blob: d291158c2f5b50b6f589f1ec2d96ef48813b41d4 [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
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200356 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
357 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200358 assert(json != NULL);
359
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200360 qstring_append_chr(json, '\n');
361 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200362
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200363 QDECREF(json);
364}
365
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200366static void monitor_protocol_emitter(Monitor *mon, QObject *data)
367{
368 QDict *qmp;
369
370 qmp = qdict_new();
371
372 if (!monitor_has_error(mon)) {
373 /* success response */
374 if (data) {
375 qobject_incref(data);
376 qdict_put_obj(qmp, "return", data);
377 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200378 /* return an empty QDict by default */
379 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200380 }
381 } else {
382 /* error response */
Markus Armbruster77e595e2009-12-07 21:37:16 +0100383 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200384 qdict_put(qmp, "error", mon->error->error);
385 QINCREF(mon->error->error);
386 QDECREF(mon->error);
387 mon->error = NULL;
388 }
389
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200390 if (mon->mc->id) {
391 qdict_put_obj(qmp, "id", mon->mc->id);
392 mon->mc->id = NULL;
393 }
394
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200395 monitor_json_emitter(mon, QOBJECT(qmp));
396 QDECREF(qmp);
397}
398
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200399static void timestamp_put(QDict *qdict)
400{
401 int err;
402 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000403 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200404
Blue Swirld08d6f02009-12-04 18:06:39 +0000405 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200406 if (err < 0)
407 return;
408
409 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
410 "'microseconds': %" PRId64 " }",
411 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200412 qdict_put_obj(qdict, "timestamp", obj);
413}
414
415/**
416 * monitor_protocol_event(): Generate a Monitor event
417 *
418 * Event-specific data can be emitted through the (optional) 'data' parameter.
419 */
420void monitor_protocol_event(MonitorEvent event, QObject *data)
421{
422 QDict *qmp;
423 const char *event_name;
Adam Litkef039a562010-01-15 08:34:02 -0600424 Monitor *mon;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200425
Blue Swirl242cd002009-12-04 18:05:45 +0000426 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200427
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200428 switch (event) {
Blue Swirl242cd002009-12-04 18:05:45 +0000429 case QEVENT_SHUTDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200430 event_name = "SHUTDOWN";
431 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000432 case QEVENT_RESET:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200433 event_name = "RESET";
434 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000435 case QEVENT_POWERDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200436 event_name = "POWERDOWN";
437 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000438 case QEVENT_STOP:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200439 event_name = "STOP";
440 break;
Luiz Capitulino6ed2c482010-04-27 20:35:59 -0300441 case QEVENT_RESUME:
442 event_name = "RESUME";
443 break;
Luiz Capitulino586153d2010-01-14 14:50:57 -0200444 case QEVENT_VNC_CONNECTED:
445 event_name = "VNC_CONNECTED";
446 break;
Luiz Capitulino0d2ed462010-01-14 14:50:59 -0200447 case QEVENT_VNC_INITIALIZED:
448 event_name = "VNC_INITIALIZED";
449 break;
Luiz Capitulino0d72f3d2010-01-14 14:50:58 -0200450 case QEVENT_VNC_DISCONNECTED:
451 event_name = "VNC_DISCONNECTED";
452 break;
Luiz Capitulinoaa1db6e2010-02-03 12:41:00 -0200453 case QEVENT_BLOCK_IO_ERROR:
454 event_name = "BLOCK_IO_ERROR";
455 break;
Luiz Capitulino80cd3472010-02-25 12:11:44 -0300456 case QEVENT_RTC_CHANGE:
457 event_name = "RTC_CHANGE";
458 break;
Luiz Capitulino9eedeb32010-02-25 12:13:04 -0300459 case QEVENT_WATCHDOG:
460 event_name = "WATCHDOG";
461 break;
Gerd Hoffmann6f8c63f2010-10-11 18:03:51 +0200462 case QEVENT_SPICE_CONNECTED:
463 event_name = "SPICE_CONNECTED";
464 break;
465 case QEVENT_SPICE_INITIALIZED:
466 event_name = "SPICE_INITIALIZED";
467 break;
468 case QEVENT_SPICE_DISCONNECTED:
469 event_name = "SPICE_DISCONNECTED";
470 break;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200471 default:
472 abort();
473 break;
474 }
475
476 qmp = qdict_new();
477 timestamp_put(qmp);
478 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200479 if (data) {
480 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200481 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200482 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200483
Adam Litkef039a562010-01-15 08:34:02 -0600484 QLIST_FOREACH(mon, &mon_list, entry) {
Luiz Capitulino09069b12010-02-04 18:10:06 -0200485 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
Luiz Capitulino23fabed2010-01-20 10:37:59 -0200486 monitor_json_emitter(mon, QOBJECT(qmp));
487 }
Adam Litkef039a562010-01-15 08:34:02 -0600488 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200489 QDECREF(qmp);
490}
491
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200492static int do_qmp_capabilities(Monitor *mon, const QDict *params,
493 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200494{
495 /* Will setup QMP capabilities in the future */
496 if (monitor_ctrl_mode(mon)) {
497 mon->mc->command_mode = 1;
498 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200499
500 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200501}
502
Luiz Capitulino0268d972010-10-22 10:08:02 -0200503static int mon_set_cpu(int cpu_index);
504static void handle_user_command(Monitor *mon, const char *cmdline);
505
506static int do_hmp_passthrough(Monitor *mon, const QDict *params,
507 QObject **ret_data)
508{
509 int ret = 0;
510 Monitor *old_mon, hmp;
511 CharDriverState mchar;
512
513 memset(&hmp, 0, sizeof(hmp));
514 qemu_chr_init_mem(&mchar);
515 hmp.chr = &mchar;
516
517 old_mon = cur_mon;
518 cur_mon = &hmp;
519
520 if (qdict_haskey(params, "cpu-index")) {
521 ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
522 if (ret < 0) {
523 cur_mon = old_mon;
524 qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
525 goto out;
526 }
527 }
528
529 handle_user_command(&hmp, qdict_get_str(params, "command-line"));
530 cur_mon = old_mon;
531
532 if (qemu_chr_mem_osize(hmp.chr) > 0) {
533 *ret_data = QOBJECT(qemu_chr_mem_to_qs(hmp.chr));
534 }
535
536out:
537 qemu_chr_close_mem(hmp.chr);
538 return ret;
539}
540
bellard9dc39cb2004-03-14 21:38:27 +0000541static int compare_cmd(const char *name, const char *list)
542{
543 const char *p, *pstart;
544 int len;
545 len = strlen(name);
546 p = list;
547 for(;;) {
548 pstart = p;
549 p = strchr(p, '|');
550 if (!p)
551 p = pstart + strlen(pstart);
552 if ((p - pstart) == len && !memcmp(pstart, name, len))
553 return 1;
554 if (*p == '\0')
555 break;
556 p++;
557 }
558 return 0;
559}
560
Anthony Liguoric227f092009-10-01 16:12:16 -0500561static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
aliguori376253e2009-03-05 23:01:23 +0000562 const char *prefix, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000563{
Anthony Liguoric227f092009-10-01 16:12:16 -0500564 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000565
566 for(cmd = cmds; cmd->name != NULL; cmd++) {
567 if (!name || !strcmp(name, cmd->name))
aliguori376253e2009-03-05 23:01:23 +0000568 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
569 cmd->params, cmd->help);
bellard9dc39cb2004-03-14 21:38:27 +0000570 }
571}
572
aliguori376253e2009-03-05 23:01:23 +0000573static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000574{
575 if (name && !strcmp(name, "info")) {
aliguori376253e2009-03-05 23:01:23 +0000576 help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard9dc39cb2004-03-14 21:38:27 +0000577 } else {
aliguori376253e2009-03-05 23:01:23 +0000578 help_cmd_dump(mon, mon_cmds, "", name);
bellardf193c792004-03-21 17:06:25 +0000579 if (name && !strcmp(name, "log")) {
blueswir18662d652008-10-02 18:32:44 +0000580 const CPULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000581 monitor_printf(mon, "Log items (comma separated):\n");
582 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
bellardf193c792004-03-21 17:06:25 +0000583 for(item = cpu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000584 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000585 }
586 }
bellard9dc39cb2004-03-14 21:38:27 +0000587 }
588}
589
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300590static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300591{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300592 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300593}
594
Prerna Saxena22890ab2010-06-24 17:04:53 +0530595#ifdef CONFIG_SIMPLE_TRACE
596static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)
597{
598 const char *tp_name = qdict_get_str(qdict, "name");
599 bool new_state = qdict_get_bool(qdict, "option");
Blue Swirlf871d682010-10-13 19:14:29 +0000600 int ret = st_change_trace_event_state(tp_name, new_state);
601
602 if (!ret) {
603 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
604 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530605}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100606
607static void do_trace_file(Monitor *mon, const QDict *qdict)
608{
609 const char *op = qdict_get_try_str(qdict, "op");
610 const char *arg = qdict_get_try_str(qdict, "arg");
611
612 if (!op) {
613 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
614 } else if (!strcmp(op, "on")) {
615 st_set_trace_file_enabled(true);
616 } else if (!strcmp(op, "off")) {
617 st_set_trace_file_enabled(false);
618 } else if (!strcmp(op, "flush")) {
619 st_flush_trace_buffer();
620 } else if (!strcmp(op, "set")) {
621 if (arg) {
622 st_set_trace_file(arg);
623 }
624 } else {
625 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
626 help_cmd(mon, "trace-file");
627 }
628}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530629#endif
630
Adam Litke940cc302010-01-25 12:18:44 -0600631static void user_monitor_complete(void *opaque, QObject *ret_data)
632{
633 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
634
635 if (ret_data) {
636 data->user_print(data->mon, ret_data);
637 }
638 monitor_resume(data->mon);
639 qemu_free(data);
640}
641
642static void qmp_monitor_complete(void *opaque, QObject *ret_data)
643{
644 monitor_protocol_emitter(opaque, ret_data);
645}
646
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300647static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
648 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -0600649{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300650 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -0600651}
652
653static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
654{
655 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
656}
657
658static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
659 const QDict *params)
660{
661 int ret;
662
663 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
664 cb_data->mon = mon;
665 cb_data->user_print = cmd->user_print;
666 monitor_suspend(mon);
667 ret = cmd->mhandler.cmd_async(mon, params,
668 user_monitor_complete, cb_data);
669 if (ret < 0) {
670 monitor_resume(mon);
671 qemu_free(cb_data);
672 }
673}
674
675static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
676{
677 int ret;
678
679 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
680 cb_data->mon = mon;
681 cb_data->user_print = cmd->user_print;
682 monitor_suspend(mon);
683 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
684 if (ret < 0) {
685 monitor_resume(mon);
686 qemu_free(cb_data);
687 }
688}
689
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300690static void do_info(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000691{
Anthony Liguoric227f092009-10-01 16:12:16 -0500692 const mon_cmd_t *cmd;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300693 const char *item = qdict_get_try_str(qdict, "item");
bellard9dc39cb2004-03-14 21:38:27 +0000694
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200695 if (!item) {
bellard9dc39cb2004-03-14 21:38:27 +0000696 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200697 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300698
699 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
ths5fafdf22007-09-16 21:08:06 +0000700 if (compare_cmd(item, cmd->name))
Luiz Capitulino13c74252009-10-07 13:41:55 -0300701 break;
bellard9dc39cb2004-03-14 21:38:27 +0000702 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300703
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200704 if (cmd->name == NULL) {
Luiz Capitulino13c74252009-10-07 13:41:55 -0300705 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200706 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300707
Luiz Capitulino4903de02010-09-16 11:01:32 -0300708 if (handler_is_async(cmd)) {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300709 user_async_info_handler(mon, cmd);
Luiz Capitulino9e807212010-09-16 10:58:59 -0300710 } else if (handler_is_qobject(cmd)) {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300711 QObject *info_data = NULL;
Jan Kiszkaa6c4d362010-06-28 18:27:47 +0200712
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300713 cmd->mhandler.info_new(mon, &info_data);
714 if (info_data) {
715 cmd->user_print(mon, info_data);
716 qobject_decref(info_data);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200717 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300718 } else {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300719 cmd->mhandler.info(mon);
Luiz Capitulino13c74252009-10-07 13:41:55 -0300720 }
721
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300722 return;
Luiz Capitulino13c74252009-10-07 13:41:55 -0300723
724help:
725 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +0000726}
727
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200728static void do_info_version_print(Monitor *mon, const QObject *data)
729{
730 QDict *qdict;
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300731 QDict *qemu;
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200732
733 qdict = qobject_to_qdict(data);
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300734 qemu = qdict_get_qdict(qdict, "qemu");
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200735
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300736 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
737 qdict_get_int(qemu, "major"),
738 qdict_get_int(qemu, "minor"),
739 qdict_get_int(qemu, "micro"),
740 qdict_get_str(qdict, "package"));
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200741}
742
Luiz Capitulinoab2d3182009-10-07 13:42:02 -0300743static void do_info_version(Monitor *mon, QObject **ret_data)
bellard9bc9d1c2004-10-10 15:15:51 +0000744{
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300745 const char *version = QEMU_VERSION;
746 int major = 0, minor = 0, micro = 0;
747 char *tmp;
748
749 major = strtol(version, &tmp, 10);
750 tmp++;
751 minor = strtol(tmp, &tmp, 10);
752 tmp++;
753 micro = strtol(tmp, &tmp, 10);
754
755 *ret_data = qobject_from_jsonf("{ 'qemu': { 'major': %d, 'minor': %d, \
756 'micro': %d }, 'package': %s }", major, minor, micro, QEMU_PKGVERSION);
bellard9bc9d1c2004-10-10 15:15:51 +0000757}
758
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200759static void do_info_name_print(Monitor *mon, const QObject *data)
thsc35734b2007-03-19 15:17:08 +0000760{
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200761 QDict *qdict;
762
763 qdict = qobject_to_qdict(data);
764 if (qdict_size(qdict) == 0) {
765 return;
766 }
767
768 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
769}
770
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200771static void do_info_name(Monitor *mon, QObject **ret_data)
772{
773 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
774 qobject_from_jsonf("{}");
thsc35734b2007-03-19 15:17:08 +0000775}
776
Luiz Capitulino1a728672009-12-10 17:15:56 -0200777static QObject *get_cmd_dict(const char *name)
778{
779 const char *p;
780
781 /* Remove '|' from some commands */
782 p = strchr(name, '|');
783 if (p) {
784 p++;
785 } else {
786 p = name;
787 }
788
789 return qobject_from_jsonf("{ 'name': %s }", p);
790}
791
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200792static void do_info_commands(Monitor *mon, QObject **ret_data)
793{
794 QList *cmd_list;
795 const mon_cmd_t *cmd;
796
797 cmd_list = qlist_new();
798
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300799 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino2e061a72010-09-16 10:36:54 -0300800 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200801 }
802
Luiz Capitulino3e12a752010-09-15 17:20:33 -0300803 for (cmd = qmp_query_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino2e061a72010-09-16 10:36:54 -0300804 char buf[128];
805 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
806 qlist_append_obj(cmd_list, get_cmd_dict(buf));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200807 }
808
809 *ret_data = QOBJECT(cmd_list);
810}
811
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200812static void do_info_uuid_print(Monitor *mon, const QObject *data)
blueswir1f1f23ad2008-09-18 18:30:20 +0000813{
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200814 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
815}
816
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200817static void do_info_uuid(Monitor *mon, QObject **ret_data)
818{
819 char uuid[64];
820
821 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
aliguori376253e2009-03-05 23:01:23 +0000822 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
823 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
824 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
825 qemu_uuid[14], qemu_uuid[15]);
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200826 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
thsa36e69d2007-12-02 05:18:19 +0000827}
828
bellard6a00d602005-11-21 23:25:50 +0000829/* get the current CPU defined by the user */
pbrook9596ebb2007-11-18 01:44:38 +0000830static int mon_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000831{
832 CPUState *env;
833
834 for(env = first_cpu; env != NULL; env = env->next_cpu) {
835 if (env->cpu_index == cpu_index) {
aliguori731b0362009-03-05 23:01:42 +0000836 cur_mon->mon_cpu = env;
bellard6a00d602005-11-21 23:25:50 +0000837 return 0;
838 }
839 }
840 return -1;
841}
842
pbrook9596ebb2007-11-18 01:44:38 +0000843static CPUState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +0000844{
aliguori731b0362009-03-05 23:01:42 +0000845 if (!cur_mon->mon_cpu) {
bellard6a00d602005-11-21 23:25:50 +0000846 mon_set_cpu(0);
847 }
Avi Kivity4c0960c2009-08-17 23:19:53 +0300848 cpu_synchronize_state(cur_mon->mon_cpu);
aliguori731b0362009-03-05 23:01:42 +0000849 return cur_mon->mon_cpu;
bellard6a00d602005-11-21 23:25:50 +0000850}
851
aliguori376253e2009-03-05 23:01:23 +0000852static void do_info_registers(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +0000853{
bellard6a00d602005-11-21 23:25:50 +0000854 CPUState *env;
855 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +0000856#ifdef TARGET_I386
aliguori376253e2009-03-05 23:01:23 +0000857 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellardd24b15a2005-07-03 21:28:00 +0000858 X86_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +0000859#else
aliguori376253e2009-03-05 23:01:23 +0000860 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard7fe48482004-10-09 18:08:01 +0000861 0);
bellard9307c4c2004-04-04 12:57:25 +0000862#endif
863}
864
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300865static void print_cpu_iter(QObject *obj, void *opaque)
866{
867 QDict *cpu;
868 int active = ' ';
869 Monitor *mon = opaque;
870
871 assert(qobject_type(obj) == QTYPE_QDICT);
872 cpu = qobject_to_qdict(obj);
873
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200874 if (qdict_get_bool(cpu, "current")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300875 active = '*';
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200876 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300877
878 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
879
880#if defined(TARGET_I386)
881 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
882 (target_ulong) qdict_get_int(cpu, "pc"));
883#elif defined(TARGET_PPC)
884 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
885 (target_long) qdict_get_int(cpu, "nip"));
886#elif defined(TARGET_SPARC)
887 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
888 (target_long) qdict_get_int(cpu, "pc"));
889 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
890 (target_long) qdict_get_int(cpu, "npc"));
891#elif defined(TARGET_MIPS)
892 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
893 (target_long) qdict_get_int(cpu, "PC"));
894#endif
895
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200896 if (qdict_get_bool(cpu, "halted")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300897 monitor_printf(mon, " (halted)");
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200898 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300899
900 monitor_printf(mon, "\n");
901}
902
903static void monitor_print_cpus(Monitor *mon, const QObject *data)
904{
905 QList *cpu_list;
906
907 assert(qobject_type(data) == QTYPE_QLIST);
908 cpu_list = qobject_to_qlist(data);
909 qlist_iter(cpu_list, print_cpu_iter, mon);
910}
911
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300912static void do_info_cpus(Monitor *mon, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000913{
914 CPUState *env;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300915 QList *cpu_list;
916
917 cpu_list = qlist_new();
bellard6a00d602005-11-21 23:25:50 +0000918
919 /* just to set the default cpu if not already done */
920 mon_get_cpu();
921
922 for(env = first_cpu; env != NULL; env = env->next_cpu) {
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200923 QDict *cpu;
924 QObject *obj;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300925
Avi Kivity4c0960c2009-08-17 23:19:53 +0300926 cpu_synchronize_state(env);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300927
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200928 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
929 env->cpu_index, env == mon->mon_cpu,
930 env->halted);
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200931
932 cpu = qobject_to_qdict(obj);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300933
bellard6a00d602005-11-21 23:25:50 +0000934#if defined(TARGET_I386)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300935 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
bellarde80e1cc2005-11-23 22:05:28 +0000936#elif defined(TARGET_PPC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300937 qdict_put(cpu, "nip", qint_from_int(env->nip));
bellardba3c64f2005-12-05 20:31:52 +0000938#elif defined(TARGET_SPARC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300939 qdict_put(cpu, "pc", qint_from_int(env->pc));
940 qdict_put(cpu, "npc", qint_from_int(env->npc));
thsead93602007-09-06 00:18:15 +0000941#elif defined(TARGET_MIPS)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300942 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
bellardce5232c2008-05-28 17:14:10 +0000943#endif
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300944
945 qlist_append(cpu_list, cpu);
bellard6a00d602005-11-21 23:25:50 +0000946 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300947
948 *ret_data = QOBJECT(cpu_list);
bellard6a00d602005-11-21 23:25:50 +0000949}
950
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200951static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000952{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300953 int index = qdict_get_int(qdict, "index");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200954 if (mon_set_cpu(index) < 0) {
Markus Armbrustere17ba872010-03-25 17:22:36 +0100955 qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",
956 "a CPU number");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200957 return -1;
958 }
959 return 0;
bellard6a00d602005-11-21 23:25:50 +0000960}
961
aliguori376253e2009-03-05 23:01:23 +0000962static void do_info_jit(Monitor *mon)
bellarde3db7222005-01-26 22:00:47 +0000963{
aliguori376253e2009-03-05 23:01:23 +0000964 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +0000965}
966
aliguori376253e2009-03-05 23:01:23 +0000967static void do_info_history(Monitor *mon)
bellardaa455482004-04-04 13:07:25 +0000968{
969 int i;
bellard7e2515e2004-08-01 21:52:19 +0000970 const char *str;
ths3b46e622007-09-17 08:09:54 +0000971
aliguoricde76ee2009-03-05 23:01:51 +0000972 if (!mon->rs)
973 return;
bellard7e2515e2004-08-01 21:52:19 +0000974 i = 0;
975 for(;;) {
aliguori731b0362009-03-05 23:01:42 +0000976 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +0000977 if (!str)
978 break;
aliguori376253e2009-03-05 23:01:23 +0000979 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +0000980 i++;
bellardaa455482004-04-04 13:07:25 +0000981 }
982}
983
j_mayer76a66252007-03-07 08:32:30 +0000984#if defined(TARGET_PPC)
985/* XXX: not implemented in other targets */
aliguori376253e2009-03-05 23:01:23 +0000986static void do_info_cpu_stats(Monitor *mon)
j_mayer76a66252007-03-07 08:32:30 +0000987{
988 CPUState *env;
989
990 env = mon_get_cpu();
aliguori376253e2009-03-05 23:01:23 +0000991 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +0000992}
993#endif
994
Prerna Saxena22890ab2010-06-24 17:04:53 +0530995#if defined(CONFIG_SIMPLE_TRACE)
996static void do_info_trace(Monitor *mon)
997{
998 st_print_trace((FILE *)mon, &monitor_fprintf);
999}
1000
1001static void do_info_trace_events(Monitor *mon)
1002{
1003 st_print_trace_events((FILE *)mon, &monitor_fprintf);
1004}
1005#endif
1006
Luiz Capitulinob223f352009-10-07 13:41:56 -03001007/**
1008 * do_quit(): Quit QEMU execution
1009 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001010static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard9dc39cb2004-03-14 21:38:27 +00001011{
Luiz Capitulino39b59d22010-05-11 18:08:20 -03001012 monitor_suspend(mon);
1013 no_shutdown = 0;
1014 qemu_system_shutdown_request();
1015
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001016 return 0;
bellard9dc39cb2004-03-14 21:38:27 +00001017}
1018
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001019static int change_vnc_password(const char *password)
aliguoribb5fc202009-03-05 23:01:15 +00001020{
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001021 if (vnc_display_password(NULL, password) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001022 qerror_report(QERR_SET_PASSWD_FAILED);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001023 return -1;
1024 }
aliguoribb5fc202009-03-05 23:01:15 +00001025
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001026 return 0;
Markus Armbruster2895e072009-12-07 21:37:01 +01001027}
1028
1029static void change_vnc_password_cb(Monitor *mon, const char *password,
1030 void *opaque)
1031{
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001032 change_vnc_password(password);
aliguori731b0362009-03-05 23:01:42 +00001033 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00001034}
1035
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001036static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
thse25a5822007-08-25 01:36:20 +00001037{
ths70848512007-08-25 01:37:05 +00001038 if (strcmp(target, "passwd") == 0 ||
aliguori28a76be2009-03-06 20:27:40 +00001039 strcmp(target, "password") == 0) {
1040 if (arg) {
aliguoribb5fc202009-03-05 23:01:15 +00001041 char password[9];
aliguori28a76be2009-03-06 20:27:40 +00001042 strncpy(password, arg, sizeof(password));
1043 password[sizeof(password) - 1] = '\0';
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001044 return change_vnc_password(password);
aliguoribb5fc202009-03-05 23:01:15 +00001045 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001046 return monitor_read_password(mon, change_vnc_password_cb, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001047 }
ths70848512007-08-25 01:37:05 +00001048 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001049 if (vnc_display_open(NULL, target) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001050 qerror_report(QERR_VNC_SERVER_FAILED, target);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001051 return -1;
1052 }
ths70848512007-08-25 01:37:05 +00001053 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001054
1055 return 0;
thse25a5822007-08-25 01:36:20 +00001056}
1057
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001058/**
1059 * do_change(): Change a removable medium, or VNC configuration
1060 */
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001061static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
thse25a5822007-08-25 01:36:20 +00001062{
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001063 const char *device = qdict_get_str(qdict, "device");
1064 const char *target = qdict_get_str(qdict, "target");
1065 const char *arg = qdict_get_try_str(qdict, "arg");
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001066 int ret;
1067
thse25a5822007-08-25 01:36:20 +00001068 if (strcmp(device, "vnc") == 0) {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001069 ret = do_change_vnc(mon, target, arg);
thse25a5822007-08-25 01:36:20 +00001070 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001071 ret = do_change_block(mon, device, target, arg);
thse25a5822007-08-25 01:36:20 +00001072 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001073
1074 return ret;
thse25a5822007-08-25 01:36:20 +00001075}
1076
Gerd Hoffmann75721502010-10-07 12:22:54 +02001077static int set_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1078{
1079 const char *protocol = qdict_get_str(qdict, "protocol");
1080 const char *password = qdict_get_str(qdict, "password");
1081 const char *connected = qdict_get_try_str(qdict, "connected");
1082 int disconnect_if_connected = 0;
1083 int fail_if_connected = 0;
1084 int rc;
1085
1086 if (connected) {
1087 if (strcmp(connected, "fail") == 0) {
1088 fail_if_connected = 1;
1089 } else if (strcmp(connected, "disconnect") == 0) {
1090 disconnect_if_connected = 1;
1091 } else if (strcmp(connected, "keep") == 0) {
1092 /* nothing */
1093 } else {
1094 qerror_report(QERR_INVALID_PARAMETER, "connected");
1095 return -1;
1096 }
1097 }
1098
1099 if (strcmp(protocol, "spice") == 0) {
1100 if (!using_spice) {
1101 /* correct one? spice isn't a device ,,, */
1102 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1103 return -1;
1104 }
1105 rc = qemu_spice_set_passwd(password, fail_if_connected,
1106 disconnect_if_connected);
1107 if (rc != 0) {
1108 qerror_report(QERR_SET_PASSWD_FAILED);
1109 return -1;
1110 }
1111 return 0;
1112 }
1113
1114 if (strcmp(protocol, "vnc") == 0) {
1115 if (fail_if_connected || disconnect_if_connected) {
1116 /* vnc supports "connected=keep" only */
1117 qerror_report(QERR_INVALID_PARAMETER, "connected");
1118 return -1;
1119 }
1120 rc = vnc_display_password(NULL, password);
1121 if (rc != 0) {
1122 qerror_report(QERR_SET_PASSWD_FAILED);
1123 return -1;
1124 }
1125 return 0;
1126 }
1127
1128 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1129 return -1;
1130}
1131
1132static int expire_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1133{
1134 const char *protocol = qdict_get_str(qdict, "protocol");
1135 const char *whenstr = qdict_get_str(qdict, "time");
1136 time_t when;
1137 int rc;
1138
1139 if (strcmp(whenstr, "now")) {
1140 when = 0;
1141 } else if (strcmp(whenstr, "never")) {
1142 when = TIME_MAX;
1143 } else if (whenstr[0] == '+') {
1144 when = time(NULL) + strtoull(whenstr+1, NULL, 10);
1145 } else {
1146 when = strtoull(whenstr, NULL, 10);
1147 }
1148
1149 if (strcmp(protocol, "spice") == 0) {
1150 if (!using_spice) {
1151 /* correct one? spice isn't a device ,,, */
1152 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1153 return -1;
1154 }
1155 rc = qemu_spice_set_pw_expire(when);
1156 if (rc != 0) {
1157 qerror_report(QERR_SET_PASSWD_FAILED);
1158 return -1;
1159 }
1160 return 0;
1161 }
1162
1163 if (strcmp(protocol, "vnc") == 0) {
1164 rc = vnc_display_pw_expire(NULL, when);
1165 if (rc != 0) {
1166 qerror_report(QERR_SET_PASSWD_FAILED);
1167 return -1;
1168 }
1169 return 0;
1170 }
1171
1172 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1173 return -1;
1174}
1175
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001176static int do_screen_dump(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard59a983b2004-03-17 23:17:16 +00001177{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001178 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001179 return 0;
bellard59a983b2004-03-17 23:17:16 +00001180}
1181
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001182static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001183{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001184 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001185}
1186
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001187static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001188{
1189 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001190 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001191
bellard9307c4c2004-04-04 12:57:25 +00001192 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001193 mask = 0;
1194 } else {
bellard9307c4c2004-04-04 12:57:25 +00001195 mask = cpu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001196 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001197 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001198 return;
1199 }
1200 }
1201 cpu_set_log(mask);
1202}
1203
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001204static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001205{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001206 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001207 if (!option || !strcmp(option, "on")) {
1208 singlestep = 1;
1209 } else if (!strcmp(option, "off")) {
1210 singlestep = 0;
1211 } else {
1212 monitor_printf(mon, "unexpected option %s\n", option);
1213 }
1214}
1215
Luiz Capitulinoe0c97bd2009-10-07 13:41:57 -03001216/**
1217 * do_stop(): Stop VM execution
1218 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001219static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard8a7ddc32004-03-31 19:00:16 +00001220{
1221 vm_stop(EXCP_INTERRUPT);
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001222 return 0;
bellard8a7ddc32004-03-31 19:00:16 +00001223}
1224
aliguoribb5fc202009-03-05 23:01:15 +00001225static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
aliguoric0f4ce72009-03-05 23:01:01 +00001226
aliguori376253e2009-03-05 23:01:23 +00001227struct bdrv_iterate_context {
1228 Monitor *mon;
1229 int err;
1230};
aliguoric0f4ce72009-03-05 23:01:01 +00001231
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001232/**
1233 * do_cont(): Resume emulation.
1234 */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001235static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori376253e2009-03-05 23:01:23 +00001236{
1237 struct bdrv_iterate_context context = { mon, 0 };
1238
Amit Shah8e848652010-07-27 15:49:19 +05301239 if (incoming_expected) {
1240 qerror_report(QERR_MIGRATION_EXPECTED);
1241 return -1;
1242 }
aliguori376253e2009-03-05 23:01:23 +00001243 bdrv_iterate(encrypted_bdrv_it, &context);
aliguoric0f4ce72009-03-05 23:01:01 +00001244 /* only resume the vm if all keys are set and valid */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001245 if (!context.err) {
aliguoric0f4ce72009-03-05 23:01:01 +00001246 vm_start();
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001247 return 0;
1248 } else {
1249 return -1;
1250 }
bellard8a7ddc32004-03-31 19:00:16 +00001251}
1252
aliguoribb5fc202009-03-05 23:01:15 +00001253static void bdrv_key_cb(void *opaque, int err)
1254{
aliguori376253e2009-03-05 23:01:23 +00001255 Monitor *mon = opaque;
1256
aliguoribb5fc202009-03-05 23:01:15 +00001257 /* another key was set successfully, retry to continue */
1258 if (!err)
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001259 do_cont(mon, NULL, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001260}
1261
1262static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1263{
aliguori376253e2009-03-05 23:01:23 +00001264 struct bdrv_iterate_context *context = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00001265
aliguori376253e2009-03-05 23:01:23 +00001266 if (!context->err && bdrv_key_required(bs)) {
1267 context->err = -EBUSY;
1268 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1269 context->mon);
aliguoribb5fc202009-03-05 23:01:15 +00001270 }
1271}
1272
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001273static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001274{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001275 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001276 if (!device)
1277 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1278 if (gdbserver_start(device) < 0) {
1279 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1280 device);
1281 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001282 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001283 } else {
aliguori59030a82009-04-05 18:43:41 +00001284 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1285 device);
bellard8a7ddc32004-03-31 19:00:16 +00001286 }
1287}
1288
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001289static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001290{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001291 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001292 if (select_watchdog_action(action) == -1) {
1293 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1294 }
1295}
1296
aliguori376253e2009-03-05 23:01:23 +00001297static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001298{
aliguori376253e2009-03-05 23:01:23 +00001299 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001300 switch(c) {
1301 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001302 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001303 break;
1304 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001305 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001306 break;
1307 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001308 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001309 break;
1310 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001311 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001312 break;
1313 default:
1314 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001315 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001316 } else {
aliguori376253e2009-03-05 23:01:23 +00001317 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001318 }
1319 break;
1320 }
aliguori376253e2009-03-05 23:01:23 +00001321 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001322}
1323
aliguori376253e2009-03-05 23:01:23 +00001324static void memory_dump(Monitor *mon, int count, int format, int wsize,
Anthony Liguoric227f092009-10-01 16:12:16 -05001325 target_phys_addr_t addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001326{
bellard6a00d602005-11-21 23:25:50 +00001327 CPUState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001328 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001329 uint8_t buf[16];
1330 uint64_t v;
1331
1332 if (format == 'i') {
1333 int flags;
1334 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001335 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001336#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001337 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001338 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001339 } else if (wsize == 4) {
1340 flags = 0;
1341 } else {
bellard6a15fd12006-04-12 21:07:07 +00001342 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001343 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001344 if (env) {
1345#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001346 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001347 (env->segs[R_CS].flags & DESC_L_MASK))
1348 flags = 2;
1349 else
1350#endif
1351 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1352 flags = 1;
1353 }
bellard4c27ba22004-04-25 18:05:08 +00001354 }
1355#endif
aliguori376253e2009-03-05 23:01:23 +00001356 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001357 return;
1358 }
1359
1360 len = wsize * count;
1361 if (wsize == 1)
1362 line_size = 8;
1363 else
1364 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001365 max_digits = 0;
1366
1367 switch(format) {
1368 case 'o':
1369 max_digits = (wsize * 8 + 2) / 3;
1370 break;
1371 default:
1372 case 'x':
1373 max_digits = (wsize * 8) / 4;
1374 break;
1375 case 'u':
1376 case 'd':
1377 max_digits = (wsize * 8 * 10 + 32) / 33;
1378 break;
1379 case 'c':
1380 wsize = 1;
1381 break;
1382 }
1383
1384 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001385 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001386 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001387 else
aliguori376253e2009-03-05 23:01:23 +00001388 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001389 l = len;
1390 if (l > line_size)
1391 l = line_size;
1392 if (is_physical) {
1393 cpu_physical_memory_rw(addr, buf, l, 0);
1394 } else {
bellard6a00d602005-11-21 23:25:50 +00001395 env = mon_get_cpu();
aliguoric8f79b62008-08-18 14:00:20 +00001396 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001397 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001398 break;
1399 }
bellard9307c4c2004-04-04 12:57:25 +00001400 }
ths5fafdf22007-09-16 21:08:06 +00001401 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001402 while (i < l) {
1403 switch(wsize) {
1404 default:
1405 case 1:
1406 v = ldub_raw(buf + i);
1407 break;
1408 case 2:
1409 v = lduw_raw(buf + i);
1410 break;
1411 case 4:
bellard92a31b12005-02-10 22:00:52 +00001412 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001413 break;
1414 case 8:
1415 v = ldq_raw(buf + i);
1416 break;
1417 }
aliguori376253e2009-03-05 23:01:23 +00001418 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001419 switch(format) {
1420 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001421 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001422 break;
1423 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001424 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001425 break;
1426 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001427 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001428 break;
1429 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001430 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001431 break;
1432 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001433 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001434 break;
1435 }
1436 i += wsize;
1437 }
aliguori376253e2009-03-05 23:01:23 +00001438 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001439 addr += l;
1440 len -= l;
1441 }
1442}
1443
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001444static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001445{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001446 int count = qdict_get_int(qdict, "count");
1447 int format = qdict_get_int(qdict, "format");
1448 int size = qdict_get_int(qdict, "size");
1449 target_long addr = qdict_get_int(qdict, "addr");
1450
aliguori376253e2009-03-05 23:01:23 +00001451 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001452}
1453
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001454static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001455{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001456 int count = qdict_get_int(qdict, "count");
1457 int format = qdict_get_int(qdict, "format");
1458 int size = qdict_get_int(qdict, "size");
Anthony Liguoric227f092009-10-01 16:12:16 -05001459 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001460
aliguori376253e2009-03-05 23:01:23 +00001461 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001462}
1463
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001464static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001465{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001466 int format = qdict_get_int(qdict, "format");
Anthony Liguoric227f092009-10-01 16:12:16 -05001467 target_phys_addr_t val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001468
blueswir17743e582007-09-24 18:39:04 +00001469#if TARGET_PHYS_ADDR_BITS == 32
bellard9307c4c2004-04-04 12:57:25 +00001470 switch(format) {
1471 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001472 monitor_printf(mon, "%#o", val);
bellard9307c4c2004-04-04 12:57:25 +00001473 break;
1474 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001475 monitor_printf(mon, "%#x", val);
bellard9307c4c2004-04-04 12:57:25 +00001476 break;
1477 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001478 monitor_printf(mon, "%u", val);
bellard9307c4c2004-04-04 12:57:25 +00001479 break;
1480 default:
1481 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001482 monitor_printf(mon, "%d", val);
bellard9307c4c2004-04-04 12:57:25 +00001483 break;
1484 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001485 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001486 break;
1487 }
bellard92a31b12005-02-10 22:00:52 +00001488#else
1489 switch(format) {
1490 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001491 monitor_printf(mon, "%#" PRIo64, val);
bellard92a31b12005-02-10 22:00:52 +00001492 break;
1493 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001494 monitor_printf(mon, "%#" PRIx64, val);
bellard92a31b12005-02-10 22:00:52 +00001495 break;
1496 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001497 monitor_printf(mon, "%" PRIu64, val);
bellard92a31b12005-02-10 22:00:52 +00001498 break;
1499 default:
1500 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001501 monitor_printf(mon, "%" PRId64, val);
bellard92a31b12005-02-10 22:00:52 +00001502 break;
1503 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001504 monitor_printc(mon, val);
bellard92a31b12005-02-10 22:00:52 +00001505 break;
1506 }
1507#endif
aliguori376253e2009-03-05 23:01:23 +00001508 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001509}
1510
Luiz Capitulino98696222010-02-10 23:49:58 -02001511static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellardb371dc52007-01-03 15:20:39 +00001512{
1513 FILE *f;
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001514 uint32_t size = qdict_get_int(qdict, "size");
1515 const char *filename = qdict_get_str(qdict, "filename");
1516 target_long addr = qdict_get_int(qdict, "val");
bellardb371dc52007-01-03 15:20:39 +00001517 uint32_t l;
1518 CPUState *env;
1519 uint8_t buf[1024];
Luiz Capitulino98696222010-02-10 23:49:58 -02001520 int ret = -1;
bellardb371dc52007-01-03 15:20:39 +00001521
1522 env = mon_get_cpu();
bellardb371dc52007-01-03 15:20:39 +00001523
1524 f = fopen(filename, "wb");
1525 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001526 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulino98696222010-02-10 23:49:58 -02001527 return -1;
bellardb371dc52007-01-03 15:20:39 +00001528 }
1529 while (size != 0) {
1530 l = sizeof(buf);
1531 if (l > size)
1532 l = size;
1533 cpu_memory_rw_debug(env, addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001534 if (fwrite(buf, 1, l, f) != l) {
1535 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1536 goto exit;
1537 }
bellardb371dc52007-01-03 15:20:39 +00001538 addr += l;
1539 size -= l;
1540 }
Luiz Capitulino98696222010-02-10 23:49:58 -02001541
1542 ret = 0;
1543
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001544exit:
bellardb371dc52007-01-03 15:20:39 +00001545 fclose(f);
Luiz Capitulino98696222010-02-10 23:49:58 -02001546 return ret;
bellardb371dc52007-01-03 15:20:39 +00001547}
1548
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001549static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
Luiz Capitulino18f5a8b2009-10-16 12:23:44 -03001550 QObject **ret_data)
aurel32a8bdf7a2008-04-11 21:36:14 +00001551{
1552 FILE *f;
1553 uint32_t l;
1554 uint8_t buf[1024];
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001555 uint32_t size = qdict_get_int(qdict, "size");
1556 const char *filename = qdict_get_str(qdict, "filename");
Anthony Liguoric227f092009-10-01 16:12:16 -05001557 target_phys_addr_t addr = qdict_get_int(qdict, "val");
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001558 int ret = -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001559
1560 f = fopen(filename, "wb");
1561 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001562 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001563 return -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001564 }
1565 while (size != 0) {
1566 l = sizeof(buf);
1567 if (l > size)
1568 l = size;
1569 cpu_physical_memory_rw(addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001570 if (fwrite(buf, 1, l, f) != l) {
1571 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1572 goto exit;
1573 }
aurel32a8bdf7a2008-04-11 21:36:14 +00001574 fflush(f);
1575 addr += l;
1576 size -= l;
1577 }
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001578
1579 ret = 0;
1580
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001581exit:
aurel32a8bdf7a2008-04-11 21:36:14 +00001582 fclose(f);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001583 return ret;
aurel32a8bdf7a2008-04-11 21:36:14 +00001584}
1585
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001586static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001587{
1588 uint32_t addr;
1589 uint8_t buf[1];
1590 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001591 uint32_t start = qdict_get_int(qdict, "start");
1592 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001593
1594 sum = 0;
1595 for(addr = start; addr < (start + size); addr++) {
1596 cpu_physical_memory_rw(addr, buf, 1, 0);
1597 /* BSD sum algorithm ('sum' Unix command) */
1598 sum = (sum >> 1) | (sum << 15);
1599 sum += buf[0];
1600 }
aliguori376253e2009-03-05 23:01:23 +00001601 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001602}
1603
bellarda3a91a32004-06-04 11:06:21 +00001604typedef struct {
1605 int keycode;
1606 const char *name;
1607} KeyDef;
1608
1609static const KeyDef key_defs[] = {
1610 { 0x2a, "shift" },
1611 { 0x36, "shift_r" },
ths3b46e622007-09-17 08:09:54 +00001612
bellarda3a91a32004-06-04 11:06:21 +00001613 { 0x38, "alt" },
1614 { 0xb8, "alt_r" },
ths2ba27c72008-08-13 12:54:23 +00001615 { 0x64, "altgr" },
1616 { 0xe4, "altgr_r" },
bellarda3a91a32004-06-04 11:06:21 +00001617 { 0x1d, "ctrl" },
1618 { 0x9d, "ctrl_r" },
1619
1620 { 0xdd, "menu" },
1621
1622 { 0x01, "esc" },
1623
1624 { 0x02, "1" },
1625 { 0x03, "2" },
1626 { 0x04, "3" },
1627 { 0x05, "4" },
1628 { 0x06, "5" },
1629 { 0x07, "6" },
1630 { 0x08, "7" },
1631 { 0x09, "8" },
1632 { 0x0a, "9" },
1633 { 0x0b, "0" },
bellard64866c32006-05-07 18:03:31 +00001634 { 0x0c, "minus" },
1635 { 0x0d, "equal" },
bellarda3a91a32004-06-04 11:06:21 +00001636 { 0x0e, "backspace" },
1637
1638 { 0x0f, "tab" },
1639 { 0x10, "q" },
1640 { 0x11, "w" },
1641 { 0x12, "e" },
1642 { 0x13, "r" },
1643 { 0x14, "t" },
1644 { 0x15, "y" },
1645 { 0x16, "u" },
1646 { 0x17, "i" },
1647 { 0x18, "o" },
1648 { 0x19, "p" },
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001649 { 0x1a, "bracket_left" },
1650 { 0x1b, "bracket_right" },
bellarda3a91a32004-06-04 11:06:21 +00001651 { 0x1c, "ret" },
1652
1653 { 0x1e, "a" },
1654 { 0x1f, "s" },
1655 { 0x20, "d" },
1656 { 0x21, "f" },
1657 { 0x22, "g" },
1658 { 0x23, "h" },
1659 { 0x24, "j" },
1660 { 0x25, "k" },
1661 { 0x26, "l" },
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001662 { 0x27, "semicolon" },
1663 { 0x28, "apostrophe" },
1664 { 0x29, "grave_accent" },
bellarda3a91a32004-06-04 11:06:21 +00001665
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001666 { 0x2b, "backslash" },
bellarda3a91a32004-06-04 11:06:21 +00001667 { 0x2c, "z" },
1668 { 0x2d, "x" },
1669 { 0x2e, "c" },
1670 { 0x2f, "v" },
1671 { 0x30, "b" },
1672 { 0x31, "n" },
1673 { 0x32, "m" },
aurel329155fc42008-10-01 21:46:15 +00001674 { 0x33, "comma" },
1675 { 0x34, "dot" },
1676 { 0x35, "slash" },
ths3b46e622007-09-17 08:09:54 +00001677
balrog4d3b6f62008-02-10 16:33:14 +00001678 { 0x37, "asterisk" },
1679
bellarda3a91a32004-06-04 11:06:21 +00001680 { 0x39, "spc" },
bellard00ffa622004-06-04 13:25:15 +00001681 { 0x3a, "caps_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001682 { 0x3b, "f1" },
1683 { 0x3c, "f2" },
1684 { 0x3d, "f3" },
1685 { 0x3e, "f4" },
1686 { 0x3f, "f5" },
1687 { 0x40, "f6" },
1688 { 0x41, "f7" },
1689 { 0x42, "f8" },
1690 { 0x43, "f9" },
1691 { 0x44, "f10" },
bellard00ffa622004-06-04 13:25:15 +00001692 { 0x45, "num_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001693 { 0x46, "scroll_lock" },
1694
bellard64866c32006-05-07 18:03:31 +00001695 { 0xb5, "kp_divide" },
1696 { 0x37, "kp_multiply" },
ths0cfec832007-06-23 16:02:43 +00001697 { 0x4a, "kp_subtract" },
bellard64866c32006-05-07 18:03:31 +00001698 { 0x4e, "kp_add" },
1699 { 0x9c, "kp_enter" },
1700 { 0x53, "kp_decimal" },
balrogf2289cb2008-06-04 10:14:16 +00001701 { 0x54, "sysrq" },
bellard64866c32006-05-07 18:03:31 +00001702
1703 { 0x52, "kp_0" },
1704 { 0x4f, "kp_1" },
1705 { 0x50, "kp_2" },
1706 { 0x51, "kp_3" },
1707 { 0x4b, "kp_4" },
1708 { 0x4c, "kp_5" },
1709 { 0x4d, "kp_6" },
1710 { 0x47, "kp_7" },
1711 { 0x48, "kp_8" },
1712 { 0x49, "kp_9" },
ths3b46e622007-09-17 08:09:54 +00001713
bellarda3a91a32004-06-04 11:06:21 +00001714 { 0x56, "<" },
1715
1716 { 0x57, "f11" },
1717 { 0x58, "f12" },
1718
1719 { 0xb7, "print" },
1720
1721 { 0xc7, "home" },
1722 { 0xc9, "pgup" },
1723 { 0xd1, "pgdn" },
1724 { 0xcf, "end" },
1725
1726 { 0xcb, "left" },
1727 { 0xc8, "up" },
1728 { 0xd0, "down" },
1729 { 0xcd, "right" },
1730
1731 { 0xd2, "insert" },
1732 { 0xd3, "delete" },
blueswir1c0b5b102008-06-22 07:45:42 +00001733#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1734 { 0xf0, "stop" },
1735 { 0xf1, "again" },
1736 { 0xf2, "props" },
1737 { 0xf3, "undo" },
1738 { 0xf4, "front" },
1739 { 0xf5, "copy" },
1740 { 0xf6, "open" },
1741 { 0xf7, "paste" },
1742 { 0xf8, "find" },
1743 { 0xf9, "cut" },
1744 { 0xfa, "lf" },
1745 { 0xfb, "help" },
1746 { 0xfc, "meta_l" },
1747 { 0xfd, "meta_r" },
1748 { 0xfe, "compose" },
1749#endif
bellarda3a91a32004-06-04 11:06:21 +00001750 { 0, NULL },
1751};
1752
1753static int get_keycode(const char *key)
1754{
1755 const KeyDef *p;
bellard64866c32006-05-07 18:03:31 +00001756 char *endp;
1757 int ret;
bellarda3a91a32004-06-04 11:06:21 +00001758
1759 for(p = key_defs; p->name != NULL; p++) {
1760 if (!strcmp(key, p->name))
1761 return p->keycode;
1762 }
bellard64866c32006-05-07 18:03:31 +00001763 if (strstart(key, "0x", NULL)) {
1764 ret = strtoul(key, &endp, 0);
1765 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1766 return ret;
1767 }
bellarda3a91a32004-06-04 11:06:21 +00001768 return -1;
1769}
1770
balrogc8256f92008-06-08 22:45:01 +00001771#define MAX_KEYCODES 16
1772static uint8_t keycodes[MAX_KEYCODES];
1773static int nb_pending_keycodes;
1774static QEMUTimer *key_timer;
1775
1776static void release_keys(void *opaque)
bellarda3a91a32004-06-04 11:06:21 +00001777{
balrogc8256f92008-06-08 22:45:01 +00001778 int keycode;
1779
1780 while (nb_pending_keycodes > 0) {
1781 nb_pending_keycodes--;
1782 keycode = keycodes[nb_pending_keycodes];
1783 if (keycode & 0x80)
1784 kbd_put_keycode(0xe0);
1785 kbd_put_keycode(keycode | 0x80);
1786 }
1787}
1788
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001789static void do_sendkey(Monitor *mon, const QDict *qdict)
balrogc8256f92008-06-08 22:45:01 +00001790{
balrog3401c0d2008-06-04 10:05:59 +00001791 char keyname_buf[16];
1792 char *separator;
1793 int keyname_len, keycode, i;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001794 const char *string = qdict_get_str(qdict, "string");
1795 int has_hold_time = qdict_haskey(qdict, "hold_time");
1796 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
ths3b46e622007-09-17 08:09:54 +00001797
balrogc8256f92008-06-08 22:45:01 +00001798 if (nb_pending_keycodes > 0) {
1799 qemu_del_timer(key_timer);
1800 release_keys(NULL);
1801 }
1802 if (!has_hold_time)
1803 hold_time = 100;
1804 i = 0;
balrog3401c0d2008-06-04 10:05:59 +00001805 while (1) {
1806 separator = strchr(string, '-');
1807 keyname_len = separator ? separator - string : strlen(string);
1808 if (keyname_len > 0) {
1809 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1810 if (keyname_len > sizeof(keyname_buf) - 1) {
aliguori376253e2009-03-05 23:01:23 +00001811 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001812 return;
bellarda3a91a32004-06-04 11:06:21 +00001813 }
balrogc8256f92008-06-08 22:45:01 +00001814 if (i == MAX_KEYCODES) {
aliguori376253e2009-03-05 23:01:23 +00001815 monitor_printf(mon, "too many keys\n");
balrog3401c0d2008-06-04 10:05:59 +00001816 return;
1817 }
1818 keyname_buf[keyname_len] = 0;
1819 keycode = get_keycode(keyname_buf);
1820 if (keycode < 0) {
aliguori376253e2009-03-05 23:01:23 +00001821 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001822 return;
1823 }
balrogc8256f92008-06-08 22:45:01 +00001824 keycodes[i++] = keycode;
bellarda3a91a32004-06-04 11:06:21 +00001825 }
balrog3401c0d2008-06-04 10:05:59 +00001826 if (!separator)
bellarda3a91a32004-06-04 11:06:21 +00001827 break;
balrog3401c0d2008-06-04 10:05:59 +00001828 string = separator + 1;
bellarda3a91a32004-06-04 11:06:21 +00001829 }
balrogc8256f92008-06-08 22:45:01 +00001830 nb_pending_keycodes = i;
bellarda3a91a32004-06-04 11:06:21 +00001831 /* key down events */
balrogc8256f92008-06-08 22:45:01 +00001832 for (i = 0; i < nb_pending_keycodes; i++) {
bellarda3a91a32004-06-04 11:06:21 +00001833 keycode = keycodes[i];
1834 if (keycode & 0x80)
1835 kbd_put_keycode(0xe0);
1836 kbd_put_keycode(keycode & 0x7f);
1837 }
balrogc8256f92008-06-08 22:45:01 +00001838 /* delayed key up events */
balrogf227f172008-06-09 00:03:47 +00001839 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
Juan Quintela6ee093c2009-09-10 03:04:26 +02001840 muldiv64(get_ticks_per_sec(), hold_time, 1000));
bellarda3a91a32004-06-04 11:06:21 +00001841}
1842
bellard13224a82006-07-14 22:03:35 +00001843static int mouse_button_state;
1844
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001845static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001846{
1847 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001848 const char *dx_str = qdict_get_str(qdict, "dx_str");
1849 const char *dy_str = qdict_get_str(qdict, "dy_str");
1850 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001851 dx = strtol(dx_str, NULL, 0);
1852 dy = strtol(dy_str, NULL, 0);
1853 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001854 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001855 dz = strtol(dz_str, NULL, 0);
1856 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1857}
1858
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001859static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001860{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001861 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001862 mouse_button_state = button_state;
1863 kbd_mouse_event(0, 0, 0, mouse_button_state);
1864}
1865
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001866static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001867{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001868 int size = qdict_get_int(qdict, "size");
1869 int addr = qdict_get_int(qdict, "addr");
1870 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001871 uint32_t val;
1872 int suffix;
1873
1874 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001875 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001876 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001877 addr++;
1878 }
1879 addr &= 0xffff;
1880
1881 switch(size) {
1882 default:
1883 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001884 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001885 suffix = 'b';
1886 break;
1887 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001888 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001889 suffix = 'w';
1890 break;
1891 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001892 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001893 suffix = 'l';
1894 break;
1895 }
aliguori376253e2009-03-05 23:01:23 +00001896 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1897 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001898}
bellarda3a91a32004-06-04 11:06:21 +00001899
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001900static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001901{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001902 int size = qdict_get_int(qdict, "size");
1903 int addr = qdict_get_int(qdict, "addr");
1904 int val = qdict_get_int(qdict, "val");
1905
Jan Kiszkaf1147842009-07-14 10:20:11 +02001906 addr &= IOPORTS_MASK;
1907
1908 switch (size) {
1909 default:
1910 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001911 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001912 break;
1913 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001914 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001915 break;
1916 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001917 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001918 break;
1919 }
1920}
1921
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001922static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001923{
1924 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001925 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001926
Jan Kiszka76e30d02009-07-02 00:19:02 +02001927 res = qemu_boot_set(bootdevice);
1928 if (res == 0) {
1929 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1930 } else if (res > 0) {
1931 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001932 } else {
aliguori376253e2009-03-05 23:01:23 +00001933 monitor_printf(mon, "no function defined to set boot device list for "
1934 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001935 }
1936}
1937
Luiz Capitulinoc80d2592009-10-07 13:41:58 -03001938/**
1939 * do_system_reset(): Issue a machine reset
1940 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001941static int do_system_reset(Monitor *mon, const QDict *qdict,
1942 QObject **ret_data)
bellarde4f90822004-06-20 12:35:44 +00001943{
1944 qemu_system_reset_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001945 return 0;
bellarde4f90822004-06-20 12:35:44 +00001946}
1947
Luiz Capitulino43076662009-10-07 13:41:59 -03001948/**
1949 * do_system_powerdown(): Issue a machine powerdown
1950 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001951static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1952 QObject **ret_data)
bellard34751872005-07-02 14:31:34 +00001953{
1954 qemu_system_powerdown_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001955 return 0;
bellard34751872005-07-02 14:31:34 +00001956}
1957
bellardb86bda52004-09-18 19:32:46 +00001958#if defined(TARGET_I386)
Blue Swirld65aaf32010-12-11 18:56:24 +00001959static void print_pte(Monitor *mon, target_phys_addr_t addr,
1960 target_phys_addr_t pte,
1961 target_phys_addr_t mask)
bellardb86bda52004-09-18 19:32:46 +00001962{
Blue Swirld65aaf32010-12-11 18:56:24 +00001963#ifdef TARGET_X86_64
1964 if (addr & (1ULL << 47)) {
1965 addr |= -1LL << 48;
1966 }
1967#endif
1968 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1969 " %c%c%c%c%c%c%c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001970 addr,
1971 pte & mask,
Blue Swirld65aaf32010-12-11 18:56:24 +00001972 pte & PG_NX_MASK ? 'X' : '-',
aliguori376253e2009-03-05 23:01:23 +00001973 pte & PG_GLOBAL_MASK ? 'G' : '-',
1974 pte & PG_PSE_MASK ? 'P' : '-',
1975 pte & PG_DIRTY_MASK ? 'D' : '-',
1976 pte & PG_ACCESSED_MASK ? 'A' : '-',
1977 pte & PG_PCD_MASK ? 'C' : '-',
1978 pte & PG_PWT_MASK ? 'T' : '-',
1979 pte & PG_USER_MASK ? 'U' : '-',
1980 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001981}
1982
Blue Swirld65aaf32010-12-11 18:56:24 +00001983static void tlb_info_32(Monitor *mon, CPUState *env)
bellardb86bda52004-09-18 19:32:46 +00001984{
bellardb86bda52004-09-18 19:32:46 +00001985 int l1, l2;
1986 uint32_t pgd, pde, pte;
1987
bellardb86bda52004-09-18 19:32:46 +00001988 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)) {
Blue Swirld65aaf32010-12-11 18:56:24 +00001994 /* 4M pages */
1995 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
bellardb86bda52004-09-18 19:32:46 +00001996 } else {
1997 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00001998 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00001999 (uint8_t *)&pte, 4);
2000 pte = le32_to_cpu(pte);
2001 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00002002 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00002003 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00002004 ~0xfff);
2005 }
2006 }
2007 }
2008 }
2009 }
2010}
2011
Blue Swirld65aaf32010-12-11 18:56:24 +00002012static void tlb_info_pae32(Monitor *mon, CPUState *env)
2013{
2014 int l1, l2, l3;
2015 uint64_t pdpe, pde, pte;
2016 uint64_t pdp_addr, pd_addr, pt_addr;
2017
2018 pdp_addr = env->cr[3] & ~0x1f;
2019 for (l1 = 0; l1 < 4; l1++) {
2020 cpu_physical_memory_read(pdp_addr + l1 * 8, (uint8_t *)&pdpe, 8);
2021 pdpe = le64_to_cpu(pdpe);
2022 if (pdpe & PG_PRESENT_MASK) {
2023 pd_addr = pdpe & 0x3fffffffff000ULL;
2024 for (l2 = 0; l2 < 512; l2++) {
2025 cpu_physical_memory_read(pd_addr + l2 * 8,
2026 (uint8_t *)&pde, 8);
2027 pde = le64_to_cpu(pde);
2028 if (pde & PG_PRESENT_MASK) {
2029 if (pde & PG_PSE_MASK) {
2030 /* 2M pages with PAE, CR4.PSE is ignored */
2031 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
2032 ~((target_phys_addr_t)(1 << 20) - 1));
2033 } else {
2034 pt_addr = pde & 0x3fffffffff000ULL;
2035 for (l3 = 0; l3 < 512; l3++) {
2036 cpu_physical_memory_read(pt_addr + l3 * 8,
2037 (uint8_t *)&pte, 8);
2038 pte = le64_to_cpu(pte);
2039 if (pte & PG_PRESENT_MASK) {
2040 print_pte(mon, (l1 << 30 ) + (l2 << 21)
2041 + (l3 << 12),
2042 pte & ~PG_PSE_MASK,
2043 ~(target_phys_addr_t)0xfff);
2044 }
2045 }
2046 }
2047 }
2048 }
2049 }
2050 }
2051}
2052
2053#ifdef TARGET_X86_64
2054static void tlb_info_64(Monitor *mon, CPUState *env)
2055{
2056 uint64_t l1, l2, l3, l4;
2057 uint64_t pml4e, pdpe, pde, pte;
2058 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
2059
2060 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
2061 for (l1 = 0; l1 < 512; l1++) {
2062 cpu_physical_memory_read(pml4_addr + l1 * 8, (uint8_t *)&pml4e, 8);
2063 pml4e = le64_to_cpu(pml4e);
2064 if (pml4e & PG_PRESENT_MASK) {
2065 pdp_addr = pml4e & 0x3fffffffff000ULL;
2066 for (l2 = 0; l2 < 512; l2++) {
2067 cpu_physical_memory_read(pdp_addr + l2 * 8, (uint8_t *)&pdpe,
2068 8);
2069 pdpe = le64_to_cpu(pdpe);
2070 if (pdpe & PG_PRESENT_MASK) {
2071 if (pdpe & PG_PSE_MASK) {
2072 /* 1G pages, CR4.PSE is ignored */
2073 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
2074 0x3ffffc0000000ULL);
2075 } else {
2076 pd_addr = pdpe & 0x3fffffffff000ULL;
2077 for (l3 = 0; l3 < 512; l3++) {
2078 cpu_physical_memory_read(pd_addr + l3 * 8,
2079 (uint8_t *)&pde, 8);
2080 pde = le64_to_cpu(pde);
2081 if (pde & PG_PRESENT_MASK) {
2082 if (pde & PG_PSE_MASK) {
2083 /* 2M pages, CR4.PSE is ignored */
2084 print_pte(mon, (l1 << 39) + (l2 << 30) +
2085 (l3 << 21), pde,
2086 0x3ffffffe00000ULL);
2087 } else {
2088 pt_addr = pde & 0x3fffffffff000ULL;
2089 for (l4 = 0; l4 < 512; l4++) {
2090 cpu_physical_memory_read(pt_addr
2091 + l4 * 8,
2092 (uint8_t *)&pte,
2093 8);
2094 pte = le64_to_cpu(pte);
2095 if (pte & PG_PRESENT_MASK) {
2096 print_pte(mon, (l1 << 39) +
2097 (l2 << 30) +
2098 (l3 << 21) + (l4 << 12),
2099 pte & ~PG_PSE_MASK,
2100 0x3fffffffff000ULL);
2101 }
2102 }
2103 }
2104 }
2105 }
2106 }
2107 }
2108 }
2109 }
2110 }
2111}
2112#endif
2113
2114static void tlb_info(Monitor *mon)
2115{
2116 CPUState *env;
2117
2118 env = mon_get_cpu();
2119
2120 if (!(env->cr[0] & CR0_PG_MASK)) {
2121 monitor_printf(mon, "PG disabled\n");
2122 return;
2123 }
2124 if (env->cr[4] & CR4_PAE_MASK) {
2125#ifdef TARGET_X86_64
2126 if (env->hflags & HF_LMA_MASK) {
2127 tlb_info_64(mon, env);
2128 } else
2129#endif
2130 {
2131 tlb_info_pae32(mon, env);
2132 }
2133 } else {
2134 tlb_info_32(mon, env);
2135 }
2136}
2137
Blue Swirl1b3cba62010-12-11 18:56:27 +00002138static void mem_print(Monitor *mon, target_phys_addr_t *pstart,
2139 int *plast_prot,
2140 target_phys_addr_t end, int prot)
bellardb86bda52004-09-18 19:32:46 +00002141{
bellard9746b152004-11-11 18:30:24 +00002142 int prot1;
2143 prot1 = *plast_prot;
2144 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00002145 if (*pstart != -1) {
Blue Swirl1b3cba62010-12-11 18:56:27 +00002146 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
2147 TARGET_FMT_plx " %c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00002148 *pstart, end, end - *pstart,
2149 prot1 & PG_USER_MASK ? 'u' : '-',
2150 'r',
2151 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00002152 }
2153 if (prot != 0)
2154 *pstart = end;
2155 else
2156 *pstart = -1;
2157 *plast_prot = prot;
2158 }
2159}
2160
Blue Swirl1b3cba62010-12-11 18:56:27 +00002161static void mem_info_32(Monitor *mon, CPUState *env)
bellardb86bda52004-09-18 19:32:46 +00002162{
bellardb86bda52004-09-18 19:32:46 +00002163 int l1, l2, prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00002164 uint32_t pgd, pde, pte;
2165 target_phys_addr_t start, end;
bellardb86bda52004-09-18 19:32:46 +00002166
bellardb86bda52004-09-18 19:32:46 +00002167 pgd = env->cr[3] & ~0xfff;
2168 last_prot = 0;
2169 start = -1;
2170 for(l1 = 0; l1 < 1024; l1++) {
2171 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
2172 pde = le32_to_cpu(pde);
2173 end = l1 << 22;
2174 if (pde & PG_PRESENT_MASK) {
2175 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2176 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00002177 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002178 } else {
2179 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00002180 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00002181 (uint8_t *)&pte, 4);
2182 pte = le32_to_cpu(pte);
2183 end = (l1 << 22) + (l2 << 12);
2184 if (pte & PG_PRESENT_MASK) {
2185 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2186 } else {
2187 prot = 0;
2188 }
aliguori376253e2009-03-05 23:01:23 +00002189 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002190 }
2191 }
2192 } else {
2193 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00002194 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002195 }
2196 }
2197}
Blue Swirl1b3cba62010-12-11 18:56:27 +00002198
2199static void mem_info_pae32(Monitor *mon, CPUState *env)
2200{
2201 int l1, l2, l3, prot, last_prot;
2202 uint64_t pdpe, pde, pte;
2203 uint64_t pdp_addr, pd_addr, pt_addr;
2204 target_phys_addr_t start, end;
2205
2206 pdp_addr = env->cr[3] & ~0x1f;
2207 last_prot = 0;
2208 start = -1;
2209 for (l1 = 0; l1 < 4; l1++) {
2210 cpu_physical_memory_read(pdp_addr + l1 * 8, (uint8_t *)&pdpe, 8);
2211 pdpe = le64_to_cpu(pdpe);
2212 end = l1 << 30;
2213 if (pdpe & PG_PRESENT_MASK) {
2214 pd_addr = pdpe & 0x3fffffffff000ULL;
2215 for (l2 = 0; l2 < 512; l2++) {
2216 cpu_physical_memory_read(pd_addr + l2 * 8,
2217 (uint8_t *)&pde, 8);
2218 pde = le64_to_cpu(pde);
2219 end = (l1 << 30) + (l2 << 21);
2220 if (pde & PG_PRESENT_MASK) {
2221 if (pde & PG_PSE_MASK) {
2222 prot = pde & (PG_USER_MASK | PG_RW_MASK |
2223 PG_PRESENT_MASK);
2224 mem_print(mon, &start, &last_prot, end, prot);
2225 } else {
2226 pt_addr = pde & 0x3fffffffff000ULL;
2227 for (l3 = 0; l3 < 512; l3++) {
2228 cpu_physical_memory_read(pt_addr + l3 * 8,
2229 (uint8_t *)&pte, 8);
2230 pte = le64_to_cpu(pte);
2231 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
2232 if (pte & PG_PRESENT_MASK) {
2233 prot = pte & (PG_USER_MASK | PG_RW_MASK |
2234 PG_PRESENT_MASK);
2235 } else {
2236 prot = 0;
2237 }
2238 mem_print(mon, &start, &last_prot, end, prot);
2239 }
2240 }
2241 } else {
2242 prot = 0;
2243 mem_print(mon, &start, &last_prot, end, prot);
2244 }
2245 }
2246 } else {
2247 prot = 0;
2248 mem_print(mon, &start, &last_prot, end, prot);
2249 }
2250 }
2251}
2252
2253
2254#ifdef TARGET_X86_64
2255static void mem_info_64(Monitor *mon, CPUState *env)
2256{
2257 int prot, last_prot;
2258 uint64_t l1, l2, l3, l4;
2259 uint64_t pml4e, pdpe, pde, pte;
2260 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
2261
2262 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
2263 last_prot = 0;
2264 start = -1;
2265 for (l1 = 0; l1 < 512; l1++) {
2266 cpu_physical_memory_read(pml4_addr + l1 * 8, (uint8_t *)&pml4e, 8);
2267 pml4e = le64_to_cpu(pml4e);
2268 end = l1 << 39;
2269 if (pml4e & PG_PRESENT_MASK) {
2270 pdp_addr = pml4e & 0x3fffffffff000ULL;
2271 for (l2 = 0; l2 < 512; l2++) {
2272 cpu_physical_memory_read(pdp_addr + l2 * 8, (uint8_t *)&pdpe,
2273 8);
2274 pdpe = le64_to_cpu(pdpe);
2275 end = (l1 << 39) + (l2 << 30);
2276 if (pdpe & PG_PRESENT_MASK) {
2277 if (pdpe & PG_PSE_MASK) {
Blue Swirl2d5b5072011-01-15 08:31:00 +00002278 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
2279 PG_PRESENT_MASK);
Blue Swirl1b3cba62010-12-11 18:56:27 +00002280 mem_print(mon, &start, &last_prot, end, prot);
2281 } else {
2282 pd_addr = pdpe & 0x3fffffffff000ULL;
2283 for (l3 = 0; l3 < 512; l3++) {
2284 cpu_physical_memory_read(pd_addr + l3 * 8,
2285 (uint8_t *)&pde, 8);
2286 pde = le64_to_cpu(pde);
2287 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
2288 if (pde & PG_PRESENT_MASK) {
2289 if (pde & PG_PSE_MASK) {
2290 prot = pde & (PG_USER_MASK | PG_RW_MASK |
2291 PG_PRESENT_MASK);
2292 mem_print(mon, &start, &last_prot, end, prot);
2293 } else {
2294 pt_addr = pde & 0x3fffffffff000ULL;
2295 for (l4 = 0; l4 < 512; l4++) {
2296 cpu_physical_memory_read(pt_addr
2297 + l4 * 8,
2298 (uint8_t *)&pte,
2299 8);
2300 pte = le64_to_cpu(pte);
2301 end = (l1 << 39) + (l2 << 30) +
2302 (l3 << 21) + (l4 << 12);
2303 if (pte & PG_PRESENT_MASK) {
2304 prot = pte & (PG_USER_MASK | PG_RW_MASK |
2305 PG_PRESENT_MASK);
2306 } else {
2307 prot = 0;
2308 }
2309 mem_print(mon, &start, &last_prot, end, prot);
2310 }
2311 }
2312 } else {
2313 prot = 0;
2314 mem_print(mon, &start, &last_prot, end, prot);
2315 }
2316 }
2317 }
2318 } else {
2319 prot = 0;
2320 mem_print(mon, &start, &last_prot, end, prot);
2321 }
2322 }
2323 } else {
2324 prot = 0;
2325 mem_print(mon, &start, &last_prot, end, prot);
2326 }
2327 }
2328}
2329#endif
2330
2331static void mem_info(Monitor *mon)
2332{
2333 CPUState *env;
2334
2335 env = mon_get_cpu();
2336
2337 if (!(env->cr[0] & CR0_PG_MASK)) {
2338 monitor_printf(mon, "PG disabled\n");
2339 return;
2340 }
2341 if (env->cr[4] & CR4_PAE_MASK) {
2342#ifdef TARGET_X86_64
2343 if (env->hflags & HF_LMA_MASK) {
2344 mem_info_64(mon, env);
2345 } else
2346#endif
2347 {
2348 mem_info_pae32(mon, env);
2349 }
2350 } else {
2351 mem_info_32(mon, env);
2352 }
2353}
bellardb86bda52004-09-18 19:32:46 +00002354#endif
2355
aurel327c664e22009-03-03 06:12:22 +00002356#if defined(TARGET_SH4)
2357
aliguori376253e2009-03-05 23:01:23 +00002358static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00002359{
aliguori376253e2009-03-05 23:01:23 +00002360 monitor_printf(mon, " tlb%i:\t"
2361 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2362 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2363 "dirty=%hhu writethrough=%hhu\n",
2364 idx,
2365 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2366 tlb->v, tlb->sh, tlb->c, tlb->pr,
2367 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00002368}
2369
aliguori376253e2009-03-05 23:01:23 +00002370static void tlb_info(Monitor *mon)
aurel327c664e22009-03-03 06:12:22 +00002371{
2372 CPUState *env = mon_get_cpu();
2373 int i;
2374
aliguori376253e2009-03-05 23:01:23 +00002375 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002376 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002377 print_tlb (mon, i, &env->itlb[i]);
2378 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002379 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002380 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00002381}
2382
2383#endif
2384
Blue Swirld41160a2010-12-19 13:42:56 +00002385#if defined(TARGET_SPARC)
2386static void tlb_info(Monitor *mon)
2387{
2388 CPUState *env1 = mon_get_cpu();
2389
2390 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
2391}
2392#endif
2393
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002394static void do_info_kvm_print(Monitor *mon, const QObject *data)
2395{
2396 QDict *qdict;
2397
2398 qdict = qobject_to_qdict(data);
2399
2400 monitor_printf(mon, "kvm support: ");
2401 if (qdict_get_bool(qdict, "present")) {
2402 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
2403 "enabled" : "disabled");
2404 } else {
2405 monitor_printf(mon, "not compiled\n");
2406 }
2407}
2408
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002409static void do_info_kvm(Monitor *mon, QObject **ret_data)
aliguori7ba1e612008-11-05 16:04:33 +00002410{
2411#ifdef CONFIG_KVM
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002412 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
2413 kvm_enabled());
aliguori7ba1e612008-11-05 16:04:33 +00002414#else
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002415 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
aliguori7ba1e612008-11-05 16:04:33 +00002416#endif
2417}
2418
aliguori030ea372009-04-21 22:30:47 +00002419static void do_info_numa(Monitor *mon)
2420{
aliguorib28b6232009-04-22 20:20:29 +00002421 int i;
aliguori030ea372009-04-21 22:30:47 +00002422 CPUState *env;
2423
2424 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2425 for (i = 0; i < nb_numa_nodes; i++) {
2426 monitor_printf(mon, "node %d cpus:", i);
2427 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2428 if (env->numa_node == i) {
2429 monitor_printf(mon, " %d", env->cpu_index);
2430 }
2431 }
2432 monitor_printf(mon, "\n");
2433 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2434 node_mem[i] >> 20);
2435 }
2436}
2437
bellard5f1ce942006-02-08 22:40:15 +00002438#ifdef CONFIG_PROFILER
2439
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002440int64_t qemu_time;
2441int64_t dev_time;
2442
aliguori376253e2009-03-05 23:01:23 +00002443static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002444{
2445 int64_t total;
2446 total = qemu_time;
2447 if (total == 0)
2448 total = 1;
aliguori376253e2009-03-05 23:01:23 +00002449 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002450 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00002451 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002452 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00002453 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002454 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002455}
2456#else
aliguori376253e2009-03-05 23:01:23 +00002457static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002458{
aliguori376253e2009-03-05 23:01:23 +00002459 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002460}
2461#endif
2462
bellardec36b692006-07-16 18:57:03 +00002463/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002464static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002465
aliguori376253e2009-03-05 23:01:23 +00002466static void do_info_capture(Monitor *mon)
bellardec36b692006-07-16 18:57:03 +00002467{
2468 int i;
2469 CaptureState *s;
2470
2471 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002472 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002473 s->ops.info (s->opaque);
2474 }
2475}
2476
Blue Swirl23130862009-06-06 08:22:04 +00002477#ifdef HAS_AUDIO
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002478static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002479{
2480 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002481 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002482 CaptureState *s;
2483
2484 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2485 if (i == n) {
2486 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002487 QLIST_REMOVE (s, entries);
bellardec36b692006-07-16 18:57:03 +00002488 qemu_free (s);
2489 return;
2490 }
2491 }
2492}
2493
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002494static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002495{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002496 const char *path = qdict_get_str(qdict, "path");
2497 int has_freq = qdict_haskey(qdict, "freq");
2498 int freq = qdict_get_try_int(qdict, "freq", -1);
2499 int has_bits = qdict_haskey(qdict, "bits");
2500 int bits = qdict_get_try_int(qdict, "bits", -1);
2501 int has_channels = qdict_haskey(qdict, "nchannels");
2502 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002503 CaptureState *s;
2504
2505 s = qemu_mallocz (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002506
2507 freq = has_freq ? freq : 44100;
2508 bits = has_bits ? bits : 16;
2509 nchannels = has_channels ? nchannels : 2;
2510
2511 if (wav_start_capture (s, path, freq, bits, nchannels)) {
aliguori376253e2009-03-05 23:01:23 +00002512 monitor_printf(mon, "Faied to add wave capture\n");
bellardec36b692006-07-16 18:57:03 +00002513 qemu_free (s);
2514 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002515 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002516}
2517#endif
2518
aurel32dc1c0b72008-04-27 23:52:12 +00002519#if defined(TARGET_I386)
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002520static void do_inject_nmi(Monitor *mon, const QDict *qdict)
aurel32dc1c0b72008-04-27 23:52:12 +00002521{
2522 CPUState *env;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002523 int cpu_index = qdict_get_int(qdict, "cpu_index");
aurel32dc1c0b72008-04-27 23:52:12 +00002524
2525 for (env = first_cpu; env != NULL; env = env->next_cpu)
2526 if (env->cpu_index == cpu_index) {
2527 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2528 break;
2529 }
2530}
2531#endif
2532
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002533static void do_info_status_print(Monitor *mon, const QObject *data)
aurel326f9c5ee2008-12-18 22:43:56 +00002534{
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002535 QDict *qdict;
2536
2537 qdict = qobject_to_qdict(data);
2538
2539 monitor_printf(mon, "VM status: ");
2540 if (qdict_get_bool(qdict, "running")) {
2541 monitor_printf(mon, "running");
2542 if (qdict_get_bool(qdict, "singlestep")) {
2543 monitor_printf(mon, " (single step mode)");
aurel321b530a62009-04-05 20:08:59 +00002544 }
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002545 } else {
2546 monitor_printf(mon, "paused");
2547 }
2548
2549 monitor_printf(mon, "\n");
2550}
2551
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002552static void do_info_status(Monitor *mon, QObject **ret_data)
2553{
2554 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2555 vm_running, singlestep);
aurel326f9c5ee2008-12-18 22:43:56 +00002556}
2557
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002558static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002559{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002560 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002561
aliguori76655d62009-03-06 20:27:37 +00002562 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002563 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002564 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002565 return acl;
2566}
aliguori76655d62009-03-06 20:27:37 +00002567
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002568static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002569{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002570 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002571 qemu_acl *acl = find_acl(mon, aclname);
2572 qemu_acl_entry *entry;
2573 int i = 0;
2574
2575 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002576 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002577 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002578 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002579 i++;
2580 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002581 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002582 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002583 }
2584}
2585
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002586static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002587{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002588 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002589 qemu_acl *acl = find_acl(mon, aclname);
2590
2591 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002592 qemu_acl_reset(acl);
2593 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002594 }
2595}
aliguori76655d62009-03-06 20:27:37 +00002596
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002597static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002598{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002599 const char *aclname = qdict_get_str(qdict, "aclname");
2600 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002601 qemu_acl *acl = find_acl(mon, aclname);
2602
2603 if (acl) {
2604 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002605 acl->defaultDeny = 0;
2606 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002607 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002608 acl->defaultDeny = 1;
2609 monitor_printf(mon, "acl: policy set to 'deny'\n");
2610 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002611 monitor_printf(mon, "acl: unknown policy '%s', "
2612 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002613 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002614 }
2615}
aliguori76655d62009-03-06 20:27:37 +00002616
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002617static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002618{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002619 const char *aclname = qdict_get_str(qdict, "aclname");
2620 const char *match = qdict_get_str(qdict, "match");
2621 const char *policy = qdict_get_str(qdict, "policy");
2622 int has_index = qdict_haskey(qdict, "index");
2623 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002624 qemu_acl *acl = find_acl(mon, aclname);
2625 int deny, ret;
2626
2627 if (acl) {
2628 if (strcmp(policy, "allow") == 0) {
2629 deny = 0;
2630 } else if (strcmp(policy, "deny") == 0) {
2631 deny = 1;
2632 } else {
2633 monitor_printf(mon, "acl: unknown policy '%s', "
2634 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002635 return;
2636 }
aliguori28a76be2009-03-06 20:27:40 +00002637 if (has_index)
2638 ret = qemu_acl_insert(acl, deny, match, index);
2639 else
2640 ret = qemu_acl_append(acl, deny, match);
2641 if (ret < 0)
2642 monitor_printf(mon, "acl: unable to add acl entry\n");
2643 else
2644 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002645 }
2646}
aliguori76655d62009-03-06 20:27:37 +00002647
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002648static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002649{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002650 const char *aclname = qdict_get_str(qdict, "aclname");
2651 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002652 qemu_acl *acl = find_acl(mon, aclname);
2653 int ret;
aliguori76655d62009-03-06 20:27:37 +00002654
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002655 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002656 ret = qemu_acl_remove(acl, match);
2657 if (ret < 0)
2658 monitor_printf(mon, "acl: no matching acl entry\n");
2659 else
2660 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002661 }
2662}
2663
Huang Ying79c4f6b2009-06-23 10:05:14 +08002664#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002665static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002666{
2667 CPUState *cenv;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002668 int cpu_index = qdict_get_int(qdict, "cpu_index");
2669 int bank = qdict_get_int(qdict, "bank");
2670 uint64_t status = qdict_get_int(qdict, "status");
2671 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2672 uint64_t addr = qdict_get_int(qdict, "addr");
2673 uint64_t misc = qdict_get_int(qdict, "misc");
Huang Ying79c4f6b2009-06-23 10:05:14 +08002674
2675 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2676 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2677 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2678 break;
2679 }
2680}
2681#endif
2682
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002683static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002684{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002685 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002686 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002687 int fd;
2688
2689 fd = qemu_chr_get_msgfd(mon->chr);
2690 if (fd == -1) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002691 qerror_report(QERR_FD_NOT_SUPPLIED);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002692 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002693 }
2694
2695 if (qemu_isdigit(fdname[0])) {
Markus Armbrustere17ba872010-03-25 17:22:36 +01002696 qerror_report(QERR_INVALID_PARAMETER_VALUE, "fdname",
2697 "a name not starting with a digit");
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002698 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002699 }
2700
Blue Swirl72cf2d42009-09-12 07:36:22 +00002701 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002702 if (strcmp(monfd->name, fdname) != 0) {
2703 continue;
2704 }
2705
2706 close(monfd->fd);
2707 monfd->fd = fd;
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002708 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002709 }
2710
Anthony Liguoric227f092009-10-01 16:12:16 -05002711 monfd = qemu_mallocz(sizeof(mon_fd_t));
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002712 monfd->name = qemu_strdup(fdname);
2713 monfd->fd = fd;
2714
Blue Swirl72cf2d42009-09-12 07:36:22 +00002715 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002716 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002717}
2718
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002719static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002720{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002721 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002722 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002723
Blue Swirl72cf2d42009-09-12 07:36:22 +00002724 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002725 if (strcmp(monfd->name, fdname) != 0) {
2726 continue;
2727 }
2728
Blue Swirl72cf2d42009-09-12 07:36:22 +00002729 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002730 close(monfd->fd);
2731 qemu_free(monfd->name);
2732 qemu_free(monfd);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002733 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002734 }
2735
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002736 qerror_report(QERR_FD_NOT_FOUND, fdname);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002737 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002738}
2739
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002740static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002741{
2742 int saved_vm_running = vm_running;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002743 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002744
2745 vm_stop(0);
2746
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002747 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002748 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002749 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002750}
2751
Mark McLoughlin7768e042009-07-22 09:11:41 +01002752int monitor_get_fd(Monitor *mon, const char *fdname)
2753{
Anthony Liguoric227f092009-10-01 16:12:16 -05002754 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002755
Blue Swirl72cf2d42009-09-12 07:36:22 +00002756 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002757 int fd;
2758
2759 if (strcmp(monfd->name, fdname) != 0) {
2760 continue;
2761 }
2762
2763 fd = monfd->fd;
2764
2765 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002766 QLIST_REMOVE(monfd, next);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002767 qemu_free(monfd->name);
2768 qemu_free(monfd);
2769
2770 return fd;
2771 }
2772
2773 return -1;
2774}
2775
Anthony Liguoric227f092009-10-01 16:12:16 -05002776static const mon_cmd_t mon_cmds[] = {
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002777#include "hmp-commands.h"
ths5fafdf22007-09-16 21:08:06 +00002778 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00002779};
2780
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002781/* Please update hmp-commands.hx when adding or changing commands */
Anthony Liguoric227f092009-10-01 16:12:16 -05002782static const mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002783 {
2784 .name = "version",
2785 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002786 .params = "",
2787 .help = "show the version of QEMU",
Luiz Capitulino45e914c2009-12-10 17:15:58 -02002788 .user_print = do_info_version_print,
Luiz Capitulinoab2d3182009-10-07 13:42:02 -03002789 .mhandler.info_new = do_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002790 },
2791 {
2792 .name = "network",
2793 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002794 .params = "",
2795 .help = "show the network state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002796 .mhandler.info = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002797 },
2798 {
2799 .name = "chardev",
2800 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002801 .params = "",
2802 .help = "show the character devices",
Luiz Capitulino588b3832009-12-10 17:16:08 -02002803 .user_print = qemu_chr_info_print,
2804 .mhandler.info_new = qemu_chr_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002805 },
2806 {
2807 .name = "block",
2808 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002809 .params = "",
2810 .help = "show the block devices",
Luiz Capitulinod15e5462009-12-10 17:16:06 -02002811 .user_print = bdrv_info_print,
2812 .mhandler.info_new = bdrv_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002813 },
2814 {
2815 .name = "blockstats",
2816 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002817 .params = "",
2818 .help = "show block device statistics",
Luiz Capitulino218a5362009-12-10 17:16:07 -02002819 .user_print = bdrv_stats_print,
2820 .mhandler.info_new = bdrv_info_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002821 },
2822 {
2823 .name = "registers",
2824 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002825 .params = "",
2826 .help = "show the cpu registers",
Luiz Capitulino910df892009-10-07 13:41:51 -03002827 .mhandler.info = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002828 },
2829 {
2830 .name = "cpus",
2831 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002832 .params = "",
2833 .help = "show infos for each CPU",
Luiz Capitulino8f3cec02009-10-07 13:42:04 -03002834 .user_print = monitor_print_cpus,
2835 .mhandler.info_new = do_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002836 },
2837 {
2838 .name = "history",
2839 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002840 .params = "",
2841 .help = "show the command line history",
Luiz Capitulino910df892009-10-07 13:41:51 -03002842 .mhandler.info = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002843 },
2844 {
2845 .name = "irq",
2846 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002847 .params = "",
2848 .help = "show the interrupts statistics (if available)",
Luiz Capitulino910df892009-10-07 13:41:51 -03002849 .mhandler.info = irq_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002850 },
2851 {
2852 .name = "pic",
2853 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002854 .params = "",
2855 .help = "show i8259 (PIC) state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002856 .mhandler.info = pic_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002857 },
2858 {
2859 .name = "pci",
2860 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002861 .params = "",
2862 .help = "show PCI info",
Luiz Capitulino163c8a52010-01-21 19:15:40 -02002863 .user_print = do_pci_info_print,
2864 .mhandler.info_new = do_pci_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002865 },
Blue Swirld41160a2010-12-19 13:42:56 +00002866#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002867 {
2868 .name = "tlb",
2869 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002870 .params = "",
2871 .help = "show virtual to physical memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002872 .mhandler.info = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002873 },
aurel327c664e22009-03-03 06:12:22 +00002874#endif
2875#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002876 {
2877 .name = "mem",
2878 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002879 .params = "",
2880 .help = "show the active virtual memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002881 .mhandler.info = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002882 },
bellardb86bda52004-09-18 19:32:46 +00002883#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002884 {
2885 .name = "jit",
2886 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002887 .params = "",
2888 .help = "show dynamic compiler info",
Luiz Capitulino910df892009-10-07 13:41:51 -03002889 .mhandler.info = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002890 },
2891 {
2892 .name = "kvm",
2893 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002894 .params = "",
2895 .help = "show KVM information",
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002896 .user_print = do_info_kvm_print,
2897 .mhandler.info_new = do_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002898 },
2899 {
2900 .name = "numa",
2901 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002902 .params = "",
2903 .help = "show NUMA information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002904 .mhandler.info = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002905 },
2906 {
2907 .name = "usb",
2908 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002909 .params = "",
2910 .help = "show guest USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002911 .mhandler.info = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002912 },
2913 {
2914 .name = "usbhost",
2915 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002916 .params = "",
2917 .help = "show host USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002918 .mhandler.info = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002919 },
2920 {
2921 .name = "profile",
2922 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002923 .params = "",
2924 .help = "show profiling information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002925 .mhandler.info = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002926 },
2927 {
2928 .name = "capture",
2929 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002930 .params = "",
2931 .help = "show capture information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002932 .mhandler.info = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002933 },
2934 {
2935 .name = "snapshots",
2936 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002937 .params = "",
2938 .help = "show the currently saved VM snapshots",
Luiz Capitulino910df892009-10-07 13:41:51 -03002939 .mhandler.info = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002940 },
2941 {
2942 .name = "status",
2943 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002944 .params = "",
2945 .help = "show the current VM status (running|paused)",
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002946 .user_print = do_info_status_print,
2947 .mhandler.info_new = do_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002948 },
2949 {
2950 .name = "pcmcia",
2951 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002952 .params = "",
2953 .help = "show guest PCMCIA status",
Luiz Capitulino910df892009-10-07 13:41:51 -03002954 .mhandler.info = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002955 },
2956 {
2957 .name = "mice",
2958 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002959 .params = "",
2960 .help = "show which guest mouse is receiving events",
Luiz Capitulinoe78c48e2009-12-10 17:16:04 -02002961 .user_print = do_info_mice_print,
2962 .mhandler.info_new = do_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002963 },
2964 {
2965 .name = "vnc",
2966 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002967 .params = "",
2968 .help = "show the vnc server status",
Luiz Capitulinod96fd292009-12-10 17:16:10 -02002969 .user_print = do_info_vnc_print,
2970 .mhandler.info_new = do_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002971 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002972#if defined(CONFIG_SPICE)
2973 {
2974 .name = "spice",
2975 .args_type = "",
2976 .params = "",
2977 .help = "show the spice server status",
2978 .user_print = do_info_spice_print,
2979 .mhandler.info_new = do_info_spice,
2980 },
2981#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002982 {
2983 .name = "name",
2984 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002985 .params = "",
2986 .help = "show the current VM name",
Luiz Capitulinoe05486c2009-12-10 17:16:01 -02002987 .user_print = do_info_name_print,
2988 .mhandler.info_new = do_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002989 },
2990 {
2991 .name = "uuid",
2992 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002993 .params = "",
2994 .help = "show the current VM UUID",
Luiz Capitulino9603ceb2009-12-10 17:16:03 -02002995 .user_print = do_info_uuid_print,
2996 .mhandler.info_new = do_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002997 },
j_mayer76a66252007-03-07 08:32:30 +00002998#if defined(TARGET_PPC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002999 {
3000 .name = "cpustats",
3001 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003002 .params = "",
3003 .help = "show CPU statistics",
Luiz Capitulino910df892009-10-07 13:41:51 -03003004 .mhandler.info = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003005 },
j_mayer76a66252007-03-07 08:32:30 +00003006#endif
blueswir131a60e22007-10-26 18:42:59 +00003007#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003008 {
3009 .name = "usernet",
3010 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003011 .params = "",
3012 .help = "show user network stack connection states",
Luiz Capitulino910df892009-10-07 13:41:51 -03003013 .mhandler.info = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003014 },
blueswir131a60e22007-10-26 18:42:59 +00003015#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003016 {
3017 .name = "migrate",
3018 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003019 .params = "",
3020 .help = "show migration status",
Luiz Capitulinoc86a6682009-12-10 17:16:05 -02003021 .user_print = do_info_migrate_print,
3022 .mhandler.info_new = do_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003023 },
3024 {
3025 .name = "balloon",
3026 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003027 .params = "",
3028 .help = "show balloon information",
Luiz Capitulinocc1d9c72009-10-07 13:42:03 -03003029 .user_print = monitor_print_balloon,
Adam Litke625a5be2010-01-26 14:17:35 -06003030 .mhandler.info_async = do_info_balloon,
Jan Kiszka8ac470c2010-06-16 00:38:39 +02003031 .flags = MONITOR_CMD_ASYNC,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003032 },
3033 {
3034 .name = "qtree",
3035 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003036 .params = "",
3037 .help = "show device tree",
Luiz Capitulino910df892009-10-07 13:41:51 -03003038 .mhandler.info = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003039 },
3040 {
3041 .name = "qdm",
3042 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003043 .params = "",
3044 .help = "show qdev device model list",
Luiz Capitulino910df892009-10-07 13:41:51 -03003045 .mhandler.info = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003046 },
3047 {
3048 .name = "roms",
3049 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003050 .params = "",
3051 .help = "show roms",
Luiz Capitulino910df892009-10-07 13:41:51 -03003052 .mhandler.info = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003053 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05303054#if defined(CONFIG_SIMPLE_TRACE)
3055 {
3056 .name = "trace",
3057 .args_type = "",
3058 .params = "",
3059 .help = "show current contents of trace buffer",
3060 .mhandler.info = do_info_trace,
3061 },
3062 {
3063 .name = "trace-events",
3064 .args_type = "",
3065 .params = "",
3066 .help = "show available trace-events & their state",
3067 .mhandler.info = do_info_trace_events,
3068 },
3069#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03003070 {
3071 .name = NULL,
3072 },
bellard9dc39cb2004-03-14 21:38:27 +00003073};
3074
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003075static const mon_cmd_t qmp_cmds[] = {
3076#include "qmp-commands.h"
3077 { /* NULL */ },
3078};
3079
Luiz Capitulino3e12a752010-09-15 17:20:33 -03003080static const mon_cmd_t qmp_query_cmds[] = {
3081 {
3082 .name = "version",
3083 .args_type = "",
3084 .params = "",
3085 .help = "show the version of QEMU",
3086 .user_print = do_info_version_print,
3087 .mhandler.info_new = do_info_version,
3088 },
3089 {
3090 .name = "commands",
3091 .args_type = "",
3092 .params = "",
3093 .help = "list QMP available commands",
3094 .user_print = monitor_user_noop,
3095 .mhandler.info_new = do_info_commands,
3096 },
3097 {
3098 .name = "chardev",
3099 .args_type = "",
3100 .params = "",
3101 .help = "show the character devices",
3102 .user_print = qemu_chr_info_print,
3103 .mhandler.info_new = qemu_chr_info,
3104 },
3105 {
3106 .name = "block",
3107 .args_type = "",
3108 .params = "",
3109 .help = "show the block devices",
3110 .user_print = bdrv_info_print,
3111 .mhandler.info_new = bdrv_info,
3112 },
3113 {
3114 .name = "blockstats",
3115 .args_type = "",
3116 .params = "",
3117 .help = "show block device statistics",
3118 .user_print = bdrv_stats_print,
3119 .mhandler.info_new = bdrv_info_stats,
3120 },
3121 {
3122 .name = "cpus",
3123 .args_type = "",
3124 .params = "",
3125 .help = "show infos for each CPU",
3126 .user_print = monitor_print_cpus,
3127 .mhandler.info_new = do_info_cpus,
3128 },
3129 {
3130 .name = "pci",
3131 .args_type = "",
3132 .params = "",
3133 .help = "show PCI info",
3134 .user_print = do_pci_info_print,
3135 .mhandler.info_new = do_pci_info,
3136 },
3137 {
3138 .name = "kvm",
3139 .args_type = "",
3140 .params = "",
3141 .help = "show KVM information",
3142 .user_print = do_info_kvm_print,
3143 .mhandler.info_new = do_info_kvm,
3144 },
3145 {
3146 .name = "status",
3147 .args_type = "",
3148 .params = "",
3149 .help = "show the current VM status (running|paused)",
3150 .user_print = do_info_status_print,
3151 .mhandler.info_new = do_info_status,
3152 },
3153 {
3154 .name = "mice",
3155 .args_type = "",
3156 .params = "",
3157 .help = "show which guest mouse is receiving events",
3158 .user_print = do_info_mice_print,
3159 .mhandler.info_new = do_info_mice,
3160 },
3161 {
3162 .name = "vnc",
3163 .args_type = "",
3164 .params = "",
3165 .help = "show the vnc server status",
3166 .user_print = do_info_vnc_print,
3167 .mhandler.info_new = do_info_vnc,
3168 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01003169#if defined(CONFIG_SPICE)
3170 {
3171 .name = "spice",
3172 .args_type = "",
3173 .params = "",
3174 .help = "show the spice server status",
3175 .user_print = do_info_spice_print,
3176 .mhandler.info_new = do_info_spice,
3177 },
3178#endif
Luiz Capitulino3e12a752010-09-15 17:20:33 -03003179 {
3180 .name = "name",
3181 .args_type = "",
3182 .params = "",
3183 .help = "show the current VM name",
3184 .user_print = do_info_name_print,
3185 .mhandler.info_new = do_info_name,
3186 },
3187 {
3188 .name = "uuid",
3189 .args_type = "",
3190 .params = "",
3191 .help = "show the current VM UUID",
3192 .user_print = do_info_uuid_print,
3193 .mhandler.info_new = do_info_uuid,
3194 },
3195 {
3196 .name = "migrate",
3197 .args_type = "",
3198 .params = "",
3199 .help = "show migration status",
3200 .user_print = do_info_migrate_print,
3201 .mhandler.info_new = do_info_migrate,
3202 },
3203 {
3204 .name = "balloon",
3205 .args_type = "",
3206 .params = "",
3207 .help = "show balloon information",
3208 .user_print = monitor_print_balloon,
3209 .mhandler.info_async = do_info_balloon,
3210 .flags = MONITOR_CMD_ASYNC,
3211 },
3212 { /* NULL */ },
3213};
3214
bellard9307c4c2004-04-04 12:57:25 +00003215/*******************************************************************/
3216
3217static const char *pch;
3218static jmp_buf expr_env;
3219
bellard92a31b12005-02-10 22:00:52 +00003220#define MD_TLONG 0
3221#define MD_I32 1
3222
bellard9307c4c2004-04-04 12:57:25 +00003223typedef struct MonitorDef {
3224 const char *name;
3225 int offset;
blueswir18662d652008-10-02 18:32:44 +00003226 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00003227 int type;
bellard9307c4c2004-04-04 12:57:25 +00003228} MonitorDef;
3229
bellard57206fd2004-04-25 18:54:52 +00003230#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00003231static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00003232{
bellard6a00d602005-11-21 23:25:50 +00003233 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003234 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00003235}
3236#endif
3237
bellarda541f292004-04-12 20:39:29 +00003238#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00003239static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00003240{
bellard6a00d602005-11-21 23:25:50 +00003241 CPUState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00003242 unsigned int u;
3243 int i;
3244
3245 u = 0;
3246 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00003247 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00003248
3249 return u;
3250}
3251
blueswir18662d652008-10-02 18:32:44 +00003252static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00003253{
bellard6a00d602005-11-21 23:25:50 +00003254 CPUState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00003255 return env->msr;
bellarda541f292004-04-12 20:39:29 +00003256}
3257
blueswir18662d652008-10-02 18:32:44 +00003258static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00003259{
bellard6a00d602005-11-21 23:25:50 +00003260 CPUState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00003261 return env->xer;
bellarda541f292004-04-12 20:39:29 +00003262}
bellard9fddaa02004-05-21 12:59:32 +00003263
blueswir18662d652008-10-02 18:32:44 +00003264static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003265{
bellard6a00d602005-11-21 23:25:50 +00003266 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003267 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00003268}
3269
blueswir18662d652008-10-02 18:32:44 +00003270static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003271{
bellard6a00d602005-11-21 23:25:50 +00003272 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003273 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00003274}
3275
blueswir18662d652008-10-02 18:32:44 +00003276static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003277{
bellard6a00d602005-11-21 23:25:50 +00003278 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003279 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00003280}
bellarda541f292004-04-12 20:39:29 +00003281#endif
3282
bellarde95c8d52004-09-30 22:22:08 +00003283#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00003284#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00003285static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003286{
bellard6a00d602005-11-21 23:25:50 +00003287 CPUState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00003288
3289 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00003290}
bellard7b936c02005-10-30 17:05:13 +00003291#endif
bellarde95c8d52004-09-30 22:22:08 +00003292
blueswir18662d652008-10-02 18:32:44 +00003293static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003294{
bellard6a00d602005-11-21 23:25:50 +00003295 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003296 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00003297}
3298#endif
3299
blueswir18662d652008-10-02 18:32:44 +00003300static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00003301#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00003302
3303#define SEG(name, seg) \
bellard92a31b12005-02-10 22:00:52 +00003304 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
bellard57206fd2004-04-25 18:54:52 +00003305 { name ".base", offsetof(CPUState, segs[seg].base) },\
bellard92a31b12005-02-10 22:00:52 +00003306 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00003307
bellard9307c4c2004-04-04 12:57:25 +00003308 { "eax", offsetof(CPUState, regs[0]) },
3309 { "ecx", offsetof(CPUState, regs[1]) },
3310 { "edx", offsetof(CPUState, regs[2]) },
3311 { "ebx", offsetof(CPUState, regs[3]) },
3312 { "esp|sp", offsetof(CPUState, regs[4]) },
3313 { "ebp|fp", offsetof(CPUState, regs[5]) },
3314 { "esi", offsetof(CPUState, regs[6]) },
bellard01038d22004-09-13 21:36:46 +00003315 { "edi", offsetof(CPUState, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00003316#ifdef TARGET_X86_64
3317 { "r8", offsetof(CPUState, regs[8]) },
3318 { "r9", offsetof(CPUState, regs[9]) },
3319 { "r10", offsetof(CPUState, regs[10]) },
3320 { "r11", offsetof(CPUState, regs[11]) },
3321 { "r12", offsetof(CPUState, regs[12]) },
3322 { "r13", offsetof(CPUState, regs[13]) },
3323 { "r14", offsetof(CPUState, regs[14]) },
3324 { "r15", offsetof(CPUState, regs[15]) },
3325#endif
bellard9307c4c2004-04-04 12:57:25 +00003326 { "eflags", offsetof(CPUState, eflags) },
bellard57206fd2004-04-25 18:54:52 +00003327 { "eip", offsetof(CPUState, eip) },
3328 SEG("cs", R_CS)
3329 SEG("ds", R_DS)
3330 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00003331 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00003332 SEG("fs", R_FS)
3333 SEG("gs", R_GS)
3334 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00003335#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00003336 /* General purpose registers */
bellarda541f292004-04-12 20:39:29 +00003337 { "r0", offsetof(CPUState, gpr[0]) },
3338 { "r1", offsetof(CPUState, gpr[1]) },
3339 { "r2", offsetof(CPUState, gpr[2]) },
3340 { "r3", offsetof(CPUState, gpr[3]) },
3341 { "r4", offsetof(CPUState, gpr[4]) },
3342 { "r5", offsetof(CPUState, gpr[5]) },
3343 { "r6", offsetof(CPUState, gpr[6]) },
3344 { "r7", offsetof(CPUState, gpr[7]) },
3345 { "r8", offsetof(CPUState, gpr[8]) },
3346 { "r9", offsetof(CPUState, gpr[9]) },
3347 { "r10", offsetof(CPUState, gpr[10]) },
3348 { "r11", offsetof(CPUState, gpr[11]) },
3349 { "r12", offsetof(CPUState, gpr[12]) },
3350 { "r13", offsetof(CPUState, gpr[13]) },
3351 { "r14", offsetof(CPUState, gpr[14]) },
3352 { "r15", offsetof(CPUState, gpr[15]) },
3353 { "r16", offsetof(CPUState, gpr[16]) },
3354 { "r17", offsetof(CPUState, gpr[17]) },
3355 { "r18", offsetof(CPUState, gpr[18]) },
3356 { "r19", offsetof(CPUState, gpr[19]) },
3357 { "r20", offsetof(CPUState, gpr[20]) },
3358 { "r21", offsetof(CPUState, gpr[21]) },
3359 { "r22", offsetof(CPUState, gpr[22]) },
3360 { "r23", offsetof(CPUState, gpr[23]) },
3361 { "r24", offsetof(CPUState, gpr[24]) },
3362 { "r25", offsetof(CPUState, gpr[25]) },
3363 { "r26", offsetof(CPUState, gpr[26]) },
3364 { "r27", offsetof(CPUState, gpr[27]) },
3365 { "r28", offsetof(CPUState, gpr[28]) },
3366 { "r29", offsetof(CPUState, gpr[29]) },
3367 { "r30", offsetof(CPUState, gpr[30]) },
3368 { "r31", offsetof(CPUState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00003369 /* Floating point registers */
3370 { "f0", offsetof(CPUState, fpr[0]) },
3371 { "f1", offsetof(CPUState, fpr[1]) },
3372 { "f2", offsetof(CPUState, fpr[2]) },
3373 { "f3", offsetof(CPUState, fpr[3]) },
3374 { "f4", offsetof(CPUState, fpr[4]) },
3375 { "f5", offsetof(CPUState, fpr[5]) },
3376 { "f6", offsetof(CPUState, fpr[6]) },
3377 { "f7", offsetof(CPUState, fpr[7]) },
3378 { "f8", offsetof(CPUState, fpr[8]) },
3379 { "f9", offsetof(CPUState, fpr[9]) },
3380 { "f10", offsetof(CPUState, fpr[10]) },
3381 { "f11", offsetof(CPUState, fpr[11]) },
3382 { "f12", offsetof(CPUState, fpr[12]) },
3383 { "f13", offsetof(CPUState, fpr[13]) },
3384 { "f14", offsetof(CPUState, fpr[14]) },
3385 { "f15", offsetof(CPUState, fpr[15]) },
3386 { "f16", offsetof(CPUState, fpr[16]) },
3387 { "f17", offsetof(CPUState, fpr[17]) },
3388 { "f18", offsetof(CPUState, fpr[18]) },
3389 { "f19", offsetof(CPUState, fpr[19]) },
3390 { "f20", offsetof(CPUState, fpr[20]) },
3391 { "f21", offsetof(CPUState, fpr[21]) },
3392 { "f22", offsetof(CPUState, fpr[22]) },
3393 { "f23", offsetof(CPUState, fpr[23]) },
3394 { "f24", offsetof(CPUState, fpr[24]) },
3395 { "f25", offsetof(CPUState, fpr[25]) },
3396 { "f26", offsetof(CPUState, fpr[26]) },
3397 { "f27", offsetof(CPUState, fpr[27]) },
3398 { "f28", offsetof(CPUState, fpr[28]) },
3399 { "f29", offsetof(CPUState, fpr[29]) },
3400 { "f30", offsetof(CPUState, fpr[30]) },
3401 { "f31", offsetof(CPUState, fpr[31]) },
3402 { "fpscr", offsetof(CPUState, fpscr) },
3403 /* Next instruction pointer */
bellard57206fd2004-04-25 18:54:52 +00003404 { "nip|pc", offsetof(CPUState, nip) },
bellarda541f292004-04-12 20:39:29 +00003405 { "lr", offsetof(CPUState, lr) },
3406 { "ctr", offsetof(CPUState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00003407 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00003408 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00003409 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00003410 { "msr", 0, &monitor_get_msr, },
3411 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00003412 { "tbu", 0, &monitor_get_tbu, },
3413 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00003414#if defined(TARGET_PPC64)
3415 /* Address space register */
3416 { "asr", offsetof(CPUState, asr) },
3417#endif
3418 /* Segment registers */
bellarda541f292004-04-12 20:39:29 +00003419 { "sdr1", offsetof(CPUState, sdr1) },
3420 { "sr0", offsetof(CPUState, sr[0]) },
3421 { "sr1", offsetof(CPUState, sr[1]) },
3422 { "sr2", offsetof(CPUState, sr[2]) },
3423 { "sr3", offsetof(CPUState, sr[3]) },
3424 { "sr4", offsetof(CPUState, sr[4]) },
3425 { "sr5", offsetof(CPUState, sr[5]) },
3426 { "sr6", offsetof(CPUState, sr[6]) },
3427 { "sr7", offsetof(CPUState, sr[7]) },
3428 { "sr8", offsetof(CPUState, sr[8]) },
3429 { "sr9", offsetof(CPUState, sr[9]) },
3430 { "sr10", offsetof(CPUState, sr[10]) },
3431 { "sr11", offsetof(CPUState, sr[11]) },
3432 { "sr12", offsetof(CPUState, sr[12]) },
3433 { "sr13", offsetof(CPUState, sr[13]) },
3434 { "sr14", offsetof(CPUState, sr[14]) },
3435 { "sr15", offsetof(CPUState, sr[15]) },
3436 /* Too lazy to put BATs and SPRs ... */
bellarde95c8d52004-09-30 22:22:08 +00003437#elif defined(TARGET_SPARC)
3438 { "g0", offsetof(CPUState, gregs[0]) },
3439 { "g1", offsetof(CPUState, gregs[1]) },
3440 { "g2", offsetof(CPUState, gregs[2]) },
3441 { "g3", offsetof(CPUState, gregs[3]) },
3442 { "g4", offsetof(CPUState, gregs[4]) },
3443 { "g5", offsetof(CPUState, gregs[5]) },
3444 { "g6", offsetof(CPUState, gregs[6]) },
3445 { "g7", offsetof(CPUState, gregs[7]) },
3446 { "o0", 0, monitor_get_reg },
3447 { "o1", 1, monitor_get_reg },
3448 { "o2", 2, monitor_get_reg },
3449 { "o3", 3, monitor_get_reg },
3450 { "o4", 4, monitor_get_reg },
3451 { "o5", 5, monitor_get_reg },
3452 { "o6", 6, monitor_get_reg },
3453 { "o7", 7, monitor_get_reg },
3454 { "l0", 8, monitor_get_reg },
3455 { "l1", 9, monitor_get_reg },
3456 { "l2", 10, monitor_get_reg },
3457 { "l3", 11, monitor_get_reg },
3458 { "l4", 12, monitor_get_reg },
3459 { "l5", 13, monitor_get_reg },
3460 { "l6", 14, monitor_get_reg },
3461 { "l7", 15, monitor_get_reg },
3462 { "i0", 16, monitor_get_reg },
3463 { "i1", 17, monitor_get_reg },
3464 { "i2", 18, monitor_get_reg },
3465 { "i3", 19, monitor_get_reg },
3466 { "i4", 20, monitor_get_reg },
3467 { "i5", 21, monitor_get_reg },
3468 { "i6", 22, monitor_get_reg },
3469 { "i7", 23, monitor_get_reg },
3470 { "pc", offsetof(CPUState, pc) },
3471 { "npc", offsetof(CPUState, npc) },
3472 { "y", offsetof(CPUState, y) },
bellard7b936c02005-10-30 17:05:13 +00003473#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003474 { "psr", 0, &monitor_get_psr, },
3475 { "wim", offsetof(CPUState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003476#endif
bellarde95c8d52004-09-30 22:22:08 +00003477 { "tbr", offsetof(CPUState, tbr) },
3478 { "fsr", offsetof(CPUState, fsr) },
3479 { "f0", offsetof(CPUState, fpr[0]) },
3480 { "f1", offsetof(CPUState, fpr[1]) },
3481 { "f2", offsetof(CPUState, fpr[2]) },
3482 { "f3", offsetof(CPUState, fpr[3]) },
3483 { "f4", offsetof(CPUState, fpr[4]) },
3484 { "f5", offsetof(CPUState, fpr[5]) },
3485 { "f6", offsetof(CPUState, fpr[6]) },
3486 { "f7", offsetof(CPUState, fpr[7]) },
3487 { "f8", offsetof(CPUState, fpr[8]) },
3488 { "f9", offsetof(CPUState, fpr[9]) },
3489 { "f10", offsetof(CPUState, fpr[10]) },
3490 { "f11", offsetof(CPUState, fpr[11]) },
3491 { "f12", offsetof(CPUState, fpr[12]) },
3492 { "f13", offsetof(CPUState, fpr[13]) },
3493 { "f14", offsetof(CPUState, fpr[14]) },
3494 { "f15", offsetof(CPUState, fpr[15]) },
3495 { "f16", offsetof(CPUState, fpr[16]) },
3496 { "f17", offsetof(CPUState, fpr[17]) },
3497 { "f18", offsetof(CPUState, fpr[18]) },
3498 { "f19", offsetof(CPUState, fpr[19]) },
3499 { "f20", offsetof(CPUState, fpr[20]) },
3500 { "f21", offsetof(CPUState, fpr[21]) },
3501 { "f22", offsetof(CPUState, fpr[22]) },
3502 { "f23", offsetof(CPUState, fpr[23]) },
3503 { "f24", offsetof(CPUState, fpr[24]) },
3504 { "f25", offsetof(CPUState, fpr[25]) },
3505 { "f26", offsetof(CPUState, fpr[26]) },
3506 { "f27", offsetof(CPUState, fpr[27]) },
3507 { "f28", offsetof(CPUState, fpr[28]) },
3508 { "f29", offsetof(CPUState, fpr[29]) },
3509 { "f30", offsetof(CPUState, fpr[30]) },
3510 { "f31", offsetof(CPUState, fpr[31]) },
bellard7b936c02005-10-30 17:05:13 +00003511#ifdef TARGET_SPARC64
3512 { "f32", offsetof(CPUState, fpr[32]) },
3513 { "f34", offsetof(CPUState, fpr[34]) },
3514 { "f36", offsetof(CPUState, fpr[36]) },
3515 { "f38", offsetof(CPUState, fpr[38]) },
3516 { "f40", offsetof(CPUState, fpr[40]) },
3517 { "f42", offsetof(CPUState, fpr[42]) },
3518 { "f44", offsetof(CPUState, fpr[44]) },
3519 { "f46", offsetof(CPUState, fpr[46]) },
3520 { "f48", offsetof(CPUState, fpr[48]) },
3521 { "f50", offsetof(CPUState, fpr[50]) },
3522 { "f52", offsetof(CPUState, fpr[52]) },
3523 { "f54", offsetof(CPUState, fpr[54]) },
3524 { "f56", offsetof(CPUState, fpr[56]) },
3525 { "f58", offsetof(CPUState, fpr[58]) },
3526 { "f60", offsetof(CPUState, fpr[60]) },
3527 { "f62", offsetof(CPUState, fpr[62]) },
3528 { "asi", offsetof(CPUState, asi) },
3529 { "pstate", offsetof(CPUState, pstate) },
3530 { "cansave", offsetof(CPUState, cansave) },
3531 { "canrestore", offsetof(CPUState, canrestore) },
3532 { "otherwin", offsetof(CPUState, otherwin) },
3533 { "wstate", offsetof(CPUState, wstate) },
3534 { "cleanwin", offsetof(CPUState, cleanwin) },
3535 { "fprs", offsetof(CPUState, fprs) },
3536#endif
bellard9307c4c2004-04-04 12:57:25 +00003537#endif
3538 { NULL },
3539};
3540
aliguori376253e2009-03-05 23:01:23 +00003541static void expr_error(Monitor *mon, const char *msg)
bellard9dc39cb2004-03-14 21:38:27 +00003542{
aliguori376253e2009-03-05 23:01:23 +00003543 monitor_printf(mon, "%s\n", msg);
bellard9307c4c2004-04-04 12:57:25 +00003544 longjmp(expr_env, 1);
3545}
3546
Markus Armbruster09b94182010-01-20 13:07:30 +01003547/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003548static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003549{
blueswir18662d652008-10-02 18:32:44 +00003550 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003551 void *ptr;
3552
bellard9307c4c2004-04-04 12:57:25 +00003553 for(md = monitor_defs; md->name != NULL; md++) {
3554 if (compare_cmd(name, md->name)) {
3555 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003556 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003557 } else {
bellard6a00d602005-11-21 23:25:50 +00003558 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003559 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003560 switch(md->type) {
3561 case MD_I32:
3562 *pval = *(int32_t *)ptr;
3563 break;
3564 case MD_TLONG:
3565 *pval = *(target_long *)ptr;
3566 break;
3567 default:
3568 *pval = 0;
3569 break;
3570 }
bellard9307c4c2004-04-04 12:57:25 +00003571 }
3572 return 0;
3573 }
3574 }
3575 return -1;
3576}
3577
3578static void next(void)
3579{
Blue Swirl660f11b2009-07-31 21:16:51 +00003580 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003581 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003582 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003583 pch++;
3584 }
3585}
3586
aliguori376253e2009-03-05 23:01:23 +00003587static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003588
aliguori376253e2009-03-05 23:01:23 +00003589static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003590{
blueswir1c2efc952007-09-25 17:28:42 +00003591 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003592 char *p;
bellard6a00d602005-11-21 23:25:50 +00003593 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003594
3595 switch(*pch) {
3596 case '+':
3597 next();
aliguori376253e2009-03-05 23:01:23 +00003598 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003599 break;
3600 case '-':
3601 next();
aliguori376253e2009-03-05 23:01:23 +00003602 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003603 break;
3604 case '~':
3605 next();
aliguori376253e2009-03-05 23:01:23 +00003606 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003607 break;
3608 case '(':
3609 next();
aliguori376253e2009-03-05 23:01:23 +00003610 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003611 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003612 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003613 }
3614 next();
3615 break;
bellard81d09122004-07-14 17:21:37 +00003616 case '\'':
3617 pch++;
3618 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003619 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003620 n = *pch;
3621 pch++;
3622 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003623 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003624 next();
3625 break;
bellard9307c4c2004-04-04 12:57:25 +00003626 case '$':
3627 {
3628 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003629 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003630
bellard9307c4c2004-04-04 12:57:25 +00003631 pch++;
3632 q = buf;
3633 while ((*pch >= 'a' && *pch <= 'z') ||
3634 (*pch >= 'A' && *pch <= 'Z') ||
3635 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003636 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003637 if ((q - buf) < sizeof(buf) - 1)
3638 *q++ = *pch;
3639 pch++;
3640 }
blueswir1cd390082008-11-16 13:53:32 +00003641 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003642 pch++;
3643 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003644 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003645 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003646 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003647 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003648 }
3649 break;
3650 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003651 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003652 n = 0;
3653 break;
3654 default:
blueswir17743e582007-09-24 18:39:04 +00003655#if TARGET_PHYS_ADDR_BITS > 32
bellard4f4fbf72006-06-25 18:28:12 +00003656 n = strtoull(pch, &p, 0);
3657#else
bellard9307c4c2004-04-04 12:57:25 +00003658 n = strtoul(pch, &p, 0);
bellard4f4fbf72006-06-25 18:28:12 +00003659#endif
bellard9307c4c2004-04-04 12:57:25 +00003660 if (pch == p) {
aliguori376253e2009-03-05 23:01:23 +00003661 expr_error(mon, "invalid char in expression");
bellard9307c4c2004-04-04 12:57:25 +00003662 }
3663 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003664 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003665 pch++;
3666 break;
3667 }
3668 return n;
3669}
3670
3671
aliguori376253e2009-03-05 23:01:23 +00003672static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003673{
blueswir1c2efc952007-09-25 17:28:42 +00003674 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003675 int op;
ths3b46e622007-09-17 08:09:54 +00003676
aliguori376253e2009-03-05 23:01:23 +00003677 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003678 for(;;) {
3679 op = *pch;
3680 if (op != '*' && op != '/' && op != '%')
3681 break;
3682 next();
aliguori376253e2009-03-05 23:01:23 +00003683 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003684 switch(op) {
3685 default:
3686 case '*':
3687 val *= val2;
3688 break;
3689 case '/':
3690 case '%':
ths5fafdf22007-09-16 21:08:06 +00003691 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003692 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003693 if (op == '/')
3694 val /= val2;
3695 else
3696 val %= val2;
3697 break;
3698 }
3699 }
3700 return val;
3701}
3702
aliguori376253e2009-03-05 23:01:23 +00003703static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003704{
blueswir1c2efc952007-09-25 17:28:42 +00003705 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003706 int op;
bellard9307c4c2004-04-04 12:57:25 +00003707
aliguori376253e2009-03-05 23:01:23 +00003708 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003709 for(;;) {
3710 op = *pch;
3711 if (op != '&' && op != '|' && op != '^')
3712 break;
3713 next();
aliguori376253e2009-03-05 23:01:23 +00003714 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003715 switch(op) {
3716 default:
3717 case '&':
3718 val &= val2;
3719 break;
3720 case '|':
3721 val |= val2;
3722 break;
3723 case '^':
3724 val ^= val2;
3725 break;
3726 }
3727 }
3728 return val;
3729}
3730
aliguori376253e2009-03-05 23:01:23 +00003731static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003732{
blueswir1c2efc952007-09-25 17:28:42 +00003733 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003734 int op;
bellard9307c4c2004-04-04 12:57:25 +00003735
aliguori376253e2009-03-05 23:01:23 +00003736 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003737 for(;;) {
3738 op = *pch;
3739 if (op != '+' && op != '-')
3740 break;
3741 next();
aliguori376253e2009-03-05 23:01:23 +00003742 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003743 if (op == '+')
3744 val += val2;
3745 else
3746 val -= val2;
3747 }
3748 return val;
3749}
3750
aliguori376253e2009-03-05 23:01:23 +00003751static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003752{
3753 pch = *pp;
3754 if (setjmp(expr_env)) {
3755 *pp = pch;
3756 return -1;
3757 }
blueswir1cd390082008-11-16 13:53:32 +00003758 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003759 pch++;
aliguori376253e2009-03-05 23:01:23 +00003760 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003761 *pp = pch;
3762 return 0;
3763}
3764
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003765static int get_double(Monitor *mon, double *pval, const char **pp)
3766{
3767 const char *p = *pp;
3768 char *tailp;
3769 double d;
3770
3771 d = strtod(p, &tailp);
3772 if (tailp == p) {
3773 monitor_printf(mon, "Number expected\n");
3774 return -1;
3775 }
3776 if (d != d || d - d != 0) {
3777 /* NaN or infinity */
3778 monitor_printf(mon, "Bad number\n");
3779 return -1;
3780 }
3781 *pval = d;
3782 *pp = tailp;
3783 return 0;
3784}
3785
bellard9307c4c2004-04-04 12:57:25 +00003786static int get_str(char *buf, int buf_size, const char **pp)
3787{
3788 const char *p;
3789 char *q;
3790 int c;
3791
bellard81d09122004-07-14 17:21:37 +00003792 q = buf;
bellard9307c4c2004-04-04 12:57:25 +00003793 p = *pp;
blueswir1cd390082008-11-16 13:53:32 +00003794 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003795 p++;
3796 if (*p == '\0') {
3797 fail:
bellard81d09122004-07-14 17:21:37 +00003798 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003799 *pp = p;
3800 return -1;
3801 }
bellard9307c4c2004-04-04 12:57:25 +00003802 if (*p == '\"') {
3803 p++;
3804 while (*p != '\0' && *p != '\"') {
3805 if (*p == '\\') {
3806 p++;
3807 c = *p++;
3808 switch(c) {
3809 case 'n':
3810 c = '\n';
3811 break;
3812 case 'r':
3813 c = '\r';
3814 break;
3815 case '\\':
3816 case '\'':
3817 case '\"':
3818 break;
3819 default:
3820 qemu_printf("unsupported escape code: '\\%c'\n", c);
3821 goto fail;
3822 }
3823 if ((q - buf) < buf_size - 1) {
3824 *q++ = c;
3825 }
3826 } else {
3827 if ((q - buf) < buf_size - 1) {
3828 *q++ = *p;
3829 }
3830 p++;
3831 }
3832 }
3833 if (*p != '\"') {
bellard5b602122004-05-22 21:41:05 +00003834 qemu_printf("unterminated string\n");
bellard9307c4c2004-04-04 12:57:25 +00003835 goto fail;
3836 }
3837 p++;
3838 } else {
blueswir1cd390082008-11-16 13:53:32 +00003839 while (*p != '\0' && !qemu_isspace(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003840 if ((q - buf) < buf_size - 1) {
3841 *q++ = *p;
3842 }
3843 p++;
3844 }
bellard9307c4c2004-04-04 12:57:25 +00003845 }
bellard81d09122004-07-14 17:21:37 +00003846 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003847 *pp = p;
3848 return 0;
3849}
3850
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003851/*
3852 * Store the command-name in cmdname, and return a pointer to
3853 * the remaining of the command string.
3854 */
3855static const char *get_command_name(const char *cmdline,
3856 char *cmdname, size_t nlen)
3857{
3858 size_t len;
3859 const char *p, *pstart;
3860
3861 p = cmdline;
3862 while (qemu_isspace(*p))
3863 p++;
3864 if (*p == '\0')
3865 return NULL;
3866 pstart = p;
3867 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3868 p++;
3869 len = p - pstart;
3870 if (len > nlen - 1)
3871 len = nlen - 1;
3872 memcpy(cmdname, pstart, len);
3873 cmdname[len] = '\0';
3874 return p;
3875}
3876
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003877/**
3878 * Read key of 'type' into 'key' and return the current
3879 * 'type' pointer.
3880 */
3881static char *key_get_info(const char *type, char **key)
3882{
3883 size_t len;
3884 char *p, *str;
3885
3886 if (*type == ',')
3887 type++;
3888
3889 p = strchr(type, ':');
3890 if (!p) {
3891 *key = NULL;
3892 return NULL;
3893 }
3894 len = p - type;
3895
3896 str = qemu_malloc(len + 1);
3897 memcpy(str, type, len);
3898 str[len] = '\0';
3899
3900 *key = str;
3901 return ++p;
3902}
3903
bellard9307c4c2004-04-04 12:57:25 +00003904static int default_fmt_format = 'x';
3905static int default_fmt_size = 4;
3906
3907#define MAX_ARGS 16
3908
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003909static int is_valid_option(const char *c, const char *typestr)
3910{
3911 char option[3];
3912
3913 option[0] = '-';
3914 option[1] = *c;
3915 option[2] = '\0';
3916
3917 typestr = strstr(typestr, option);
3918 return (typestr != NULL);
3919}
3920
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003921static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3922 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003923{
3924 const mon_cmd_t *cmd;
3925
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003926 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003927 if (compare_cmd(cmdname, cmd->name)) {
3928 return cmd;
3929 }
3930 }
3931
3932 return NULL;
3933}
3934
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003935static const mon_cmd_t *monitor_find_command(const char *cmdname)
3936{
3937 return search_dispatch_table(mon_cmds, cmdname);
3938}
3939
Luiz Capitulino030db6e2010-09-10 16:03:38 -03003940static const mon_cmd_t *qmp_find_query_cmd(const char *info_item)
3941{
Luiz Capitulino3e12a752010-09-15 17:20:33 -03003942 return search_dispatch_table(qmp_query_cmds, info_item);
Luiz Capitulino030db6e2010-09-10 16:03:38 -03003943}
3944
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003945static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3946{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003947 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003948}
3949
Anthony Liguoric227f092009-10-01 16:12:16 -05003950static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003951 const char *cmdline,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003952 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003953{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003954 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003955 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003956 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003957 char cmdname[256];
3958 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003959 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003960
3961#ifdef DEBUG
aliguori376253e2009-03-05 23:01:23 +00003962 monitor_printf(mon, "command='%s'\n", cmdline);
bellard9dc39cb2004-03-14 21:38:27 +00003963#endif
ths3b46e622007-09-17 08:09:54 +00003964
bellard9307c4c2004-04-04 12:57:25 +00003965 /* extract the command name */
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003966 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3967 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003968 return NULL;
ths3b46e622007-09-17 08:09:54 +00003969
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003970 cmd = monitor_find_command(cmdname);
3971 if (!cmd) {
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003972 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003973 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003974 }
bellard9307c4c2004-04-04 12:57:25 +00003975
bellard9307c4c2004-04-04 12:57:25 +00003976 /* parse the parameters */
3977 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003978 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003979 typestr = key_get_info(typestr, &key);
3980 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003981 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003982 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003983 typestr++;
3984 switch(c) {
3985 case 'F':
bellard81d09122004-07-14 17:21:37 +00003986 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003987 case 's':
3988 {
3989 int ret;
ths3b46e622007-09-17 08:09:54 +00003990
blueswir1cd390082008-11-16 13:53:32 +00003991 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003992 p++;
3993 if (*typestr == '?') {
3994 typestr++;
3995 if (*p == '\0') {
3996 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003997 break;
bellard9307c4c2004-04-04 12:57:25 +00003998 }
3999 }
4000 ret = get_str(buf, sizeof(buf), &p);
4001 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00004002 switch(c) {
4003 case 'F':
aliguori376253e2009-03-05 23:01:23 +00004004 monitor_printf(mon, "%s: filename expected\n",
4005 cmdname);
bellard81d09122004-07-14 17:21:37 +00004006 break;
4007 case 'B':
aliguori376253e2009-03-05 23:01:23 +00004008 monitor_printf(mon, "%s: block device name expected\n",
4009 cmdname);
bellard81d09122004-07-14 17:21:37 +00004010 break;
4011 default:
aliguori376253e2009-03-05 23:01:23 +00004012 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00004013 break;
4014 }
bellard9307c4c2004-04-04 12:57:25 +00004015 goto fail;
4016 }
Luiz Capitulino53773582009-08-28 15:27:25 -03004017 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00004018 }
4019 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01004020 case 'O':
4021 {
4022 QemuOptsList *opts_list;
4023 QemuOpts *opts;
4024
4025 opts_list = qemu_find_opts(key);
4026 if (!opts_list || opts_list->desc->name) {
4027 goto bad_type;
4028 }
4029 while (qemu_isspace(*p)) {
4030 p++;
4031 }
4032 if (!*p)
4033 break;
4034 if (get_str(buf, sizeof(buf), &p) < 0) {
4035 goto fail;
4036 }
4037 opts = qemu_opts_parse(opts_list, buf, 1);
4038 if (!opts) {
4039 goto fail;
4040 }
4041 qemu_opts_to_qdict(opts, qdict);
4042 qemu_opts_del(opts);
4043 }
4044 break;
bellard9307c4c2004-04-04 12:57:25 +00004045 case '/':
4046 {
4047 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00004048
blueswir1cd390082008-11-16 13:53:32 +00004049 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004050 p++;
4051 if (*p == '/') {
4052 /* format found */
4053 p++;
4054 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00004055 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00004056 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00004057 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00004058 count = count * 10 + (*p - '0');
4059 p++;
4060 }
4061 }
4062 size = -1;
4063 format = -1;
4064 for(;;) {
4065 switch(*p) {
4066 case 'o':
4067 case 'd':
4068 case 'u':
4069 case 'x':
4070 case 'i':
4071 case 'c':
4072 format = *p++;
4073 break;
4074 case 'b':
4075 size = 1;
4076 p++;
4077 break;
4078 case 'h':
4079 size = 2;
4080 p++;
4081 break;
4082 case 'w':
4083 size = 4;
4084 p++;
4085 break;
4086 case 'g':
4087 case 'L':
4088 size = 8;
4089 p++;
4090 break;
4091 default:
4092 goto next;
4093 }
4094 }
4095 next:
blueswir1cd390082008-11-16 13:53:32 +00004096 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00004097 monitor_printf(mon, "invalid char in format: '%c'\n",
4098 *p);
bellard9307c4c2004-04-04 12:57:25 +00004099 goto fail;
4100 }
bellard9307c4c2004-04-04 12:57:25 +00004101 if (format < 0)
4102 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00004103 if (format != 'i') {
4104 /* for 'i', not specifying a size gives -1 as size */
4105 if (size < 0)
4106 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00004107 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00004108 }
bellard9307c4c2004-04-04 12:57:25 +00004109 default_fmt_format = format;
4110 } else {
4111 count = 1;
4112 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00004113 if (format != 'i') {
4114 size = default_fmt_size;
4115 } else {
4116 size = -1;
4117 }
bellard9307c4c2004-04-04 12:57:25 +00004118 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004119 qdict_put(qdict, "count", qint_from_int(count));
4120 qdict_put(qdict, "format", qint_from_int(format));
4121 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00004122 }
4123 break;
4124 case 'i':
bellard92a31b12005-02-10 22:00:52 +00004125 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02004126 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00004127 {
blueswir1c2efc952007-09-25 17:28:42 +00004128 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00004129
blueswir1cd390082008-11-16 13:53:32 +00004130 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004131 p++;
bellard34405572004-06-08 00:55:58 +00004132 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00004133 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03004134 if (*p == '\0') {
4135 typestr++;
4136 break;
4137 }
bellard34405572004-06-08 00:55:58 +00004138 } else {
4139 if (*p == '.') {
4140 p++;
blueswir1cd390082008-11-16 13:53:32 +00004141 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00004142 p++;
bellard34405572004-06-08 00:55:58 +00004143 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03004144 typestr++;
4145 break;
bellard34405572004-06-08 00:55:58 +00004146 }
4147 }
bellard13224a82006-07-14 22:03:35 +00004148 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00004149 }
aliguori376253e2009-03-05 23:01:23 +00004150 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00004151 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03004152 /* Check if 'i' is greater than 32-bit */
4153 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
4154 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
4155 monitor_printf(mon, "integer is for 32-bit values\n");
4156 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02004157 } else if (c == 'M') {
4158 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03004159 }
Luiz Capitulino53773582009-08-28 15:27:25 -03004160 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00004161 }
4162 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02004163 case 'o':
4164 {
4165 ssize_t val;
4166 char *end;
4167
4168 while (qemu_isspace(*p)) {
4169 p++;
4170 }
4171 if (*typestr == '?') {
4172 typestr++;
4173 if (*p == '\0') {
4174 break;
4175 }
4176 }
4177 val = strtosz(p, &end);
4178 if (val < 0) {
4179 monitor_printf(mon, "invalid size\n");
4180 goto fail;
4181 }
4182 qdict_put(qdict, key, qint_from_int(val));
4183 p = end;
4184 }
4185 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01004186 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01004187 {
4188 double val;
4189
4190 while (qemu_isspace(*p))
4191 p++;
4192 if (*typestr == '?') {
4193 typestr++;
4194 if (*p == '\0') {
4195 break;
4196 }
4197 }
4198 if (get_double(mon, &val, &p) < 0) {
4199 goto fail;
4200 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02004201 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01004202 switch (*p) {
4203 case 'm':
4204 val /= 1e3; p += 2; break;
4205 case 'u':
4206 val /= 1e6; p += 2; break;
4207 case 'n':
4208 val /= 1e9; p += 2; break;
4209 }
4210 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01004211 if (*p && !qemu_isspace(*p)) {
4212 monitor_printf(mon, "Unknown unit suffix\n");
4213 goto fail;
4214 }
4215 qdict_put(qdict, key, qfloat_from_double(val));
4216 }
4217 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01004218 case 'b':
4219 {
4220 const char *beg;
4221 int val;
4222
4223 while (qemu_isspace(*p)) {
4224 p++;
4225 }
4226 beg = p;
4227 while (qemu_isgraph(*p)) {
4228 p++;
4229 }
4230 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4231 val = 1;
4232 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4233 val = 0;
4234 } else {
4235 monitor_printf(mon, "Expected 'on' or 'off'\n");
4236 goto fail;
4237 }
4238 qdict_put(qdict, key, qbool_from_int(val));
4239 }
4240 break;
bellard9307c4c2004-04-04 12:57:25 +00004241 case '-':
4242 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004243 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004244 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00004245 /* option */
ths3b46e622007-09-17 08:09:54 +00004246
bellard9307c4c2004-04-04 12:57:25 +00004247 c = *typestr++;
4248 if (c == '\0')
4249 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00004250 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004251 p++;
bellard9307c4c2004-04-04 12:57:25 +00004252 if (*p == '-') {
4253 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004254 if(c != *p) {
4255 if(!is_valid_option(p, typestr)) {
4256
4257 monitor_printf(mon, "%s: unsupported option -%c\n",
4258 cmdname, *p);
4259 goto fail;
4260 } else {
4261 skip_key = 1;
4262 }
bellard9307c4c2004-04-04 12:57:25 +00004263 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004264 if(skip_key) {
4265 p = tmp;
4266 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004267 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004268 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004269 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004270 }
bellard9307c4c2004-04-04 12:57:25 +00004271 }
bellard9307c4c2004-04-04 12:57:25 +00004272 }
4273 break;
4274 default:
4275 bad_type:
aliguori376253e2009-03-05 23:01:23 +00004276 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00004277 goto fail;
4278 }
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004279 qemu_free(key);
4280 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00004281 }
4282 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00004283 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004284 p++;
4285 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00004286 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4287 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00004288 goto fail;
4289 }
4290
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004291 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02004292
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004293fail:
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004294 qemu_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004295 return NULL;
4296}
4297
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004298void monitor_set_error(Monitor *mon, QError *qerror)
4299{
4300 /* report only the first error */
4301 if (!mon->error) {
4302 mon->error = qerror;
4303 } else {
4304 MON_DEBUG("Additional error report at %s:%d\n",
4305 qerror->file, qerror->linenr);
4306 QDECREF(qerror);
4307 }
4308}
4309
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004310static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4311{
Luiz Capitulino6d441432010-11-22 16:35:09 -02004312 if (ret && !monitor_has_error(mon)) {
4313 /*
4314 * If it returns failure, it must have passed on error.
4315 *
4316 * Action: Report an internal error to the client if in QMP.
4317 */
4318 qerror_report(QERR_UNDEFINED_ERROR);
4319 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
4320 cmd->name);
4321 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004322
4323#ifdef CONFIG_DEBUG_MONITOR
Luiz Capitulino6d441432010-11-22 16:35:09 -02004324 if (!ret && monitor_has_error(mon)) {
4325 /*
4326 * If it returns success, it must not have passed an error.
4327 *
4328 * Action: Report the passed error to the client.
4329 */
4330 MON_DEBUG("command '%s' returned success but passed an error\n",
4331 cmd->name);
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004332 }
Luiz Capitulino6d441432010-11-22 16:35:09 -02004333
4334 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
4335 /*
4336 * Handlers should not call Monitor print functions.
4337 *
4338 * Action: Ignore them in QMP.
4339 *
4340 * (XXX: we don't check any 'info' or 'query' command here
4341 * because the user print function _is_ called by do_info(), hence
4342 * we will trigger this check. This problem will go away when we
4343 * make 'query' commands real and kill do_info())
4344 */
4345 MON_DEBUG("command '%s' called print functions %d time(s)\n",
4346 cmd->name, mon_print_count_get(mon));
4347 }
4348#endif
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004349}
4350
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004351static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004352{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004353 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05004354 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004355
4356 qdict = qdict_new();
4357
Luiz Capitulino590fb3b2009-08-28 15:27:24 -03004358 cmd = monitor_parse_command(mon, cmdline, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03004359 if (!cmd)
4360 goto out;
4361
Luiz Capitulino4903de02010-09-16 11:01:32 -03004362 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06004363 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03004364 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03004365 QObject *data = NULL;
4366
4367 /* XXX: ignores the error code */
4368 cmd->mhandler.cmd_new(mon, qdict, &data);
4369 assert(!monitor_has_error(mon));
4370 if (data) {
4371 cmd->user_print(mon, data);
4372 qobject_decref(data);
4373 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03004374 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03004375 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004376 }
4377
Luiz Capitulino13917be2009-10-07 13:41:54 -03004378out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004379 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00004380}
4381
bellard81d09122004-07-14 17:21:37 +00004382static void cmd_completion(const char *name, const char *list)
4383{
4384 const char *p, *pstart;
4385 char cmd[128];
4386 int len;
4387
4388 p = list;
4389 for(;;) {
4390 pstart = p;
4391 p = strchr(p, '|');
4392 if (!p)
4393 p = pstart + strlen(pstart);
4394 len = p - pstart;
4395 if (len > sizeof(cmd) - 2)
4396 len = sizeof(cmd) - 2;
4397 memcpy(cmd, pstart, len);
4398 cmd[len] = '\0';
4399 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
aliguori731b0362009-03-05 23:01:42 +00004400 readline_add_completion(cur_mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00004401 }
4402 if (*p == '\0')
4403 break;
4404 p++;
4405 }
4406}
4407
4408static void file_completion(const char *input)
4409{
4410 DIR *ffs;
4411 struct dirent *d;
4412 char path[1024];
4413 char file[1024], file_prefix[1024];
4414 int input_path_len;
4415 const char *p;
4416
ths5fafdf22007-09-16 21:08:06 +00004417 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004418 if (!p) {
4419 input_path_len = 0;
4420 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004421 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004422 } else {
4423 input_path_len = p - input + 1;
4424 memcpy(path, input, input_path_len);
4425 if (input_path_len > sizeof(path) - 1)
4426 input_path_len = sizeof(path) - 1;
4427 path[input_path_len] = '\0';
4428 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4429 }
4430#ifdef DEBUG_COMPLETION
aliguori376253e2009-03-05 23:01:23 +00004431 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4432 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004433#endif
4434 ffs = opendir(path);
4435 if (!ffs)
4436 return;
4437 for(;;) {
4438 struct stat sb;
4439 d = readdir(ffs);
4440 if (!d)
4441 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004442
4443 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4444 continue;
4445 }
4446
bellard81d09122004-07-14 17:21:37 +00004447 if (strstart(d->d_name, file_prefix, NULL)) {
4448 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004449 if (input_path_len < sizeof(file))
4450 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4451 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004452 /* stat the file to find out if it's a directory.
4453 * In that case add a slash to speed up typing long paths
4454 */
4455 stat(file, &sb);
4456 if(S_ISDIR(sb.st_mode))
blueswir1363a37d2008-08-21 17:58:08 +00004457 pstrcat(file, sizeof(file), "/");
aliguori731b0362009-03-05 23:01:42 +00004458 readline_add_completion(cur_mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004459 }
4460 }
4461 closedir(ffs);
4462}
4463
aliguori51de9762009-03-05 23:00:43 +00004464static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004465{
aliguori51de9762009-03-05 23:00:43 +00004466 const char *name = bdrv_get_device_name(bs);
bellard81d09122004-07-14 17:21:37 +00004467 const char *input = opaque;
4468
4469 if (input[0] == '\0' ||
4470 !strncmp(name, (char *)input, strlen(input))) {
aliguori731b0362009-03-05 23:01:42 +00004471 readline_add_completion(cur_mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004472 }
4473}
4474
4475/* NOTE: this parser is an approximate form of the real command parser */
4476static void parse_cmdline(const char *cmdline,
4477 int *pnb_args, char **args)
4478{
4479 const char *p;
4480 int nb_args, ret;
4481 char buf[1024];
4482
4483 p = cmdline;
4484 nb_args = 0;
4485 for(;;) {
blueswir1cd390082008-11-16 13:53:32 +00004486 while (qemu_isspace(*p))
bellard81d09122004-07-14 17:21:37 +00004487 p++;
4488 if (*p == '\0')
4489 break;
4490 if (nb_args >= MAX_ARGS)
4491 break;
4492 ret = get_str(buf, sizeof(buf), &p);
4493 args[nb_args] = qemu_strdup(buf);
4494 nb_args++;
4495 if (ret < 0)
4496 break;
4497 }
4498 *pnb_args = nb_args;
4499}
4500
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004501static const char *next_arg_type(const char *typestr)
4502{
4503 const char *p = strchr(typestr, ':');
4504 return (p != NULL ? ++p : typestr);
4505}
4506
aliguori4c36ba32009-03-05 23:01:37 +00004507static void monitor_find_completion(const char *cmdline)
bellard81d09122004-07-14 17:21:37 +00004508{
4509 const char *cmdname;
4510 char *args[MAX_ARGS];
4511 int nb_args, i, len;
4512 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004513 const mon_cmd_t *cmd;
bellard64866c32006-05-07 18:03:31 +00004514 const KeyDef *key;
bellard81d09122004-07-14 17:21:37 +00004515
4516 parse_cmdline(cmdline, &nb_args, args);
4517#ifdef DEBUG_COMPLETION
4518 for(i = 0; i < nb_args; i++) {
aliguori376253e2009-03-05 23:01:23 +00004519 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard81d09122004-07-14 17:21:37 +00004520 }
4521#endif
4522
4523 /* if the line ends with a space, it means we want to complete the
4524 next arg */
4525 len = strlen(cmdline);
blueswir1cd390082008-11-16 13:53:32 +00004526 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004527 if (nb_args >= MAX_ARGS) {
4528 goto cleanup;
4529 }
bellard81d09122004-07-14 17:21:37 +00004530 args[nb_args++] = qemu_strdup("");
4531 }
4532 if (nb_args <= 1) {
4533 /* command completion */
4534 if (nb_args == 0)
4535 cmdname = "";
4536 else
4537 cmdname = args[0];
aliguori731b0362009-03-05 23:01:42 +00004538 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
aliguori376253e2009-03-05 23:01:23 +00004539 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004540 cmd_completion(cmdname, cmd->name);
4541 }
4542 } else {
4543 /* find the command */
Jan Kiszka03a63482010-06-16 00:38:33 +02004544 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4545 if (compare_cmd(args[0], cmd->name)) {
4546 break;
4547 }
bellard81d09122004-07-14 17:21:37 +00004548 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004549 if (!cmd->name) {
4550 goto cleanup;
4551 }
4552
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004553 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004554 for(i = 0; i < nb_args - 2; i++) {
4555 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004556 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004557 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004558 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004559 }
4560 }
4561 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004562 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004563 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004564 }
bellard81d09122004-07-14 17:21:37 +00004565 switch(*ptype) {
4566 case 'F':
4567 /* file completion */
aliguori731b0362009-03-05 23:01:42 +00004568 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004569 file_completion(str);
4570 break;
4571 case 'B':
4572 /* block device name completion */
aliguori731b0362009-03-05 23:01:42 +00004573 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004574 bdrv_iterate(block_completion_it, (void *)str);
4575 break;
bellard7fe48482004-10-09 18:08:01 +00004576 case 's':
4577 /* XXX: more generic ? */
4578 if (!strcmp(cmd->name, "info")) {
aliguori731b0362009-03-05 23:01:42 +00004579 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard7fe48482004-10-09 18:08:01 +00004580 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4581 cmd_completion(str, cmd->name);
4582 }
bellard64866c32006-05-07 18:03:31 +00004583 } else if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004584 char *sep = strrchr(str, '-');
4585 if (sep)
4586 str = sep + 1;
aliguori731b0362009-03-05 23:01:42 +00004587 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard64866c32006-05-07 18:03:31 +00004588 for(key = key_defs; key->name != NULL; key++) {
4589 cmd_completion(str, key->name);
4590 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004591 } else if (!strcmp(cmd->name, "help|?")) {
4592 readline_set_completion_index(cur_mon->rs, strlen(str));
4593 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4594 cmd_completion(str, cmd->name);
4595 }
bellard7fe48482004-10-09 18:08:01 +00004596 }
4597 break;
bellard81d09122004-07-14 17:21:37 +00004598 default:
4599 break;
4600 }
4601 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004602
4603cleanup:
4604 for (i = 0; i < nb_args; i++) {
bellard81d09122004-07-14 17:21:37 +00004605 qemu_free(args[i]);
Jan Kiszka03a63482010-06-16 00:38:33 +02004606 }
bellard81d09122004-07-14 17:21:37 +00004607}
4608
aliguori731b0362009-03-05 23:01:42 +00004609static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004610{
aliguori731b0362009-03-05 23:01:42 +00004611 Monitor *mon = opaque;
4612
Jan Kiszkac62313b2009-12-04 14:05:29 +01004613 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004614}
4615
Luiz Capitulino09069b12010-02-04 18:10:06 -02004616static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4617{
4618 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4619 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4620}
4621
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004622/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004623 * Argument validation rules:
4624 *
4625 * 1. The argument must exist in cmd_args qdict
4626 * 2. The argument type must be the expected one
4627 *
4628 * Special case: If the argument doesn't exist in cmd_args and
4629 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4630 * checking is skipped for it.
4631 */
4632static int check_client_args_type(const QDict *client_args,
4633 const QDict *cmd_args, int flags)
4634{
4635 const QDictEntry *ent;
4636
4637 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4638 QObject *obj;
4639 QString *arg_type;
4640 const QObject *client_arg = qdict_entry_value(ent);
4641 const char *client_arg_name = qdict_entry_key(ent);
4642
4643 obj = qdict_get(cmd_args, client_arg_name);
4644 if (!obj) {
4645 if (flags & QMP_ACCEPT_UNKNOWNS) {
4646 /* handler accepts unknowns */
4647 continue;
4648 }
4649 /* client arg doesn't exist */
4650 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4651 return -1;
4652 }
4653
4654 arg_type = qobject_to_qstring(obj);
4655 assert(arg_type != NULL);
4656
4657 /* check if argument's type is correct */
4658 switch (qstring_get_str(arg_type)[0]) {
4659 case 'F':
4660 case 'B':
4661 case 's':
4662 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4663 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4664 "string");
4665 return -1;
4666 }
4667 break;
4668 case 'i':
4669 case 'l':
4670 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004671 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004672 if (qobject_type(client_arg) != QTYPE_QINT) {
4673 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4674 "int");
4675 return -1;
4676 }
4677 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004678 case 'T':
4679 if (qobject_type(client_arg) != QTYPE_QINT &&
4680 qobject_type(client_arg) != QTYPE_QFLOAT) {
4681 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4682 "number");
4683 return -1;
4684 }
4685 break;
4686 case 'b':
4687 case '-':
4688 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4689 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4690 "bool");
4691 return -1;
4692 }
4693 break;
4694 case 'O':
4695 assert(flags & QMP_ACCEPT_UNKNOWNS);
4696 break;
4697 case '/':
4698 case '.':
4699 /*
4700 * These types are not supported by QMP and thus are not
4701 * handled here. Fall through.
4702 */
4703 default:
4704 abort();
4705 }
4706 }
4707
4708 return 0;
4709}
4710
4711/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004712 * - Check if the client has passed all mandatory args
4713 * - Set special flags for argument validation
4714 */
4715static int check_mandatory_args(const QDict *cmd_args,
4716 const QDict *client_args, int *flags)
4717{
4718 const QDictEntry *ent;
4719
4720 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4721 const char *cmd_arg_name = qdict_entry_key(ent);
4722 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4723 assert(type != NULL);
4724
4725 if (qstring_get_str(type)[0] == 'O') {
4726 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4727 *flags |= QMP_ACCEPT_UNKNOWNS;
4728 } else if (qstring_get_str(type)[0] != '-' &&
4729 qstring_get_str(type)[1] != '?' &&
4730 !qdict_haskey(client_args, cmd_arg_name)) {
4731 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4732 return -1;
4733 }
4734 }
4735
4736 return 0;
4737}
4738
4739static QDict *qdict_from_args_type(const char *args_type)
4740{
4741 int i;
4742 QDict *qdict;
4743 QString *key, *type, *cur_qs;
4744
4745 assert(args_type != NULL);
4746
4747 qdict = qdict_new();
4748
4749 if (args_type == NULL || args_type[0] == '\0') {
4750 /* no args, empty qdict */
4751 goto out;
4752 }
4753
4754 key = qstring_new();
4755 type = qstring_new();
4756
4757 cur_qs = key;
4758
4759 for (i = 0;; i++) {
4760 switch (args_type[i]) {
4761 case ',':
4762 case '\0':
4763 qdict_put(qdict, qstring_get_str(key), type);
4764 QDECREF(key);
4765 if (args_type[i] == '\0') {
4766 goto out;
4767 }
4768 type = qstring_new(); /* qdict has ref */
4769 cur_qs = key = qstring_new();
4770 break;
4771 case ':':
4772 cur_qs = type;
4773 break;
4774 default:
4775 qstring_append_chr(cur_qs, args_type[i]);
4776 break;
4777 }
4778 }
4779
4780out:
4781 return qdict;
4782}
4783
4784/*
4785 * Client argument checking rules:
4786 *
4787 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004788 * 2. Each argument provided by the client must be expected
4789 * 3. Each argument provided by the client must have the type expected
4790 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004791 */
4792static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4793{
4794 int flags, err;
4795 QDict *cmd_args;
4796
4797 cmd_args = qdict_from_args_type(cmd->args_type);
4798
4799 flags = 0;
4800 err = check_mandatory_args(cmd_args, client_args, &flags);
4801 if (err) {
4802 goto out;
4803 }
4804
Luiz Capitulino4af91932010-06-22 11:44:05 -03004805 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004806
4807out:
4808 QDECREF(cmd_args);
4809 return err;
4810}
4811
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004812/*
4813 * Input object checking rules
4814 *
4815 * 1. Input object must be a dict
4816 * 2. The "execute" key must exist
4817 * 3. The "execute" key must be a string
4818 * 4. If the "arguments" key exists, it must be a dict
4819 * 5. If the "id" key exists, it can be anything (ie. json-value)
4820 * 6. Any argument not listed above is considered invalid
4821 */
4822static QDict *qmp_check_input_obj(QObject *input_obj)
4823{
4824 const QDictEntry *ent;
4825 int has_exec_key = 0;
4826 QDict *input_dict;
4827
4828 if (qobject_type(input_obj) != QTYPE_QDICT) {
4829 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4830 return NULL;
4831 }
4832
4833 input_dict = qobject_to_qdict(input_obj);
4834
4835 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4836 const char *arg_name = qdict_entry_key(ent);
4837 const QObject *arg_obj = qdict_entry_value(ent);
4838
4839 if (!strcmp(arg_name, "execute")) {
4840 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4841 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4842 "string");
4843 return NULL;
4844 }
4845 has_exec_key = 1;
4846 } else if (!strcmp(arg_name, "arguments")) {
4847 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4848 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4849 "object");
4850 return NULL;
4851 }
4852 } else if (!strcmp(arg_name, "id")) {
4853 /* FIXME: check duplicated IDs for async commands */
4854 } else {
4855 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4856 return NULL;
4857 }
4858 }
4859
4860 if (!has_exec_key) {
4861 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4862 return NULL;
4863 }
4864
4865 return input_dict;
4866}
4867
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004868static void qmp_call_query_cmd(Monitor *mon, const mon_cmd_t *cmd)
4869{
4870 QObject *ret_data = NULL;
4871
Luiz Capitulino4903de02010-09-16 11:01:32 -03004872 if (handler_is_async(cmd)) {
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004873 qmp_async_info_handler(mon, cmd);
4874 if (monitor_has_error(mon)) {
4875 monitor_protocol_emitter(mon, NULL);
4876 }
4877 } else {
4878 cmd->mhandler.info_new(mon, &ret_data);
Luiz Capitulinoc01e6882010-11-22 16:22:47 -02004879 monitor_protocol_emitter(mon, ret_data);
4880 qobject_decref(ret_data);
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004881 }
4882}
4883
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004884static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4885 const QDict *params)
4886{
4887 int ret;
4888 QObject *data = NULL;
4889
4890 mon_print_count_init(mon);
4891
4892 ret = cmd->mhandler.cmd_new(mon, params, &data);
4893 handler_audit(mon, cmd, ret);
4894 monitor_protocol_emitter(mon, data);
4895 qobject_decref(data);
4896}
4897
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004898static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4899{
4900 int err;
4901 QObject *obj;
4902 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004903 const mon_cmd_t *cmd;
4904 Monitor *mon = cur_mon;
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004905 const char *cmd_name, *query_cmd;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004906
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004907 query_cmd = NULL;
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004908 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004909
4910 obj = json_parser_parse(tokens, NULL);
4911 if (!obj) {
4912 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004913 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004914 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004915 }
4916
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004917 input = qmp_check_input_obj(obj);
4918 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004919 qobject_decref(obj);
4920 goto err_out;
4921 }
4922
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004923 mon->mc->id = qdict_get(input, "id");
4924 qobject_incref(mon->mc->id);
4925
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004926 cmd_name = qdict_get_str(input, "execute");
Luiz Capitulino09069b12010-02-04 18:10:06 -02004927 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004928 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004929 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004930 }
4931
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004932 if (strstart(cmd_name, "query-", &query_cmd)) {
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004933 cmd = qmp_find_query_cmd(query_cmd);
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004934 } else {
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03004935 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulino0fb88582010-09-15 10:56:17 -03004936 }
4937
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004938 if (!cmd) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004939 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4940 goto err_out;
4941 }
4942
4943 obj = qdict_get(input, "arguments");
4944 if (!obj) {
4945 args = qdict_new();
4946 } else {
4947 args = qobject_to_qdict(obj);
4948 QINCREF(args);
4949 }
4950
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004951 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004952 if (err < 0) {
4953 goto err_out;
4954 }
4955
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004956 if (query_cmd) {
4957 qmp_call_query_cmd(mon, cmd);
Luiz Capitulino4903de02010-09-16 11:01:32 -03004958 } else if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004959 err = qmp_async_cmd_handler(mon, cmd, args);
4960 if (err) {
4961 /* emit the error response */
4962 goto err_out;
4963 }
Adam Litke940cc302010-01-25 12:18:44 -06004964 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004965 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004966 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004967
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004968 goto out;
4969
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004970err_out:
4971 monitor_protocol_emitter(mon, NULL);
4972out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004973 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004974 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004975}
4976
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004977/**
4978 * monitor_control_read(): Read and handle QMP input
4979 */
4980static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4981{
4982 Monitor *old_mon = cur_mon;
4983
4984 cur_mon = opaque;
4985
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004986 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004987
4988 cur_mon = old_mon;
4989}
4990
aliguori731b0362009-03-05 23:01:42 +00004991static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004992{
aliguori731b0362009-03-05 23:01:42 +00004993 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004994 int i;
aliguori376253e2009-03-05 23:01:23 +00004995
aliguori731b0362009-03-05 23:01:42 +00004996 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004997
aliguoricde76ee2009-03-05 23:01:51 +00004998 if (cur_mon->rs) {
4999 for (i = 0; i < size; i++)
5000 readline_handle_byte(cur_mon->rs, buf[i]);
5001 } else {
5002 if (size == 0 || buf[size - 1] != 0)
5003 monitor_printf(cur_mon, "corrupted command\n");
5004 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02005005 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00005006 }
aliguori731b0362009-03-05 23:01:42 +00005007
5008 cur_mon = old_mon;
5009}
aliguorid8f44602008-10-06 13:52:44 +00005010
aliguori376253e2009-03-05 23:01:23 +00005011static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00005012{
aliguori731b0362009-03-05 23:01:42 +00005013 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02005014 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00005015 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00005016}
5017
aliguoricde76ee2009-03-05 23:01:51 +00005018int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00005019{
aliguoricde76ee2009-03-05 23:01:51 +00005020 if (!mon->rs)
5021 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00005022 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00005023 return 0;
aliguorid8f44602008-10-06 13:52:44 +00005024}
5025
aliguori376253e2009-03-05 23:01:23 +00005026void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00005027{
aliguoricde76ee2009-03-05 23:01:51 +00005028 if (!mon->rs)
5029 return;
aliguori731b0362009-03-05 23:01:42 +00005030 if (--mon->suspend_cnt == 0)
5031 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00005032}
5033
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02005034static QObject *get_qmp_greeting(void)
5035{
5036 QObject *ver;
5037
5038 do_info_version(NULL, &ver);
5039 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
5040}
5041
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005042/**
5043 * monitor_control_event(): Print QMP gretting
5044 */
5045static void monitor_control_event(void *opaque, int event)
5046{
Luiz Capitulino47116d12010-02-08 17:01:30 -02005047 QObject *data;
5048 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005049
Luiz Capitulino47116d12010-02-08 17:01:30 -02005050 switch (event) {
5051 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02005052 mon->mc->command_mode = 0;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02005053 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02005054 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005055 monitor_json_emitter(mon, data);
5056 qobject_decref(data);
Luiz Capitulino47116d12010-02-08 17:01:30 -02005057 break;
5058 case CHR_EVENT_CLOSED:
5059 json_message_parser_destroy(&mon->mc->parser);
5060 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005061 }
5062}
5063
aliguori731b0362009-03-05 23:01:42 +00005064static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00005065{
aliguori376253e2009-03-05 23:01:23 +00005066 Monitor *mon = opaque;
5067
aliguori2724b182009-03-05 23:01:47 +00005068 switch (event) {
5069 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02005070 mon->mux_out = 0;
5071 if (mon->reset_seen) {
5072 readline_restart(mon->rs);
5073 monitor_resume(mon);
5074 monitor_flush(mon);
5075 } else {
5076 mon->suspend_cnt = 0;
5077 }
aliguori2724b182009-03-05 23:01:47 +00005078 break;
ths86e94de2007-01-05 22:01:59 +00005079
aliguori2724b182009-03-05 23:01:47 +00005080 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02005081 if (mon->reset_seen) {
5082 if (mon->suspend_cnt == 0) {
5083 monitor_printf(mon, "\n");
5084 }
5085 monitor_flush(mon);
5086 monitor_suspend(mon);
5087 } else {
5088 mon->suspend_cnt++;
5089 }
5090 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00005091 break;
5092
Amit Shahb6b8df52009-10-07 18:31:16 +05305093 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00005094 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
5095 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02005096 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00005097 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02005098 }
5099 mon->reset_seen = 1;
aliguori2724b182009-03-05 23:01:47 +00005100 break;
5101 }
ths86e94de2007-01-05 22:01:59 +00005102}
5103
aliguori76655d62009-03-06 20:27:37 +00005104
5105/*
5106 * Local variables:
5107 * c-indent-level: 4
5108 * c-basic-offset: 4
5109 * tab-width: 8
5110 * End:
5111 */
5112
aliguori731b0362009-03-05 23:01:42 +00005113void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00005114{
aliguori731b0362009-03-05 23:01:42 +00005115 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00005116 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00005117
5118 if (is_first_init) {
balrogc8256f92008-06-08 22:45:01 +00005119 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
ths20d8a3e2007-02-18 17:04:49 +00005120 is_first_init = 0;
5121 }
aliguori87127162009-03-05 23:01:29 +00005122
5123 mon = qemu_mallocz(sizeof(*mon));
ths20d8a3e2007-02-18 17:04:49 +00005124
aliguori87127162009-03-05 23:01:29 +00005125 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00005126 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00005127 if (flags & MONITOR_USE_READLINE) {
5128 mon->rs = readline_init(mon, monitor_find_completion);
5129 monitor_read_command(mon, 0);
5130 }
aliguori87127162009-03-05 23:01:29 +00005131
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005132 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02005133 mon->mc = qemu_mallocz(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005134 /* Control mode requires special handlers */
5135 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
5136 monitor_control_event, mon);
5137 } else {
5138 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
5139 monitor_event, mon);
5140 }
aliguori87127162009-03-05 23:01:29 +00005141
Blue Swirl72cf2d42009-09-12 07:36:22 +00005142 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01005143 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
5144 default_mon = mon;
bellard7e2515e2004-08-01 21:52:19 +00005145}
5146
aliguori376253e2009-03-05 23:01:23 +00005147static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00005148{
aliguoribb5fc202009-03-05 23:01:15 +00005149 BlockDriverState *bs = opaque;
5150 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00005151
aliguoribb5fc202009-03-05 23:01:15 +00005152 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00005153 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00005154 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00005155 }
aliguori731b0362009-03-05 23:01:42 +00005156 if (mon->password_completion_cb)
5157 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00005158
aliguori731b0362009-03-05 23:01:42 +00005159 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00005160}
aliguoric0f4ce72009-03-05 23:01:01 +00005161
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005162int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
5163 BlockDriverCompletionFunc *completion_cb,
5164 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00005165{
aliguoricde76ee2009-03-05 23:01:51 +00005166 int err;
5167
aliguoribb5fc202009-03-05 23:01:15 +00005168 if (!bdrv_key_required(bs)) {
5169 if (completion_cb)
5170 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005171 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00005172 }
aliguoric0f4ce72009-03-05 23:01:01 +00005173
Luiz Capitulino94171e12009-12-07 21:37:00 +01005174 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01005175 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005176 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01005177 }
5178
aliguori376253e2009-03-05 23:01:23 +00005179 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
5180 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00005181
aliguori731b0362009-03-05 23:01:42 +00005182 mon->password_completion_cb = completion_cb;
5183 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00005184
aliguoricde76ee2009-03-05 23:01:51 +00005185 err = monitor_read_password(mon, bdrv_password_cb, bs);
5186
5187 if (err && completion_cb)
5188 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005189
5190 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00005191}