blob: ad50f12edbd470e9e1ad8cd8e38a82be705207a8 [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"
37#include "sysemu.h"
aliguori376253e2009-03-05 23:01:23 +000038#include "monitor.h"
39#include "readline.h"
pbrook87ecb682007-11-17 17:14:51 +000040#include "console.h"
41#include "block.h"
42#include "audio/audio.h"
bellard9307c4c2004-04-04 12:57:25 +000043#include "disas.h"
aliguoridf751fa2008-12-04 20:19:35 +000044#include "balloon.h"
balrogc8256f92008-06-08 22:45:01 +000045#include "qemu-timer.h"
aliguori5bb79102008-10-13 03:12:02 +000046#include "migration.h"
aliguori7ba1e612008-11-05 16:04:33 +000047#include "kvm.h"
aliguori76655d62009-03-06 20:27:37 +000048#include "acl.h"
Luiz Capitulinof7188bb2009-08-28 15:27:10 -030049#include "qint.h"
Markus Armbruster3350a4d2010-01-25 14:23:03 +010050#include "qfloat.h"
Luiz Capitulino8f3cec02009-10-07 13:42:04 -030051#include "qlist.h"
Luiz Capitulino5fa737a2009-11-26 22:59:01 -020052#include "qbool.h"
Luiz Capitulinof7188bb2009-08-28 15:27:10 -030053#include "qstring.h"
Luiz Capitulino9b57c022009-11-26 22:58:58 -020054#include "qjson.h"
Luiz Capitulino5fa737a2009-11-26 22:59:01 -020055#include "json-streamer.h"
56#include "json-parser.h"
Blue Swirld08d6f02009-12-04 18:06:39 +000057#include "osdep.h"
ths6a5bd302007-12-03 17:05:38 +000058
bellard9dc39cb2004-03-14 21:38:27 +000059//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000060//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000061
bellard9307c4c2004-04-04 12:57:25 +000062/*
63 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000064 *
bellard9307c4c2004-04-04 12:57:25 +000065 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000066 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000067 * 's' string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +010068 * 'O' option string of the form NAME=VALUE,...
69 * parsed according to QemuOptsList given by its name
70 * Example: 'device:O' uses qemu_device_opts.
71 * Restriction: only lists with empty desc are supported
72 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +000073 * 'i' 32 bit integer
74 * 'l' target long (32 or 64 bit)
Markus Armbruster9fec5432010-01-25 14:23:01 +010075 * 'M' just like 'l', except in user mode the value is
76 * multiplied by 2^20 (think Mebibyte)
Markus Armbrusteree9545d2010-03-26 09:07:08 +010077 * 'f' double
Markus Armbruster3350a4d2010-01-25 14:23:03 +010078 * user mode accepts an optional G, g, M, m, K, k suffix,
79 * which multiplies the value by 2^30 for suffixes G and
80 * g, 2^20 for M and m, 2^10 for K and k
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +010081 * 'T' double
82 * user mode accepts an optional ms, us, ns suffix,
83 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +000084 * '/' optional gdb-like print format (like "/10x")
85 *
Luiz Capitulinofb466602009-08-28 15:27:27 -030086 * '?' optional type (for all types, except '/')
87 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +010088 * 'b' boolean
89 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -030090 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +000091 *
92 */
93
Adam Litke940cc302010-01-25 12:18:44 -060094typedef struct MonitorCompletionData MonitorCompletionData;
95struct MonitorCompletionData {
96 Monitor *mon;
97 void (*user_print)(Monitor *mon, const QObject *data);
98};
99
Anthony Liguoric227f092009-10-01 16:12:16 -0500100typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000101 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000102 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000103 const char *params;
104 const char *help;
Luiz Capitulinoa2876f52009-10-07 13:41:53 -0300105 void (*user_print)(Monitor *mon, const QObject *data);
Luiz Capitulino910df892009-10-07 13:41:51 -0300106 union {
107 void (*info)(Monitor *mon);
Luiz Capitulino13c74252009-10-07 13:41:55 -0300108 void (*info_new)(Monitor *mon, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600109 int (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -0300110 void (*cmd)(Monitor *mon, const QDict *qdict);
Luiz Capitulino261394d2010-02-10 23:50:02 -0200111 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600112 int (*cmd_async)(Monitor *mon, const QDict *params,
113 MonitorCompletion *cb, void *opaque);
Luiz Capitulino910df892009-10-07 13:41:51 -0300114 } mhandler;
Adam Litke940cc302010-01-25 12:18:44 -0600115 int async;
Anthony Liguoric227f092009-10-01 16:12:16 -0500116} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000117
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100118/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500119typedef struct mon_fd_t mon_fd_t;
120struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100121 char *name;
122 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500123 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100124};
125
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200126typedef struct MonitorControl {
127 QObject *id;
128 JSONMessageParser parser;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200129 int command_mode;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200130} MonitorControl;
131
aliguori87127162009-03-05 23:01:29 +0000132struct Monitor {
133 CharDriverState *chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200134 int mux_out;
135 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000136 int flags;
137 int suspend_cnt;
138 uint8_t outbuf[1024];
139 int outbuf_index;
140 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200141 MonitorControl *mc;
aliguori731b0362009-03-05 23:01:42 +0000142 CPUState *mon_cpu;
143 BlockDriverCompletionFunc *password_completion_cb;
144 void *password_opaque;
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200145#ifdef CONFIG_DEBUG_MONITOR
146 int print_calls_nr;
147#endif
Luiz Capitulino8204a912009-11-18 23:05:31 -0200148 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500149 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000150 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000151};
152
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200153#ifdef CONFIG_DEBUG_MONITOR
154#define MON_DEBUG(fmt, ...) do { \
155 fprintf(stderr, "Monitor: "); \
156 fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200157
158static inline void mon_print_count_inc(Monitor *mon)
159{
160 mon->print_calls_nr++;
161}
162
163static inline void mon_print_count_init(Monitor *mon)
164{
165 mon->print_calls_nr = 0;
166}
167
168static inline int mon_print_count_get(const Monitor *mon)
169{
170 return mon->print_calls_nr;
171}
172
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200173#else /* !CONFIG_DEBUG_MONITOR */
174#define MON_DEBUG(fmt, ...) do { } while (0)
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200175static inline void mon_print_count_inc(Monitor *mon) { }
176static inline void mon_print_count_init(Monitor *mon) { }
177static inline int mon_print_count_get(const Monitor *mon) { return 0; }
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200178#endif /* CONFIG_DEBUG_MONITOR */
179
Blue Swirl72cf2d42009-09-12 07:36:22 +0000180static QLIST_HEAD(mon_list, Monitor) mon_list;
bellard7e2515e2004-08-01 21:52:19 +0000181
Anthony Liguoric227f092009-10-01 16:12:16 -0500182static const mon_cmd_t mon_cmds[];
183static const mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000184
Markus Armbruster8631b602010-02-18 11:41:55 +0100185Monitor *cur_mon;
186Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000187
aliguori731b0362009-03-05 23:01:42 +0000188static void monitor_command_cb(Monitor *mon, const char *cmdline,
189 void *opaque);
aliguori83ab7952008-08-19 14:44:22 +0000190
Luiz Capitulino09069b12010-02-04 18:10:06 -0200191static inline int qmp_cmd_mode(const Monitor *mon)
192{
193 return (mon->mc ? mon->mc->command_mode : 0);
194}
195
Luiz Capitulino418173c2009-11-26 22:58:51 -0200196/* Return true if in control mode, false otherwise */
197static inline int monitor_ctrl_mode(const Monitor *mon)
198{
199 return (mon->flags & MONITOR_USE_CONTROL);
200}
201
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100202/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
203int monitor_cur_is_qmp(void)
204{
205 return cur_mon && monitor_ctrl_mode(cur_mon);
206}
207
aliguori731b0362009-03-05 23:01:42 +0000208static void monitor_read_command(Monitor *mon, int show_prompt)
209{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200210 if (!mon->rs)
211 return;
212
aliguori731b0362009-03-05 23:01:42 +0000213 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
214 if (show_prompt)
215 readline_show_prompt(mon->rs);
216}
bellard6a00d602005-11-21 23:25:50 +0000217
aliguoricde76ee2009-03-05 23:01:51 +0000218static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
219 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000220{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100221 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100222 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100223 return -EINVAL;
224 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000225 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
226 /* prompt is printed on return from the command handler */
227 return 0;
228 } else {
229 monitor_printf(mon, "terminal does not support password prompting\n");
230 return -ENOTTY;
231 }
aliguoribb5fc202009-03-05 23:01:15 +0000232}
233
aliguori376253e2009-03-05 23:01:23 +0000234void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000235{
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200236 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
aliguori731b0362009-03-05 23:01:42 +0000237 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
238 mon->outbuf_index = 0;
bellard7e2515e2004-08-01 21:52:19 +0000239 }
240}
241
242/* flush at every end of line or if the buffer is full */
aliguori376253e2009-03-05 23:01:23 +0000243static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000244{
ths60fe76f2007-12-16 03:02:09 +0000245 char c;
aliguori731b0362009-03-05 23:01:42 +0000246
bellard7e2515e2004-08-01 21:52:19 +0000247 for(;;) {
248 c = *str++;
249 if (c == '\0')
250 break;
bellard7ba12602006-07-14 20:26:42 +0000251 if (c == '\n')
aliguori731b0362009-03-05 23:01:42 +0000252 mon->outbuf[mon->outbuf_index++] = '\r';
253 mon->outbuf[mon->outbuf_index++] = c;
254 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
255 || c == '\n')
aliguori376253e2009-03-05 23:01:23 +0000256 monitor_flush(mon);
bellard7e2515e2004-08-01 21:52:19 +0000257 }
258}
259
aliguori376253e2009-03-05 23:01:23 +0000260void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000261{
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200262 char buf[4096];
263
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200264 if (!mon)
265 return;
266
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200267 mon_print_count_inc(mon);
268
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200269 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200270 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200271 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200272
273 vsnprintf(buf, sizeof(buf), fmt, ap);
274 monitor_puts(mon, buf);
bellard7e2515e2004-08-01 21:52:19 +0000275}
276
aliguori376253e2009-03-05 23:01:23 +0000277void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000278{
279 va_list ap;
280 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000281 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000282 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000283}
284
aliguori376253e2009-03-05 23:01:23 +0000285void monitor_print_filename(Monitor *mon, const char *filename)
thsfef30742006-12-22 14:11:32 +0000286{
287 int i;
288
289 for (i = 0; filename[i]; i++) {
aliguori28a76be2009-03-06 20:27:40 +0000290 switch (filename[i]) {
291 case ' ':
292 case '"':
293 case '\\':
294 monitor_printf(mon, "\\%c", filename[i]);
295 break;
296 case '\t':
297 monitor_printf(mon, "\\t");
298 break;
299 case '\r':
300 monitor_printf(mon, "\\r");
301 break;
302 case '\n':
303 monitor_printf(mon, "\\n");
304 break;
305 default:
306 monitor_printf(mon, "%c", filename[i]);
307 break;
308 }
thsfef30742006-12-22 14:11:32 +0000309 }
310}
311
bellard7fe48482004-10-09 18:08:01 +0000312static int monitor_fprintf(FILE *stream, const char *fmt, ...)
313{
314 va_list ap;
315 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000316 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000317 va_end(ap);
318 return 0;
319}
320
Luiz Capitulino13c74252009-10-07 13:41:55 -0300321static void monitor_user_noop(Monitor *mon, const QObject *data) { }
322
Luiz Capitulino13917be2009-10-07 13:41:54 -0300323static inline int monitor_handler_ported(const mon_cmd_t *cmd)
324{
325 return cmd->user_print != NULL;
326}
327
Adam Litke940cc302010-01-25 12:18:44 -0600328static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)
329{
330 return cmd->async != 0;
331}
332
Luiz Capitulino8204a912009-11-18 23:05:31 -0200333static inline int monitor_has_error(const Monitor *mon)
334{
335 return mon->error != NULL;
336}
337
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200338static void monitor_json_emitter(Monitor *mon, const QObject *data)
339{
340 QString *json;
341
342 json = qobject_to_json(data);
343 assert(json != NULL);
344
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200345 qstring_append_chr(json, '\n');
346 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200347
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200348 QDECREF(json);
349}
350
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200351static void monitor_protocol_emitter(Monitor *mon, QObject *data)
352{
353 QDict *qmp;
354
355 qmp = qdict_new();
356
357 if (!monitor_has_error(mon)) {
358 /* success response */
359 if (data) {
360 qobject_incref(data);
361 qdict_put_obj(qmp, "return", data);
362 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200363 /* return an empty QDict by default */
364 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200365 }
366 } else {
367 /* error response */
Markus Armbruster77e595e2009-12-07 21:37:16 +0100368 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200369 qdict_put(qmp, "error", mon->error->error);
370 QINCREF(mon->error->error);
371 QDECREF(mon->error);
372 mon->error = NULL;
373 }
374
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200375 if (mon->mc->id) {
376 qdict_put_obj(qmp, "id", mon->mc->id);
377 mon->mc->id = NULL;
378 }
379
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200380 monitor_json_emitter(mon, QOBJECT(qmp));
381 QDECREF(qmp);
382}
383
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200384static void timestamp_put(QDict *qdict)
385{
386 int err;
387 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000388 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200389
Blue Swirld08d6f02009-12-04 18:06:39 +0000390 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200391 if (err < 0)
392 return;
393
394 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
395 "'microseconds': %" PRId64 " }",
396 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200397 qdict_put_obj(qdict, "timestamp", obj);
398}
399
400/**
401 * monitor_protocol_event(): Generate a Monitor event
402 *
403 * Event-specific data can be emitted through the (optional) 'data' parameter.
404 */
405void monitor_protocol_event(MonitorEvent event, QObject *data)
406{
407 QDict *qmp;
408 const char *event_name;
Adam Litkef039a562010-01-15 08:34:02 -0600409 Monitor *mon;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200410
Blue Swirl242cd002009-12-04 18:05:45 +0000411 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200412
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200413 switch (event) {
Blue Swirl242cd002009-12-04 18:05:45 +0000414 case QEVENT_SHUTDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200415 event_name = "SHUTDOWN";
416 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000417 case QEVENT_RESET:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200418 event_name = "RESET";
419 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000420 case QEVENT_POWERDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200421 event_name = "POWERDOWN";
422 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000423 case QEVENT_STOP:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200424 event_name = "STOP";
425 break;
Luiz Capitulino6ed2c482010-04-27 20:35:59 -0300426 case QEVENT_RESUME:
427 event_name = "RESUME";
428 break;
Luiz Capitulino586153d2010-01-14 14:50:57 -0200429 case QEVENT_VNC_CONNECTED:
430 event_name = "VNC_CONNECTED";
431 break;
Luiz Capitulino0d2ed462010-01-14 14:50:59 -0200432 case QEVENT_VNC_INITIALIZED:
433 event_name = "VNC_INITIALIZED";
434 break;
Luiz Capitulino0d72f3d2010-01-14 14:50:58 -0200435 case QEVENT_VNC_DISCONNECTED:
436 event_name = "VNC_DISCONNECTED";
437 break;
Luiz Capitulinoaa1db6e2010-02-03 12:41:00 -0200438 case QEVENT_BLOCK_IO_ERROR:
439 event_name = "BLOCK_IO_ERROR";
440 break;
Luiz Capitulino80cd3472010-02-25 12:11:44 -0300441 case QEVENT_RTC_CHANGE:
442 event_name = "RTC_CHANGE";
443 break;
Luiz Capitulino9eedeb32010-02-25 12:13:04 -0300444 case QEVENT_WATCHDOG:
445 event_name = "WATCHDOG";
446 break;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200447 default:
448 abort();
449 break;
450 }
451
452 qmp = qdict_new();
453 timestamp_put(qmp);
454 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200455 if (data) {
456 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200457 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200458 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200459
Adam Litkef039a562010-01-15 08:34:02 -0600460 QLIST_FOREACH(mon, &mon_list, entry) {
Luiz Capitulino09069b12010-02-04 18:10:06 -0200461 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
Luiz Capitulino23fabed2010-01-20 10:37:59 -0200462 monitor_json_emitter(mon, QOBJECT(qmp));
463 }
Adam Litkef039a562010-01-15 08:34:02 -0600464 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200465 QDECREF(qmp);
466}
467
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200468static int do_qmp_capabilities(Monitor *mon, const QDict *params,
469 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200470{
471 /* Will setup QMP capabilities in the future */
472 if (monitor_ctrl_mode(mon)) {
473 mon->mc->command_mode = 1;
474 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200475
476 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200477}
478
bellard9dc39cb2004-03-14 21:38:27 +0000479static int compare_cmd(const char *name, const char *list)
480{
481 const char *p, *pstart;
482 int len;
483 len = strlen(name);
484 p = list;
485 for(;;) {
486 pstart = p;
487 p = strchr(p, '|');
488 if (!p)
489 p = pstart + strlen(pstart);
490 if ((p - pstart) == len && !memcmp(pstart, name, len))
491 return 1;
492 if (*p == '\0')
493 break;
494 p++;
495 }
496 return 0;
497}
498
Anthony Liguoric227f092009-10-01 16:12:16 -0500499static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
aliguori376253e2009-03-05 23:01:23 +0000500 const char *prefix, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000501{
Anthony Liguoric227f092009-10-01 16:12:16 -0500502 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000503
504 for(cmd = cmds; cmd->name != NULL; cmd++) {
505 if (!name || !strcmp(name, cmd->name))
aliguori376253e2009-03-05 23:01:23 +0000506 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
507 cmd->params, cmd->help);
bellard9dc39cb2004-03-14 21:38:27 +0000508 }
509}
510
aliguori376253e2009-03-05 23:01:23 +0000511static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000512{
513 if (name && !strcmp(name, "info")) {
aliguori376253e2009-03-05 23:01:23 +0000514 help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard9dc39cb2004-03-14 21:38:27 +0000515 } else {
aliguori376253e2009-03-05 23:01:23 +0000516 help_cmd_dump(mon, mon_cmds, "", name);
bellardf193c792004-03-21 17:06:25 +0000517 if (name && !strcmp(name, "log")) {
blueswir18662d652008-10-02 18:32:44 +0000518 const CPULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000519 monitor_printf(mon, "Log items (comma separated):\n");
520 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
bellardf193c792004-03-21 17:06:25 +0000521 for(item = cpu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000522 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000523 }
524 }
bellard9dc39cb2004-03-14 21:38:27 +0000525 }
526}
527
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300528static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300529{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300530 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300531}
532
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300533static void do_commit(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000534{
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200535 int all_devices;
536 DriveInfo *dinfo;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300537 const char *device = qdict_get_str(qdict, "device");
balrog2dc7b602007-05-24 18:53:22 +0000538
bellard7954c732006-08-01 15:52:40 +0000539 all_devices = !strcmp(device, "all");
Blue Swirl72cf2d42009-09-12 07:36:22 +0000540 QTAILQ_FOREACH(dinfo, &drives, next) {
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200541 if (!all_devices)
Luiz Capitulino73006d22009-07-31 15:15:41 -0300542 if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
Gerd Hoffmann751c6a12009-07-22 16:42:57 +0200543 continue;
544 bdrv_commit(dinfo->bdrv);
bellard9dc39cb2004-03-14 21:38:27 +0000545 }
546}
547
Adam Litke940cc302010-01-25 12:18:44 -0600548static void user_monitor_complete(void *opaque, QObject *ret_data)
549{
550 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
551
552 if (ret_data) {
553 data->user_print(data->mon, ret_data);
554 }
555 monitor_resume(data->mon);
556 qemu_free(data);
557}
558
559static void qmp_monitor_complete(void *opaque, QObject *ret_data)
560{
561 monitor_protocol_emitter(opaque, ret_data);
562}
563
564static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
565 const QDict *params)
566{
567 cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
568}
569
570static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
571{
572 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
573}
574
575static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
576 const QDict *params)
577{
578 int ret;
579
580 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
581 cb_data->mon = mon;
582 cb_data->user_print = cmd->user_print;
583 monitor_suspend(mon);
584 ret = cmd->mhandler.cmd_async(mon, params,
585 user_monitor_complete, cb_data);
586 if (ret < 0) {
587 monitor_resume(mon);
588 qemu_free(cb_data);
589 }
590}
591
592static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
593{
594 int ret;
595
596 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
597 cb_data->mon = mon;
598 cb_data->user_print = cmd->user_print;
599 monitor_suspend(mon);
600 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
601 if (ret < 0) {
602 monitor_resume(mon);
603 qemu_free(cb_data);
604 }
605}
606
Luiz Capitulino4fdc94b2010-02-10 23:50:00 -0200607static int do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard9dc39cb2004-03-14 21:38:27 +0000608{
Anthony Liguoric227f092009-10-01 16:12:16 -0500609 const mon_cmd_t *cmd;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300610 const char *item = qdict_get_try_str(qdict, "item");
bellard9dc39cb2004-03-14 21:38:27 +0000611
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200612 if (!item) {
613 assert(monitor_ctrl_mode(mon) == 0);
bellard9dc39cb2004-03-14 21:38:27 +0000614 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200615 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300616
617 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
ths5fafdf22007-09-16 21:08:06 +0000618 if (compare_cmd(item, cmd->name))
Luiz Capitulino13c74252009-10-07 13:41:55 -0300619 break;
bellard9dc39cb2004-03-14 21:38:27 +0000620 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300621
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200622 if (cmd->name == NULL) {
623 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100624 qerror_report(QERR_COMMAND_NOT_FOUND, item);
Luiz Capitulino4fdc94b2010-02-10 23:50:00 -0200625 return -1;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200626 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300627 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200628 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300629
Adam Litke940cc302010-01-25 12:18:44 -0600630 if (monitor_handler_is_async(cmd)) {
631 if (monitor_ctrl_mode(mon)) {
632 qmp_async_info_handler(mon, cmd);
633 } else {
634 user_async_info_handler(mon, cmd);
635 }
636 /*
637 * Indicate that this command is asynchronous and will not return any
638 * data (not even empty). Instead, the data will be returned via a
639 * completion callback.
640 */
641 *ret_data = qobject_from_jsonf("{ '__mon_async': 'return' }");
642 } else if (monitor_handler_ported(cmd)) {
Luiz Capitulino13c74252009-10-07 13:41:55 -0300643 cmd->mhandler.info_new(mon, ret_data);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200644
645 if (!monitor_ctrl_mode(mon)) {
646 /*
647 * User Protocol function is called here, Monitor Protocol is
648 * handled by monitor_call_handler()
649 */
650 if (*ret_data)
651 cmd->user_print(mon, *ret_data);
652 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300653 } else {
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200654 if (monitor_ctrl_mode(mon)) {
655 /* handler not converted yet */
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100656 qerror_report(QERR_COMMAND_NOT_FOUND, item);
Luiz Capitulino4fdc94b2010-02-10 23:50:00 -0200657 return -1;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200658 } else {
659 cmd->mhandler.info(mon);
660 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300661 }
662
Luiz Capitulino4fdc94b2010-02-10 23:50:00 -0200663 return 0;
Luiz Capitulino13c74252009-10-07 13:41:55 -0300664
665help:
666 help_cmd(mon, "info");
Luiz Capitulino4fdc94b2010-02-10 23:50:00 -0200667 return 0;
bellard9dc39cb2004-03-14 21:38:27 +0000668}
669
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200670static void do_info_version_print(Monitor *mon, const QObject *data)
671{
672 QDict *qdict;
673
674 qdict = qobject_to_qdict(data);
675
676 monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),
677 qdict_get_str(qdict, "package"));
678}
679
Luiz Capitulinoab2d3182009-10-07 13:42:02 -0300680/**
681 * do_info_version(): Show QEMU version
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200682 *
683 * Return a QDict with the following information:
684 *
685 * - "qemu": QEMU's version
686 * - "package": package's version
687 *
688 * Example:
689 *
690 * { "qemu": "0.11.50", "package": "" }
Luiz Capitulinoab2d3182009-10-07 13:42:02 -0300691 */
692static void do_info_version(Monitor *mon, QObject **ret_data)
bellard9bc9d1c2004-10-10 15:15:51 +0000693{
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200694 *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
695 QEMU_VERSION, QEMU_PKGVERSION);
bellard9bc9d1c2004-10-10 15:15:51 +0000696}
697
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200698static void do_info_name_print(Monitor *mon, const QObject *data)
thsc35734b2007-03-19 15:17:08 +0000699{
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200700 QDict *qdict;
701
702 qdict = qobject_to_qdict(data);
703 if (qdict_size(qdict) == 0) {
704 return;
705 }
706
707 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
708}
709
710/**
711 * do_info_name(): Show VM name
712 *
713 * Return a QDict with the following information:
714 *
715 * - "name": VM's name (optional)
716 *
717 * Example:
718 *
719 * { "name": "qemu-name" }
720 */
721static void do_info_name(Monitor *mon, QObject **ret_data)
722{
723 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
724 qobject_from_jsonf("{}");
thsc35734b2007-03-19 15:17:08 +0000725}
726
Luiz Capitulino1a728672009-12-10 17:15:56 -0200727static QObject *get_cmd_dict(const char *name)
728{
729 const char *p;
730
731 /* Remove '|' from some commands */
732 p = strchr(name, '|');
733 if (p) {
734 p++;
735 } else {
736 p = name;
737 }
738
739 return qobject_from_jsonf("{ 'name': %s }", p);
740}
741
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200742/**
743 * do_info_commands(): List QMP available commands
744 *
Luiz Capitulino1a728672009-12-10 17:15:56 -0200745 * Each command is represented by a QDict, the returned QObject is a QList
746 * of all commands.
747 *
748 * The QDict contains:
749 *
750 * - "name": command's name
751 *
752 * Example:
753 *
754 * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200755 */
756static void do_info_commands(Monitor *mon, QObject **ret_data)
757{
758 QList *cmd_list;
759 const mon_cmd_t *cmd;
760
761 cmd_list = qlist_new();
762
763 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
764 if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
Luiz Capitulino1a728672009-12-10 17:15:56 -0200765 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200766 }
767 }
768
769 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
770 if (monitor_handler_ported(cmd)) {
771 char buf[128];
772 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
Luiz Capitulino1a728672009-12-10 17:15:56 -0200773 qlist_append_obj(cmd_list, get_cmd_dict(buf));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200774 }
775 }
776
777 *ret_data = QOBJECT(cmd_list);
778}
779
aurel32bf4f74c2008-12-18 22:42:34 +0000780#if defined(TARGET_I386)
Luiz Capitulino14f07202009-12-10 17:16:02 -0200781static void do_info_hpet_print(Monitor *mon, const QObject *data)
aliguori16b29ae2008-12-17 23:28:44 +0000782{
aliguori376253e2009-03-05 23:01:23 +0000783 monitor_printf(mon, "HPET is %s by QEMU\n",
Luiz Capitulino14f07202009-12-10 17:16:02 -0200784 qdict_get_bool(qobject_to_qdict(data), "enabled") ?
785 "enabled" : "disabled");
786}
787
788/**
789 * do_info_hpet(): Show HPET state
790 *
791 * Return a QDict with the following information:
792 *
793 * - "enabled": true if hpet if enabled, false otherwise
794 *
795 * Example:
796 *
797 * { "enabled": true }
798 */
799static void do_info_hpet(Monitor *mon, QObject **ret_data)
800{
801 *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
aliguori16b29ae2008-12-17 23:28:44 +0000802}
aurel32bf4f74c2008-12-18 22:42:34 +0000803#endif
aliguori16b29ae2008-12-17 23:28:44 +0000804
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200805static void do_info_uuid_print(Monitor *mon, const QObject *data)
blueswir1f1f23ad2008-09-18 18:30:20 +0000806{
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200807 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
808}
809
810/**
811 * do_info_uuid(): Show VM UUID
812 *
813 * Return a QDict with the following information:
814 *
815 * - "UUID": Universally Unique Identifier
816 *
817 * Example:
818 *
819 * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
820 */
821static void do_info_uuid(Monitor *mon, QObject **ret_data)
822{
823 char uuid[64];
824
825 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
aliguori376253e2009-03-05 23:01:23 +0000826 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
827 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
828 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
829 qemu_uuid[14], qemu_uuid[15]);
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200830 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
thsa36e69d2007-12-02 05:18:19 +0000831}
832
bellard6a00d602005-11-21 23:25:50 +0000833/* get the current CPU defined by the user */
pbrook9596ebb2007-11-18 01:44:38 +0000834static int mon_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000835{
836 CPUState *env;
837
838 for(env = first_cpu; env != NULL; env = env->next_cpu) {
839 if (env->cpu_index == cpu_index) {
aliguori731b0362009-03-05 23:01:42 +0000840 cur_mon->mon_cpu = env;
bellard6a00d602005-11-21 23:25:50 +0000841 return 0;
842 }
843 }
844 return -1;
845}
846
pbrook9596ebb2007-11-18 01:44:38 +0000847static CPUState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +0000848{
aliguori731b0362009-03-05 23:01:42 +0000849 if (!cur_mon->mon_cpu) {
bellard6a00d602005-11-21 23:25:50 +0000850 mon_set_cpu(0);
851 }
Avi Kivity4c0960c2009-08-17 23:19:53 +0300852 cpu_synchronize_state(cur_mon->mon_cpu);
aliguori731b0362009-03-05 23:01:42 +0000853 return cur_mon->mon_cpu;
bellard6a00d602005-11-21 23:25:50 +0000854}
855
aliguori376253e2009-03-05 23:01:23 +0000856static void do_info_registers(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +0000857{
bellard6a00d602005-11-21 23:25:50 +0000858 CPUState *env;
859 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +0000860#ifdef TARGET_I386
aliguori376253e2009-03-05 23:01:23 +0000861 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellardd24b15a2005-07-03 21:28:00 +0000862 X86_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +0000863#else
aliguori376253e2009-03-05 23:01:23 +0000864 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard7fe48482004-10-09 18:08:01 +0000865 0);
bellard9307c4c2004-04-04 12:57:25 +0000866#endif
867}
868
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300869static void print_cpu_iter(QObject *obj, void *opaque)
870{
871 QDict *cpu;
872 int active = ' ';
873 Monitor *mon = opaque;
874
875 assert(qobject_type(obj) == QTYPE_QDICT);
876 cpu = qobject_to_qdict(obj);
877
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200878 if (qdict_get_bool(cpu, "current")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300879 active = '*';
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200880 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300881
882 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
883
884#if defined(TARGET_I386)
885 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
886 (target_ulong) qdict_get_int(cpu, "pc"));
887#elif defined(TARGET_PPC)
888 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
889 (target_long) qdict_get_int(cpu, "nip"));
890#elif defined(TARGET_SPARC)
891 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
892 (target_long) qdict_get_int(cpu, "pc"));
893 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
894 (target_long) qdict_get_int(cpu, "npc"));
895#elif defined(TARGET_MIPS)
896 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
897 (target_long) qdict_get_int(cpu, "PC"));
898#endif
899
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200900 if (qdict_get_bool(cpu, "halted")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300901 monitor_printf(mon, " (halted)");
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200902 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300903
904 monitor_printf(mon, "\n");
905}
906
907static void monitor_print_cpus(Monitor *mon, const QObject *data)
908{
909 QList *cpu_list;
910
911 assert(qobject_type(data) == QTYPE_QLIST);
912 cpu_list = qobject_to_qlist(data);
913 qlist_iter(cpu_list, print_cpu_iter, mon);
914}
915
916/**
917 * do_info_cpus(): Show CPU information
918 *
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200919 * Return a QList. Each CPU is represented by a QDict, which contains:
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300920 *
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200921 * - "cpu": CPU index
922 * - "current": true if this is the current CPU, false otherwise
923 * - "halted": true if the cpu is halted, false otherwise
924 * - Current program counter. The key's name depends on the architecture:
925 * "pc": i386/x86)64
926 * "nip": PPC
927 * "pc" and "npc": sparc
928 * "PC": mips
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300929 *
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200930 * Example:
931 *
932 * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
933 * { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300934 */
935static void do_info_cpus(Monitor *mon, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000936{
937 CPUState *env;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300938 QList *cpu_list;
939
940 cpu_list = qlist_new();
bellard6a00d602005-11-21 23:25:50 +0000941
942 /* just to set the default cpu if not already done */
943 mon_get_cpu();
944
945 for(env = first_cpu; env != NULL; env = env->next_cpu) {
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200946 QDict *cpu;
947 QObject *obj;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300948
Avi Kivity4c0960c2009-08-17 23:19:53 +0300949 cpu_synchronize_state(env);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300950
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200951 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
952 env->cpu_index, env == mon->mon_cpu,
953 env->halted);
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200954
955 cpu = qobject_to_qdict(obj);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300956
bellard6a00d602005-11-21 23:25:50 +0000957#if defined(TARGET_I386)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300958 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
bellarde80e1cc2005-11-23 22:05:28 +0000959#elif defined(TARGET_PPC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300960 qdict_put(cpu, "nip", qint_from_int(env->nip));
bellardba3c64f2005-12-05 20:31:52 +0000961#elif defined(TARGET_SPARC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300962 qdict_put(cpu, "pc", qint_from_int(env->pc));
963 qdict_put(cpu, "npc", qint_from_int(env->npc));
thsead93602007-09-06 00:18:15 +0000964#elif defined(TARGET_MIPS)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300965 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
bellardce5232c2008-05-28 17:14:10 +0000966#endif
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300967
968 qlist_append(cpu_list, cpu);
bellard6a00d602005-11-21 23:25:50 +0000969 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300970
971 *ret_data = QOBJECT(cpu_list);
bellard6a00d602005-11-21 23:25:50 +0000972}
973
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200974static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000975{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300976 int index = qdict_get_int(qdict, "index");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200977 if (mon_set_cpu(index) < 0) {
Markus Armbrustere17ba872010-03-25 17:22:36 +0100978 qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",
979 "a CPU number");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200980 return -1;
981 }
982 return 0;
bellard6a00d602005-11-21 23:25:50 +0000983}
984
aliguori376253e2009-03-05 23:01:23 +0000985static void do_info_jit(Monitor *mon)
bellarde3db7222005-01-26 22:00:47 +0000986{
aliguori376253e2009-03-05 23:01:23 +0000987 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +0000988}
989
aliguori376253e2009-03-05 23:01:23 +0000990static void do_info_history(Monitor *mon)
bellardaa455482004-04-04 13:07:25 +0000991{
992 int i;
bellard7e2515e2004-08-01 21:52:19 +0000993 const char *str;
ths3b46e622007-09-17 08:09:54 +0000994
aliguoricde76ee2009-03-05 23:01:51 +0000995 if (!mon->rs)
996 return;
bellard7e2515e2004-08-01 21:52:19 +0000997 i = 0;
998 for(;;) {
aliguori731b0362009-03-05 23:01:42 +0000999 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +00001000 if (!str)
1001 break;
aliguori376253e2009-03-05 23:01:23 +00001002 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +00001003 i++;
bellardaa455482004-04-04 13:07:25 +00001004 }
1005}
1006
j_mayer76a66252007-03-07 08:32:30 +00001007#if defined(TARGET_PPC)
1008/* XXX: not implemented in other targets */
aliguori376253e2009-03-05 23:01:23 +00001009static void do_info_cpu_stats(Monitor *mon)
j_mayer76a66252007-03-07 08:32:30 +00001010{
1011 CPUState *env;
1012
1013 env = mon_get_cpu();
aliguori376253e2009-03-05 23:01:23 +00001014 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +00001015}
1016#endif
1017
Luiz Capitulinob223f352009-10-07 13:41:56 -03001018/**
1019 * do_quit(): Quit QEMU execution
1020 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001021static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard9dc39cb2004-03-14 21:38:27 +00001022{
Luiz Capitulino39b59d22010-05-11 18:08:20 -03001023 monitor_suspend(mon);
1024 no_shutdown = 0;
1025 qemu_system_shutdown_request();
1026
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001027 return 0;
bellard9dc39cb2004-03-14 21:38:27 +00001028}
1029
aliguori376253e2009-03-05 23:01:23 +00001030static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
bellard9dc39cb2004-03-14 21:38:27 +00001031{
1032 if (bdrv_is_inserted(bs)) {
1033 if (!force) {
1034 if (!bdrv_is_removable(bs)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001035 qerror_report(QERR_DEVICE_NOT_REMOVABLE,
Markus Armbruster2c2a6bb2009-12-07 21:37:05 +01001036 bdrv_get_device_name(bs));
bellard9dc39cb2004-03-14 21:38:27 +00001037 return -1;
1038 }
1039 if (bdrv_is_locked(bs)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001040 qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
bellard9dc39cb2004-03-14 21:38:27 +00001041 return -1;
1042 }
1043 }
1044 bdrv_close(bs);
1045 }
1046 return 0;
1047}
1048
Luiz Capitulino9b9d4d92010-02-10 23:49:50 -02001049static int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard9dc39cb2004-03-14 21:38:27 +00001050{
1051 BlockDriverState *bs;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001052 int force = qdict_get_int(qdict, "force");
Luiz Capitulino78d714e2009-12-14 18:53:21 -02001053 const char *filename = qdict_get_str(qdict, "device");
bellard9dc39cb2004-03-14 21:38:27 +00001054
bellard9307c4c2004-04-04 12:57:25 +00001055 bs = bdrv_find(filename);
bellard9dc39cb2004-03-14 21:38:27 +00001056 if (!bs) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001057 qerror_report(QERR_DEVICE_NOT_FOUND, filename);
Luiz Capitulino9b9d4d92010-02-10 23:49:50 -02001058 return -1;
bellard9dc39cb2004-03-14 21:38:27 +00001059 }
Luiz Capitulino9b9d4d92010-02-10 23:49:50 -02001060 return eject_device(mon, bs, force);
bellard9dc39cb2004-03-14 21:38:27 +00001061}
1062
Luiz Capitulinoba85d352010-02-10 23:49:52 -02001063static int do_block_set_passwd(Monitor *mon, const QDict *qdict,
Luiz Capitulinoa3a55a22009-12-04 15:24:09 -02001064 QObject **ret_data)
1065{
1066 BlockDriverState *bs;
Shahar Havivifd04a2a2010-03-06 00:26:13 +02001067 int err;
Luiz Capitulinoa3a55a22009-12-04 15:24:09 -02001068
1069 bs = bdrv_find(qdict_get_str(qdict, "device"));
1070 if (!bs) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001071 qerror_report(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
Luiz Capitulinoba85d352010-02-10 23:49:52 -02001072 return -1;
Luiz Capitulinoa3a55a22009-12-04 15:24:09 -02001073 }
1074
Shahar Havivifd04a2a2010-03-06 00:26:13 +02001075 err = bdrv_set_key(bs, qdict_get_str(qdict, "password"));
1076 if (err == -EINVAL) {
1077 qerror_report(QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
1078 return -1;
1079 } else if (err < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001080 qerror_report(QERR_INVALID_PASSWORD);
Luiz Capitulinoba85d352010-02-10 23:49:52 -02001081 return -1;
Luiz Capitulinoa3a55a22009-12-04 15:24:09 -02001082 }
Luiz Capitulinoba85d352010-02-10 23:49:52 -02001083
1084 return 0;
Luiz Capitulinoa3a55a22009-12-04 15:24:09 -02001085}
1086
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001087static int do_change_block(Monitor *mon, const char *device,
1088 const char *filename, const char *fmt)
bellard9dc39cb2004-03-14 21:38:27 +00001089{
1090 BlockDriverState *bs;
aurel322ecea9b2008-06-18 22:10:01 +00001091 BlockDriver *drv = NULL;
Naphtali Spreicb4e5f82010-04-25 19:30:37 +03001092 int bdrv_flags;
bellard9dc39cb2004-03-14 21:38:27 +00001093
bellard9307c4c2004-04-04 12:57:25 +00001094 bs = bdrv_find(device);
bellard9dc39cb2004-03-14 21:38:27 +00001095 if (!bs) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001096 qerror_report(QERR_DEVICE_NOT_FOUND, device);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001097 return -1;
bellard9dc39cb2004-03-14 21:38:27 +00001098 }
aurel322ecea9b2008-06-18 22:10:01 +00001099 if (fmt) {
Markus Armbrustereb852012009-10-27 18:41:44 +01001100 drv = bdrv_find_whitelisted_format(fmt);
aurel322ecea9b2008-06-18 22:10:01 +00001101 if (!drv) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001102 qerror_report(QERR_INVALID_BLOCK_FORMAT, fmt);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001103 return -1;
aurel322ecea9b2008-06-18 22:10:01 +00001104 }
1105 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001106 if (eject_device(mon, bs, 0) < 0) {
1107 return -1;
1108 }
Naphtali Spreicb4e5f82010-04-25 19:30:37 +03001109 bdrv_flags = bdrv_get_type_hint(bs) == BDRV_TYPE_CDROM ? 0 : BDRV_O_RDWR;
1110 if (bdrv_open(bs, filename, bdrv_flags, drv) < 0) {
Ryan Harper07a5d952010-03-25 09:32:58 -05001111 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001112 return -1;
1113 }
1114 return monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001115}
1116
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001117static int change_vnc_password(const char *password)
aliguoribb5fc202009-03-05 23:01:15 +00001118{
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001119 if (vnc_display_password(NULL, password) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001120 qerror_report(QERR_SET_PASSWD_FAILED);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001121 return -1;
1122 }
aliguoribb5fc202009-03-05 23:01:15 +00001123
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001124 return 0;
Markus Armbruster2895e072009-12-07 21:37:01 +01001125}
1126
1127static void change_vnc_password_cb(Monitor *mon, const char *password,
1128 void *opaque)
1129{
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001130 change_vnc_password(password);
aliguori731b0362009-03-05 23:01:42 +00001131 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00001132}
1133
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001134static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
thse25a5822007-08-25 01:36:20 +00001135{
ths70848512007-08-25 01:37:05 +00001136 if (strcmp(target, "passwd") == 0 ||
aliguori28a76be2009-03-06 20:27:40 +00001137 strcmp(target, "password") == 0) {
1138 if (arg) {
aliguoribb5fc202009-03-05 23:01:15 +00001139 char password[9];
aliguori28a76be2009-03-06 20:27:40 +00001140 strncpy(password, arg, sizeof(password));
1141 password[sizeof(password) - 1] = '\0';
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001142 return change_vnc_password(password);
aliguoribb5fc202009-03-05 23:01:15 +00001143 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001144 return monitor_read_password(mon, change_vnc_password_cb, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001145 }
ths70848512007-08-25 01:37:05 +00001146 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001147 if (vnc_display_open(NULL, target) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001148 qerror_report(QERR_VNC_SERVER_FAILED, target);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001149 return -1;
1150 }
ths70848512007-08-25 01:37:05 +00001151 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001152
1153 return 0;
thse25a5822007-08-25 01:36:20 +00001154}
1155
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001156/**
1157 * do_change(): Change a removable medium, or VNC configuration
1158 */
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001159static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
thse25a5822007-08-25 01:36:20 +00001160{
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001161 const char *device = qdict_get_str(qdict, "device");
1162 const char *target = qdict_get_str(qdict, "target");
1163 const char *arg = qdict_get_try_str(qdict, "arg");
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001164 int ret;
1165
thse25a5822007-08-25 01:36:20 +00001166 if (strcmp(device, "vnc") == 0) {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001167 ret = do_change_vnc(mon, target, arg);
thse25a5822007-08-25 01:36:20 +00001168 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001169 ret = do_change_block(mon, device, target, arg);
thse25a5822007-08-25 01:36:20 +00001170 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001171
1172 return ret;
thse25a5822007-08-25 01:36:20 +00001173}
1174
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001175static int do_screen_dump(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard59a983b2004-03-17 23:17:16 +00001176{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001177 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001178 return 0;
bellard59a983b2004-03-17 23:17:16 +00001179}
1180
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001181static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001182{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001183 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001184}
1185
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001186static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001187{
1188 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001189 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001190
bellard9307c4c2004-04-04 12:57:25 +00001191 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001192 mask = 0;
1193 } else {
bellard9307c4c2004-04-04 12:57:25 +00001194 mask = cpu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001195 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001196 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001197 return;
1198 }
1199 }
1200 cpu_set_log(mask);
1201}
1202
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001203static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001204{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001205 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001206 if (!option || !strcmp(option, "on")) {
1207 singlestep = 1;
1208 } else if (!strcmp(option, "off")) {
1209 singlestep = 0;
1210 } else {
1211 monitor_printf(mon, "unexpected option %s\n", option);
1212 }
1213}
1214
Luiz Capitulinoe0c97bd2009-10-07 13:41:57 -03001215/**
1216 * do_stop(): Stop VM execution
1217 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001218static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard8a7ddc32004-03-31 19:00:16 +00001219{
1220 vm_stop(EXCP_INTERRUPT);
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001221 return 0;
bellard8a7ddc32004-03-31 19:00:16 +00001222}
1223
aliguoribb5fc202009-03-05 23:01:15 +00001224static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
aliguoric0f4ce72009-03-05 23:01:01 +00001225
aliguori376253e2009-03-05 23:01:23 +00001226struct bdrv_iterate_context {
1227 Monitor *mon;
1228 int err;
1229};
aliguoric0f4ce72009-03-05 23:01:01 +00001230
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001231/**
1232 * do_cont(): Resume emulation.
1233 */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001234static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori376253e2009-03-05 23:01:23 +00001235{
1236 struct bdrv_iterate_context context = { mon, 0 };
1237
1238 bdrv_iterate(encrypted_bdrv_it, &context);
aliguoric0f4ce72009-03-05 23:01:01 +00001239 /* only resume the vm if all keys are set and valid */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001240 if (!context.err) {
aliguoric0f4ce72009-03-05 23:01:01 +00001241 vm_start();
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001242 return 0;
1243 } else {
1244 return -1;
1245 }
bellard8a7ddc32004-03-31 19:00:16 +00001246}
1247
aliguoribb5fc202009-03-05 23:01:15 +00001248static void bdrv_key_cb(void *opaque, int err)
1249{
aliguori376253e2009-03-05 23:01:23 +00001250 Monitor *mon = opaque;
1251
aliguoribb5fc202009-03-05 23:01:15 +00001252 /* another key was set successfully, retry to continue */
1253 if (!err)
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001254 do_cont(mon, NULL, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001255}
1256
1257static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1258{
aliguori376253e2009-03-05 23:01:23 +00001259 struct bdrv_iterate_context *context = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00001260
aliguori376253e2009-03-05 23:01:23 +00001261 if (!context->err && bdrv_key_required(bs)) {
1262 context->err = -EBUSY;
1263 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1264 context->mon);
aliguoribb5fc202009-03-05 23:01:15 +00001265 }
1266}
1267
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001268static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001269{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001270 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001271 if (!device)
1272 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1273 if (gdbserver_start(device) < 0) {
1274 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1275 device);
1276 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001277 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001278 } else {
aliguori59030a82009-04-05 18:43:41 +00001279 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1280 device);
bellard8a7ddc32004-03-31 19:00:16 +00001281 }
1282}
1283
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001284static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001285{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001286 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001287 if (select_watchdog_action(action) == -1) {
1288 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1289 }
1290}
1291
aliguori376253e2009-03-05 23:01:23 +00001292static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001293{
aliguori376253e2009-03-05 23:01:23 +00001294 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001295 switch(c) {
1296 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001297 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001298 break;
1299 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001300 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001301 break;
1302 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001303 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001304 break;
1305 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001306 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001307 break;
1308 default:
1309 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001310 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001311 } else {
aliguori376253e2009-03-05 23:01:23 +00001312 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001313 }
1314 break;
1315 }
aliguori376253e2009-03-05 23:01:23 +00001316 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001317}
1318
aliguori376253e2009-03-05 23:01:23 +00001319static void memory_dump(Monitor *mon, int count, int format, int wsize,
Anthony Liguoric227f092009-10-01 16:12:16 -05001320 target_phys_addr_t addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001321{
bellard6a00d602005-11-21 23:25:50 +00001322 CPUState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001323 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001324 uint8_t buf[16];
1325 uint64_t v;
1326
1327 if (format == 'i') {
1328 int flags;
1329 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001330 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001331#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001332 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001333 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001334 } else if (wsize == 4) {
1335 flags = 0;
1336 } else {
bellard6a15fd12006-04-12 21:07:07 +00001337 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001338 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001339 if (env) {
1340#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001341 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001342 (env->segs[R_CS].flags & DESC_L_MASK))
1343 flags = 2;
1344 else
1345#endif
1346 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1347 flags = 1;
1348 }
bellard4c27ba22004-04-25 18:05:08 +00001349 }
1350#endif
aliguori376253e2009-03-05 23:01:23 +00001351 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001352 return;
1353 }
1354
1355 len = wsize * count;
1356 if (wsize == 1)
1357 line_size = 8;
1358 else
1359 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001360 max_digits = 0;
1361
1362 switch(format) {
1363 case 'o':
1364 max_digits = (wsize * 8 + 2) / 3;
1365 break;
1366 default:
1367 case 'x':
1368 max_digits = (wsize * 8) / 4;
1369 break;
1370 case 'u':
1371 case 'd':
1372 max_digits = (wsize * 8 * 10 + 32) / 33;
1373 break;
1374 case 'c':
1375 wsize = 1;
1376 break;
1377 }
1378
1379 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001380 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001381 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001382 else
aliguori376253e2009-03-05 23:01:23 +00001383 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001384 l = len;
1385 if (l > line_size)
1386 l = line_size;
1387 if (is_physical) {
1388 cpu_physical_memory_rw(addr, buf, l, 0);
1389 } else {
bellard6a00d602005-11-21 23:25:50 +00001390 env = mon_get_cpu();
aliguoric8f79b62008-08-18 14:00:20 +00001391 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001392 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001393 break;
1394 }
bellard9307c4c2004-04-04 12:57:25 +00001395 }
ths5fafdf22007-09-16 21:08:06 +00001396 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001397 while (i < l) {
1398 switch(wsize) {
1399 default:
1400 case 1:
1401 v = ldub_raw(buf + i);
1402 break;
1403 case 2:
1404 v = lduw_raw(buf + i);
1405 break;
1406 case 4:
bellard92a31b12005-02-10 22:00:52 +00001407 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001408 break;
1409 case 8:
1410 v = ldq_raw(buf + i);
1411 break;
1412 }
aliguori376253e2009-03-05 23:01:23 +00001413 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001414 switch(format) {
1415 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001416 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001417 break;
1418 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001419 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001420 break;
1421 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001422 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001423 break;
1424 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001425 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001426 break;
1427 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001428 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001429 break;
1430 }
1431 i += wsize;
1432 }
aliguori376253e2009-03-05 23:01:23 +00001433 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001434 addr += l;
1435 len -= l;
1436 }
1437}
1438
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001439static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001440{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001441 int count = qdict_get_int(qdict, "count");
1442 int format = qdict_get_int(qdict, "format");
1443 int size = qdict_get_int(qdict, "size");
1444 target_long addr = qdict_get_int(qdict, "addr");
1445
aliguori376253e2009-03-05 23:01:23 +00001446 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001447}
1448
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001449static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001450{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001451 int count = qdict_get_int(qdict, "count");
1452 int format = qdict_get_int(qdict, "format");
1453 int size = qdict_get_int(qdict, "size");
Anthony Liguoric227f092009-10-01 16:12:16 -05001454 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001455
aliguori376253e2009-03-05 23:01:23 +00001456 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001457}
1458
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001459static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001460{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001461 int format = qdict_get_int(qdict, "format");
Anthony Liguoric227f092009-10-01 16:12:16 -05001462 target_phys_addr_t val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001463
blueswir17743e582007-09-24 18:39:04 +00001464#if TARGET_PHYS_ADDR_BITS == 32
bellard9307c4c2004-04-04 12:57:25 +00001465 switch(format) {
1466 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001467 monitor_printf(mon, "%#o", val);
bellard9307c4c2004-04-04 12:57:25 +00001468 break;
1469 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001470 monitor_printf(mon, "%#x", val);
bellard9307c4c2004-04-04 12:57:25 +00001471 break;
1472 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001473 monitor_printf(mon, "%u", val);
bellard9307c4c2004-04-04 12:57:25 +00001474 break;
1475 default:
1476 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001477 monitor_printf(mon, "%d", val);
bellard9307c4c2004-04-04 12:57:25 +00001478 break;
1479 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001480 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001481 break;
1482 }
bellard92a31b12005-02-10 22:00:52 +00001483#else
1484 switch(format) {
1485 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001486 monitor_printf(mon, "%#" PRIo64, val);
bellard92a31b12005-02-10 22:00:52 +00001487 break;
1488 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001489 monitor_printf(mon, "%#" PRIx64, val);
bellard92a31b12005-02-10 22:00:52 +00001490 break;
1491 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001492 monitor_printf(mon, "%" PRIu64, val);
bellard92a31b12005-02-10 22:00:52 +00001493 break;
1494 default:
1495 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001496 monitor_printf(mon, "%" PRId64, val);
bellard92a31b12005-02-10 22:00:52 +00001497 break;
1498 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001499 monitor_printc(mon, val);
bellard92a31b12005-02-10 22:00:52 +00001500 break;
1501 }
1502#endif
aliguori376253e2009-03-05 23:01:23 +00001503 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001504}
1505
Luiz Capitulino98696222010-02-10 23:49:58 -02001506static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellardb371dc52007-01-03 15:20:39 +00001507{
1508 FILE *f;
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001509 uint32_t size = qdict_get_int(qdict, "size");
1510 const char *filename = qdict_get_str(qdict, "filename");
1511 target_long addr = qdict_get_int(qdict, "val");
bellardb371dc52007-01-03 15:20:39 +00001512 uint32_t l;
1513 CPUState *env;
1514 uint8_t buf[1024];
Luiz Capitulino98696222010-02-10 23:49:58 -02001515 int ret = -1;
bellardb371dc52007-01-03 15:20:39 +00001516
1517 env = mon_get_cpu();
bellardb371dc52007-01-03 15:20:39 +00001518
1519 f = fopen(filename, "wb");
1520 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001521 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulino98696222010-02-10 23:49:58 -02001522 return -1;
bellardb371dc52007-01-03 15:20:39 +00001523 }
1524 while (size != 0) {
1525 l = sizeof(buf);
1526 if (l > size)
1527 l = size;
1528 cpu_memory_rw_debug(env, addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001529 if (fwrite(buf, 1, l, f) != l) {
1530 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1531 goto exit;
1532 }
bellardb371dc52007-01-03 15:20:39 +00001533 addr += l;
1534 size -= l;
1535 }
Luiz Capitulino98696222010-02-10 23:49:58 -02001536
1537 ret = 0;
1538
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001539exit:
bellardb371dc52007-01-03 15:20:39 +00001540 fclose(f);
Luiz Capitulino98696222010-02-10 23:49:58 -02001541 return ret;
bellardb371dc52007-01-03 15:20:39 +00001542}
1543
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001544static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
Luiz Capitulino18f5a8b2009-10-16 12:23:44 -03001545 QObject **ret_data)
aurel32a8bdf7a2008-04-11 21:36:14 +00001546{
1547 FILE *f;
1548 uint32_t l;
1549 uint8_t buf[1024];
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001550 uint32_t size = qdict_get_int(qdict, "size");
1551 const char *filename = qdict_get_str(qdict, "filename");
Anthony Liguoric227f092009-10-01 16:12:16 -05001552 target_phys_addr_t addr = qdict_get_int(qdict, "val");
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001553 int ret = -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001554
1555 f = fopen(filename, "wb");
1556 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001557 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001558 return -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001559 }
1560 while (size != 0) {
1561 l = sizeof(buf);
1562 if (l > size)
1563 l = size;
1564 cpu_physical_memory_rw(addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001565 if (fwrite(buf, 1, l, f) != l) {
1566 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1567 goto exit;
1568 }
aurel32a8bdf7a2008-04-11 21:36:14 +00001569 fflush(f);
1570 addr += l;
1571 size -= l;
1572 }
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001573
1574 ret = 0;
1575
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001576exit:
aurel32a8bdf7a2008-04-11 21:36:14 +00001577 fclose(f);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001578 return ret;
aurel32a8bdf7a2008-04-11 21:36:14 +00001579}
1580
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001581static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001582{
1583 uint32_t addr;
1584 uint8_t buf[1];
1585 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001586 uint32_t start = qdict_get_int(qdict, "start");
1587 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001588
1589 sum = 0;
1590 for(addr = start; addr < (start + size); addr++) {
1591 cpu_physical_memory_rw(addr, buf, 1, 0);
1592 /* BSD sum algorithm ('sum' Unix command) */
1593 sum = (sum >> 1) | (sum << 15);
1594 sum += buf[0];
1595 }
aliguori376253e2009-03-05 23:01:23 +00001596 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001597}
1598
bellarda3a91a32004-06-04 11:06:21 +00001599typedef struct {
1600 int keycode;
1601 const char *name;
1602} KeyDef;
1603
1604static const KeyDef key_defs[] = {
1605 { 0x2a, "shift" },
1606 { 0x36, "shift_r" },
ths3b46e622007-09-17 08:09:54 +00001607
bellarda3a91a32004-06-04 11:06:21 +00001608 { 0x38, "alt" },
1609 { 0xb8, "alt_r" },
ths2ba27c72008-08-13 12:54:23 +00001610 { 0x64, "altgr" },
1611 { 0xe4, "altgr_r" },
bellarda3a91a32004-06-04 11:06:21 +00001612 { 0x1d, "ctrl" },
1613 { 0x9d, "ctrl_r" },
1614
1615 { 0xdd, "menu" },
1616
1617 { 0x01, "esc" },
1618
1619 { 0x02, "1" },
1620 { 0x03, "2" },
1621 { 0x04, "3" },
1622 { 0x05, "4" },
1623 { 0x06, "5" },
1624 { 0x07, "6" },
1625 { 0x08, "7" },
1626 { 0x09, "8" },
1627 { 0x0a, "9" },
1628 { 0x0b, "0" },
bellard64866c32006-05-07 18:03:31 +00001629 { 0x0c, "minus" },
1630 { 0x0d, "equal" },
bellarda3a91a32004-06-04 11:06:21 +00001631 { 0x0e, "backspace" },
1632
1633 { 0x0f, "tab" },
1634 { 0x10, "q" },
1635 { 0x11, "w" },
1636 { 0x12, "e" },
1637 { 0x13, "r" },
1638 { 0x14, "t" },
1639 { 0x15, "y" },
1640 { 0x16, "u" },
1641 { 0x17, "i" },
1642 { 0x18, "o" },
1643 { 0x19, "p" },
1644
1645 { 0x1c, "ret" },
1646
1647 { 0x1e, "a" },
1648 { 0x1f, "s" },
1649 { 0x20, "d" },
1650 { 0x21, "f" },
1651 { 0x22, "g" },
1652 { 0x23, "h" },
1653 { 0x24, "j" },
1654 { 0x25, "k" },
1655 { 0x26, "l" },
1656
1657 { 0x2c, "z" },
1658 { 0x2d, "x" },
1659 { 0x2e, "c" },
1660 { 0x2f, "v" },
1661 { 0x30, "b" },
1662 { 0x31, "n" },
1663 { 0x32, "m" },
aurel329155fc42008-10-01 21:46:15 +00001664 { 0x33, "comma" },
1665 { 0x34, "dot" },
1666 { 0x35, "slash" },
ths3b46e622007-09-17 08:09:54 +00001667
balrog4d3b6f62008-02-10 16:33:14 +00001668 { 0x37, "asterisk" },
1669
bellarda3a91a32004-06-04 11:06:21 +00001670 { 0x39, "spc" },
bellard00ffa622004-06-04 13:25:15 +00001671 { 0x3a, "caps_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001672 { 0x3b, "f1" },
1673 { 0x3c, "f2" },
1674 { 0x3d, "f3" },
1675 { 0x3e, "f4" },
1676 { 0x3f, "f5" },
1677 { 0x40, "f6" },
1678 { 0x41, "f7" },
1679 { 0x42, "f8" },
1680 { 0x43, "f9" },
1681 { 0x44, "f10" },
bellard00ffa622004-06-04 13:25:15 +00001682 { 0x45, "num_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001683 { 0x46, "scroll_lock" },
1684
bellard64866c32006-05-07 18:03:31 +00001685 { 0xb5, "kp_divide" },
1686 { 0x37, "kp_multiply" },
ths0cfec832007-06-23 16:02:43 +00001687 { 0x4a, "kp_subtract" },
bellard64866c32006-05-07 18:03:31 +00001688 { 0x4e, "kp_add" },
1689 { 0x9c, "kp_enter" },
1690 { 0x53, "kp_decimal" },
balrogf2289cb2008-06-04 10:14:16 +00001691 { 0x54, "sysrq" },
bellard64866c32006-05-07 18:03:31 +00001692
1693 { 0x52, "kp_0" },
1694 { 0x4f, "kp_1" },
1695 { 0x50, "kp_2" },
1696 { 0x51, "kp_3" },
1697 { 0x4b, "kp_4" },
1698 { 0x4c, "kp_5" },
1699 { 0x4d, "kp_6" },
1700 { 0x47, "kp_7" },
1701 { 0x48, "kp_8" },
1702 { 0x49, "kp_9" },
ths3b46e622007-09-17 08:09:54 +00001703
bellarda3a91a32004-06-04 11:06:21 +00001704 { 0x56, "<" },
1705
1706 { 0x57, "f11" },
1707 { 0x58, "f12" },
1708
1709 { 0xb7, "print" },
1710
1711 { 0xc7, "home" },
1712 { 0xc9, "pgup" },
1713 { 0xd1, "pgdn" },
1714 { 0xcf, "end" },
1715
1716 { 0xcb, "left" },
1717 { 0xc8, "up" },
1718 { 0xd0, "down" },
1719 { 0xcd, "right" },
1720
1721 { 0xd2, "insert" },
1722 { 0xd3, "delete" },
blueswir1c0b5b102008-06-22 07:45:42 +00001723#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1724 { 0xf0, "stop" },
1725 { 0xf1, "again" },
1726 { 0xf2, "props" },
1727 { 0xf3, "undo" },
1728 { 0xf4, "front" },
1729 { 0xf5, "copy" },
1730 { 0xf6, "open" },
1731 { 0xf7, "paste" },
1732 { 0xf8, "find" },
1733 { 0xf9, "cut" },
1734 { 0xfa, "lf" },
1735 { 0xfb, "help" },
1736 { 0xfc, "meta_l" },
1737 { 0xfd, "meta_r" },
1738 { 0xfe, "compose" },
1739#endif
bellarda3a91a32004-06-04 11:06:21 +00001740 { 0, NULL },
1741};
1742
1743static int get_keycode(const char *key)
1744{
1745 const KeyDef *p;
bellard64866c32006-05-07 18:03:31 +00001746 char *endp;
1747 int ret;
bellarda3a91a32004-06-04 11:06:21 +00001748
1749 for(p = key_defs; p->name != NULL; p++) {
1750 if (!strcmp(key, p->name))
1751 return p->keycode;
1752 }
bellard64866c32006-05-07 18:03:31 +00001753 if (strstart(key, "0x", NULL)) {
1754 ret = strtoul(key, &endp, 0);
1755 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1756 return ret;
1757 }
bellarda3a91a32004-06-04 11:06:21 +00001758 return -1;
1759}
1760
balrogc8256f92008-06-08 22:45:01 +00001761#define MAX_KEYCODES 16
1762static uint8_t keycodes[MAX_KEYCODES];
1763static int nb_pending_keycodes;
1764static QEMUTimer *key_timer;
1765
1766static void release_keys(void *opaque)
bellarda3a91a32004-06-04 11:06:21 +00001767{
balrogc8256f92008-06-08 22:45:01 +00001768 int keycode;
1769
1770 while (nb_pending_keycodes > 0) {
1771 nb_pending_keycodes--;
1772 keycode = keycodes[nb_pending_keycodes];
1773 if (keycode & 0x80)
1774 kbd_put_keycode(0xe0);
1775 kbd_put_keycode(keycode | 0x80);
1776 }
1777}
1778
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001779static void do_sendkey(Monitor *mon, const QDict *qdict)
balrogc8256f92008-06-08 22:45:01 +00001780{
balrog3401c0d2008-06-04 10:05:59 +00001781 char keyname_buf[16];
1782 char *separator;
1783 int keyname_len, keycode, i;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001784 const char *string = qdict_get_str(qdict, "string");
1785 int has_hold_time = qdict_haskey(qdict, "hold_time");
1786 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
ths3b46e622007-09-17 08:09:54 +00001787
balrogc8256f92008-06-08 22:45:01 +00001788 if (nb_pending_keycodes > 0) {
1789 qemu_del_timer(key_timer);
1790 release_keys(NULL);
1791 }
1792 if (!has_hold_time)
1793 hold_time = 100;
1794 i = 0;
balrog3401c0d2008-06-04 10:05:59 +00001795 while (1) {
1796 separator = strchr(string, '-');
1797 keyname_len = separator ? separator - string : strlen(string);
1798 if (keyname_len > 0) {
1799 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1800 if (keyname_len > sizeof(keyname_buf) - 1) {
aliguori376253e2009-03-05 23:01:23 +00001801 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001802 return;
bellarda3a91a32004-06-04 11:06:21 +00001803 }
balrogc8256f92008-06-08 22:45:01 +00001804 if (i == MAX_KEYCODES) {
aliguori376253e2009-03-05 23:01:23 +00001805 monitor_printf(mon, "too many keys\n");
balrog3401c0d2008-06-04 10:05:59 +00001806 return;
1807 }
1808 keyname_buf[keyname_len] = 0;
1809 keycode = get_keycode(keyname_buf);
1810 if (keycode < 0) {
aliguori376253e2009-03-05 23:01:23 +00001811 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001812 return;
1813 }
balrogc8256f92008-06-08 22:45:01 +00001814 keycodes[i++] = keycode;
bellarda3a91a32004-06-04 11:06:21 +00001815 }
balrog3401c0d2008-06-04 10:05:59 +00001816 if (!separator)
bellarda3a91a32004-06-04 11:06:21 +00001817 break;
balrog3401c0d2008-06-04 10:05:59 +00001818 string = separator + 1;
bellarda3a91a32004-06-04 11:06:21 +00001819 }
balrogc8256f92008-06-08 22:45:01 +00001820 nb_pending_keycodes = i;
bellarda3a91a32004-06-04 11:06:21 +00001821 /* key down events */
balrogc8256f92008-06-08 22:45:01 +00001822 for (i = 0; i < nb_pending_keycodes; i++) {
bellarda3a91a32004-06-04 11:06:21 +00001823 keycode = keycodes[i];
1824 if (keycode & 0x80)
1825 kbd_put_keycode(0xe0);
1826 kbd_put_keycode(keycode & 0x7f);
1827 }
balrogc8256f92008-06-08 22:45:01 +00001828 /* delayed key up events */
balrogf227f172008-06-09 00:03:47 +00001829 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
Juan Quintela6ee093c2009-09-10 03:04:26 +02001830 muldiv64(get_ticks_per_sec(), hold_time, 1000));
bellarda3a91a32004-06-04 11:06:21 +00001831}
1832
bellard13224a82006-07-14 22:03:35 +00001833static int mouse_button_state;
1834
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001835static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001836{
1837 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001838 const char *dx_str = qdict_get_str(qdict, "dx_str");
1839 const char *dy_str = qdict_get_str(qdict, "dy_str");
1840 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001841 dx = strtol(dx_str, NULL, 0);
1842 dy = strtol(dy_str, NULL, 0);
1843 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001844 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001845 dz = strtol(dz_str, NULL, 0);
1846 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1847}
1848
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001849static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001850{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001851 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001852 mouse_button_state = button_state;
1853 kbd_mouse_event(0, 0, 0, mouse_button_state);
1854}
1855
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001856static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001857{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001858 int size = qdict_get_int(qdict, "size");
1859 int addr = qdict_get_int(qdict, "addr");
1860 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001861 uint32_t val;
1862 int suffix;
1863
1864 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001865 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001866 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001867 addr++;
1868 }
1869 addr &= 0xffff;
1870
1871 switch(size) {
1872 default:
1873 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001874 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001875 suffix = 'b';
1876 break;
1877 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001878 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001879 suffix = 'w';
1880 break;
1881 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001882 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001883 suffix = 'l';
1884 break;
1885 }
aliguori376253e2009-03-05 23:01:23 +00001886 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1887 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001888}
bellarda3a91a32004-06-04 11:06:21 +00001889
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001890static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001891{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001892 int size = qdict_get_int(qdict, "size");
1893 int addr = qdict_get_int(qdict, "addr");
1894 int val = qdict_get_int(qdict, "val");
1895
Jan Kiszkaf1147842009-07-14 10:20:11 +02001896 addr &= IOPORTS_MASK;
1897
1898 switch (size) {
1899 default:
1900 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001901 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001902 break;
1903 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001904 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001905 break;
1906 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001907 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001908 break;
1909 }
1910}
1911
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001912static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001913{
1914 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001915 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001916
Jan Kiszka76e30d02009-07-02 00:19:02 +02001917 res = qemu_boot_set(bootdevice);
1918 if (res == 0) {
1919 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1920 } else if (res > 0) {
1921 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001922 } else {
aliguori376253e2009-03-05 23:01:23 +00001923 monitor_printf(mon, "no function defined to set boot device list for "
1924 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001925 }
1926}
1927
Luiz Capitulinoc80d2592009-10-07 13:41:58 -03001928/**
1929 * do_system_reset(): Issue a machine reset
1930 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001931static int do_system_reset(Monitor *mon, const QDict *qdict,
1932 QObject **ret_data)
bellarde4f90822004-06-20 12:35:44 +00001933{
1934 qemu_system_reset_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001935 return 0;
bellarde4f90822004-06-20 12:35:44 +00001936}
1937
Luiz Capitulino43076662009-10-07 13:41:59 -03001938/**
1939 * do_system_powerdown(): Issue a machine powerdown
1940 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001941static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1942 QObject **ret_data)
bellard34751872005-07-02 14:31:34 +00001943{
1944 qemu_system_powerdown_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001945 return 0;
bellard34751872005-07-02 14:31:34 +00001946}
1947
bellardb86bda52004-09-18 19:32:46 +00001948#if defined(TARGET_I386)
aliguori376253e2009-03-05 23:01:23 +00001949static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
bellardb86bda52004-09-18 19:32:46 +00001950{
aliguori376253e2009-03-05 23:01:23 +00001951 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1952 addr,
1953 pte & mask,
1954 pte & PG_GLOBAL_MASK ? 'G' : '-',
1955 pte & PG_PSE_MASK ? 'P' : '-',
1956 pte & PG_DIRTY_MASK ? 'D' : '-',
1957 pte & PG_ACCESSED_MASK ? 'A' : '-',
1958 pte & PG_PCD_MASK ? 'C' : '-',
1959 pte & PG_PWT_MASK ? 'T' : '-',
1960 pte & PG_USER_MASK ? 'U' : '-',
1961 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001962}
1963
aliguori376253e2009-03-05 23:01:23 +00001964static void tlb_info(Monitor *mon)
bellardb86bda52004-09-18 19:32:46 +00001965{
bellard6a00d602005-11-21 23:25:50 +00001966 CPUState *env;
bellardb86bda52004-09-18 19:32:46 +00001967 int l1, l2;
1968 uint32_t pgd, pde, pte;
1969
bellard6a00d602005-11-21 23:25:50 +00001970 env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00001971
bellardb86bda52004-09-18 19:32:46 +00001972 if (!(env->cr[0] & CR0_PG_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00001973 monitor_printf(mon, "PG disabled\n");
bellardb86bda52004-09-18 19:32:46 +00001974 return;
1975 }
1976 pgd = env->cr[3] & ~0xfff;
1977 for(l1 = 0; l1 < 1024; l1++) {
1978 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1979 pde = le32_to_cpu(pde);
1980 if (pde & PG_PRESENT_MASK) {
1981 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00001982 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
bellardb86bda52004-09-18 19:32:46 +00001983 } else {
1984 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00001985 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00001986 (uint8_t *)&pte, 4);
1987 pte = le32_to_cpu(pte);
1988 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00001989 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00001990 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00001991 ~0xfff);
1992 }
1993 }
1994 }
1995 }
1996 }
1997}
1998
aliguori376253e2009-03-05 23:01:23 +00001999static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
bellardb86bda52004-09-18 19:32:46 +00002000 uint32_t end, int prot)
2001{
bellard9746b152004-11-11 18:30:24 +00002002 int prot1;
2003 prot1 = *plast_prot;
2004 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00002005 if (*pstart != -1) {
aliguori376253e2009-03-05 23:01:23 +00002006 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
2007 *pstart, end, end - *pstart,
2008 prot1 & PG_USER_MASK ? 'u' : '-',
2009 'r',
2010 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00002011 }
2012 if (prot != 0)
2013 *pstart = end;
2014 else
2015 *pstart = -1;
2016 *plast_prot = prot;
2017 }
2018}
2019
aliguori376253e2009-03-05 23:01:23 +00002020static void mem_info(Monitor *mon)
bellardb86bda52004-09-18 19:32:46 +00002021{
bellard6a00d602005-11-21 23:25:50 +00002022 CPUState *env;
bellardb86bda52004-09-18 19:32:46 +00002023 int l1, l2, prot, last_prot;
2024 uint32_t pgd, pde, pte, start, end;
2025
bellard6a00d602005-11-21 23:25:50 +00002026 env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002027
bellardb86bda52004-09-18 19:32:46 +00002028 if (!(env->cr[0] & CR0_PG_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00002029 monitor_printf(mon, "PG disabled\n");
bellardb86bda52004-09-18 19:32:46 +00002030 return;
2031 }
2032 pgd = env->cr[3] & ~0xfff;
2033 last_prot = 0;
2034 start = -1;
2035 for(l1 = 0; l1 < 1024; l1++) {
2036 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
2037 pde = le32_to_cpu(pde);
2038 end = l1 << 22;
2039 if (pde & PG_PRESENT_MASK) {
2040 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2041 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00002042 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002043 } else {
2044 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00002045 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00002046 (uint8_t *)&pte, 4);
2047 pte = le32_to_cpu(pte);
2048 end = (l1 << 22) + (l2 << 12);
2049 if (pte & PG_PRESENT_MASK) {
2050 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2051 } else {
2052 prot = 0;
2053 }
aliguori376253e2009-03-05 23:01:23 +00002054 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002055 }
2056 }
2057 } else {
2058 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00002059 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002060 }
2061 }
2062}
2063#endif
2064
aurel327c664e22009-03-03 06:12:22 +00002065#if defined(TARGET_SH4)
2066
aliguori376253e2009-03-05 23:01:23 +00002067static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00002068{
aliguori376253e2009-03-05 23:01:23 +00002069 monitor_printf(mon, " tlb%i:\t"
2070 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2071 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2072 "dirty=%hhu writethrough=%hhu\n",
2073 idx,
2074 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2075 tlb->v, tlb->sh, tlb->c, tlb->pr,
2076 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00002077}
2078
aliguori376253e2009-03-05 23:01:23 +00002079static void tlb_info(Monitor *mon)
aurel327c664e22009-03-03 06:12:22 +00002080{
2081 CPUState *env = mon_get_cpu();
2082 int i;
2083
aliguori376253e2009-03-05 23:01:23 +00002084 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002085 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002086 print_tlb (mon, i, &env->itlb[i]);
2087 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002088 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002089 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00002090}
2091
2092#endif
2093
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002094static void do_info_kvm_print(Monitor *mon, const QObject *data)
2095{
2096 QDict *qdict;
2097
2098 qdict = qobject_to_qdict(data);
2099
2100 monitor_printf(mon, "kvm support: ");
2101 if (qdict_get_bool(qdict, "present")) {
2102 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
2103 "enabled" : "disabled");
2104 } else {
2105 monitor_printf(mon, "not compiled\n");
2106 }
2107}
2108
2109/**
2110 * do_info_kvm(): Show KVM information
2111 *
2112 * Return a QDict with the following information:
2113 *
2114 * - "enabled": true if KVM support is enabled, false otherwise
2115 * - "present": true if QEMU has KVM support, false otherwise
2116 *
2117 * Example:
2118 *
2119 * { "enabled": true, "present": true }
2120 */
2121static void do_info_kvm(Monitor *mon, QObject **ret_data)
aliguori7ba1e612008-11-05 16:04:33 +00002122{
2123#ifdef CONFIG_KVM
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002124 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
2125 kvm_enabled());
aliguori7ba1e612008-11-05 16:04:33 +00002126#else
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002127 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
aliguori7ba1e612008-11-05 16:04:33 +00002128#endif
2129}
2130
aliguori030ea372009-04-21 22:30:47 +00002131static void do_info_numa(Monitor *mon)
2132{
aliguorib28b6232009-04-22 20:20:29 +00002133 int i;
aliguori030ea372009-04-21 22:30:47 +00002134 CPUState *env;
2135
2136 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2137 for (i = 0; i < nb_numa_nodes; i++) {
2138 monitor_printf(mon, "node %d cpus:", i);
2139 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2140 if (env->numa_node == i) {
2141 monitor_printf(mon, " %d", env->cpu_index);
2142 }
2143 }
2144 monitor_printf(mon, "\n");
2145 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2146 node_mem[i] >> 20);
2147 }
2148}
2149
bellard5f1ce942006-02-08 22:40:15 +00002150#ifdef CONFIG_PROFILER
2151
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002152int64_t qemu_time;
2153int64_t dev_time;
2154
aliguori376253e2009-03-05 23:01:23 +00002155static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002156{
2157 int64_t total;
2158 total = qemu_time;
2159 if (total == 0)
2160 total = 1;
aliguori376253e2009-03-05 23:01:23 +00002161 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002162 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00002163 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002164 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00002165 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002166 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002167}
2168#else
aliguori376253e2009-03-05 23:01:23 +00002169static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002170{
aliguori376253e2009-03-05 23:01:23 +00002171 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002172}
2173#endif
2174
bellardec36b692006-07-16 18:57:03 +00002175/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002176static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002177
aliguori376253e2009-03-05 23:01:23 +00002178static void do_info_capture(Monitor *mon)
bellardec36b692006-07-16 18:57:03 +00002179{
2180 int i;
2181 CaptureState *s;
2182
2183 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002184 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002185 s->ops.info (s->opaque);
2186 }
2187}
2188
Blue Swirl23130862009-06-06 08:22:04 +00002189#ifdef HAS_AUDIO
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002190static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002191{
2192 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002193 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002194 CaptureState *s;
2195
2196 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2197 if (i == n) {
2198 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002199 QLIST_REMOVE (s, entries);
bellardec36b692006-07-16 18:57:03 +00002200 qemu_free (s);
2201 return;
2202 }
2203 }
2204}
2205
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002206static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002207{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002208 const char *path = qdict_get_str(qdict, "path");
2209 int has_freq = qdict_haskey(qdict, "freq");
2210 int freq = qdict_get_try_int(qdict, "freq", -1);
2211 int has_bits = qdict_haskey(qdict, "bits");
2212 int bits = qdict_get_try_int(qdict, "bits", -1);
2213 int has_channels = qdict_haskey(qdict, "nchannels");
2214 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002215 CaptureState *s;
2216
2217 s = qemu_mallocz (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002218
2219 freq = has_freq ? freq : 44100;
2220 bits = has_bits ? bits : 16;
2221 nchannels = has_channels ? nchannels : 2;
2222
2223 if (wav_start_capture (s, path, freq, bits, nchannels)) {
aliguori376253e2009-03-05 23:01:23 +00002224 monitor_printf(mon, "Faied to add wave capture\n");
bellardec36b692006-07-16 18:57:03 +00002225 qemu_free (s);
2226 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002227 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002228}
2229#endif
2230
aurel32dc1c0b72008-04-27 23:52:12 +00002231#if defined(TARGET_I386)
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002232static void do_inject_nmi(Monitor *mon, const QDict *qdict)
aurel32dc1c0b72008-04-27 23:52:12 +00002233{
2234 CPUState *env;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002235 int cpu_index = qdict_get_int(qdict, "cpu_index");
aurel32dc1c0b72008-04-27 23:52:12 +00002236
2237 for (env = first_cpu; env != NULL; env = env->next_cpu)
2238 if (env->cpu_index == cpu_index) {
2239 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2240 break;
2241 }
2242}
2243#endif
2244
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002245static void do_info_status_print(Monitor *mon, const QObject *data)
aurel326f9c5ee2008-12-18 22:43:56 +00002246{
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002247 QDict *qdict;
2248
2249 qdict = qobject_to_qdict(data);
2250
2251 monitor_printf(mon, "VM status: ");
2252 if (qdict_get_bool(qdict, "running")) {
2253 monitor_printf(mon, "running");
2254 if (qdict_get_bool(qdict, "singlestep")) {
2255 monitor_printf(mon, " (single step mode)");
aurel321b530a62009-04-05 20:08:59 +00002256 }
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002257 } else {
2258 monitor_printf(mon, "paused");
2259 }
2260
2261 monitor_printf(mon, "\n");
2262}
2263
2264/**
2265 * do_info_status(): VM status
2266 *
2267 * Return a QDict with the following information:
2268 *
2269 * - "running": true if the VM is running, or false if it is paused
2270 * - "singlestep": true if the VM is in single step mode, false otherwise
2271 *
2272 * Example:
2273 *
2274 * { "running": true, "singlestep": false }
2275 */
2276static void do_info_status(Monitor *mon, QObject **ret_data)
2277{
2278 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2279 vm_running, singlestep);
aurel326f9c5ee2008-12-18 22:43:56 +00002280}
2281
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002282static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002283{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002284 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002285
aliguori76655d62009-03-06 20:27:37 +00002286 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002287 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002288 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002289 return acl;
2290}
aliguori76655d62009-03-06 20:27:37 +00002291
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002292static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002293{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002294 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002295 qemu_acl *acl = find_acl(mon, aclname);
2296 qemu_acl_entry *entry;
2297 int i = 0;
2298
2299 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002300 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002301 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002302 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002303 i++;
2304 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002305 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002306 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002307 }
2308}
2309
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002310static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002311{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002312 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002313 qemu_acl *acl = find_acl(mon, aclname);
2314
2315 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002316 qemu_acl_reset(acl);
2317 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002318 }
2319}
aliguori76655d62009-03-06 20:27:37 +00002320
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002321static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002322{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002323 const char *aclname = qdict_get_str(qdict, "aclname");
2324 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002325 qemu_acl *acl = find_acl(mon, aclname);
2326
2327 if (acl) {
2328 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002329 acl->defaultDeny = 0;
2330 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002331 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002332 acl->defaultDeny = 1;
2333 monitor_printf(mon, "acl: policy set to 'deny'\n");
2334 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002335 monitor_printf(mon, "acl: unknown policy '%s', "
2336 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002337 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002338 }
2339}
aliguori76655d62009-03-06 20:27:37 +00002340
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002341static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002342{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002343 const char *aclname = qdict_get_str(qdict, "aclname");
2344 const char *match = qdict_get_str(qdict, "match");
2345 const char *policy = qdict_get_str(qdict, "policy");
2346 int has_index = qdict_haskey(qdict, "index");
2347 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002348 qemu_acl *acl = find_acl(mon, aclname);
2349 int deny, ret;
2350
2351 if (acl) {
2352 if (strcmp(policy, "allow") == 0) {
2353 deny = 0;
2354 } else if (strcmp(policy, "deny") == 0) {
2355 deny = 1;
2356 } else {
2357 monitor_printf(mon, "acl: unknown policy '%s', "
2358 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002359 return;
2360 }
aliguori28a76be2009-03-06 20:27:40 +00002361 if (has_index)
2362 ret = qemu_acl_insert(acl, deny, match, index);
2363 else
2364 ret = qemu_acl_append(acl, deny, match);
2365 if (ret < 0)
2366 monitor_printf(mon, "acl: unable to add acl entry\n");
2367 else
2368 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002369 }
2370}
aliguori76655d62009-03-06 20:27:37 +00002371
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002372static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002373{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002374 const char *aclname = qdict_get_str(qdict, "aclname");
2375 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002376 qemu_acl *acl = find_acl(mon, aclname);
2377 int ret;
aliguori76655d62009-03-06 20:27:37 +00002378
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002379 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002380 ret = qemu_acl_remove(acl, match);
2381 if (ret < 0)
2382 monitor_printf(mon, "acl: no matching acl entry\n");
2383 else
2384 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002385 }
2386}
2387
Huang Ying79c4f6b2009-06-23 10:05:14 +08002388#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002389static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002390{
2391 CPUState *cenv;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002392 int cpu_index = qdict_get_int(qdict, "cpu_index");
2393 int bank = qdict_get_int(qdict, "bank");
2394 uint64_t status = qdict_get_int(qdict, "status");
2395 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2396 uint64_t addr = qdict_get_int(qdict, "addr");
2397 uint64_t misc = qdict_get_int(qdict, "misc");
Huang Ying79c4f6b2009-06-23 10:05:14 +08002398
2399 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2400 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2401 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2402 break;
2403 }
2404}
2405#endif
2406
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002407static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002408{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002409 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002410 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002411 int fd;
2412
2413 fd = qemu_chr_get_msgfd(mon->chr);
2414 if (fd == -1) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002415 qerror_report(QERR_FD_NOT_SUPPLIED);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002416 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002417 }
2418
2419 if (qemu_isdigit(fdname[0])) {
Markus Armbrustere17ba872010-03-25 17:22:36 +01002420 qerror_report(QERR_INVALID_PARAMETER_VALUE, "fdname",
2421 "a name not starting with a digit");
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002422 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002423 }
2424
Blue Swirl72cf2d42009-09-12 07:36:22 +00002425 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002426 if (strcmp(monfd->name, fdname) != 0) {
2427 continue;
2428 }
2429
2430 close(monfd->fd);
2431 monfd->fd = fd;
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002432 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002433 }
2434
Anthony Liguoric227f092009-10-01 16:12:16 -05002435 monfd = qemu_mallocz(sizeof(mon_fd_t));
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002436 monfd->name = qemu_strdup(fdname);
2437 monfd->fd = fd;
2438
Blue Swirl72cf2d42009-09-12 07:36:22 +00002439 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002440 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002441}
2442
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002443static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002444{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002445 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002446 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002447
Blue Swirl72cf2d42009-09-12 07:36:22 +00002448 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002449 if (strcmp(monfd->name, fdname) != 0) {
2450 continue;
2451 }
2452
Blue Swirl72cf2d42009-09-12 07:36:22 +00002453 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002454 close(monfd->fd);
2455 qemu_free(monfd->name);
2456 qemu_free(monfd);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002457 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002458 }
2459
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002460 qerror_report(QERR_FD_NOT_FOUND, fdname);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002461 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002462}
2463
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002464static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002465{
2466 int saved_vm_running = vm_running;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002467 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002468
2469 vm_stop(0);
2470
Markus Armbruster03cd4652010-02-17 16:24:10 +01002471 if (load_vmstate(name) >= 0 && saved_vm_running)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002472 vm_start();
2473}
2474
Mark McLoughlin7768e042009-07-22 09:11:41 +01002475int monitor_get_fd(Monitor *mon, const char *fdname)
2476{
Anthony Liguoric227f092009-10-01 16:12:16 -05002477 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002478
Blue Swirl72cf2d42009-09-12 07:36:22 +00002479 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002480 int fd;
2481
2482 if (strcmp(monfd->name, fdname) != 0) {
2483 continue;
2484 }
2485
2486 fd = monfd->fd;
2487
2488 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002489 QLIST_REMOVE(monfd, next);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002490 qemu_free(monfd->name);
2491 qemu_free(monfd);
2492
2493 return fd;
2494 }
2495
2496 return -1;
2497}
2498
Anthony Liguoric227f092009-10-01 16:12:16 -05002499static const mon_cmd_t mon_cmds[] = {
Blue Swirl23130862009-06-06 08:22:04 +00002500#include "qemu-monitor.h"
ths5fafdf22007-09-16 21:08:06 +00002501 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00002502};
2503
Blue Swirl23130862009-06-06 08:22:04 +00002504/* Please update qemu-monitor.hx when adding or changing commands */
Anthony Liguoric227f092009-10-01 16:12:16 -05002505static const mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002506 {
2507 .name = "version",
2508 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002509 .params = "",
2510 .help = "show the version of QEMU",
Luiz Capitulino45e914c2009-12-10 17:15:58 -02002511 .user_print = do_info_version_print,
Luiz Capitulinoab2d3182009-10-07 13:42:02 -03002512 .mhandler.info_new = do_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002513 },
2514 {
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02002515 .name = "commands",
2516 .args_type = "",
2517 .params = "",
2518 .help = "list QMP available commands",
2519 .user_print = monitor_user_noop,
2520 .mhandler.info_new = do_info_commands,
2521 },
2522 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002523 .name = "network",
2524 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002525 .params = "",
2526 .help = "show the network state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002527 .mhandler.info = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002528 },
2529 {
2530 .name = "chardev",
2531 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002532 .params = "",
2533 .help = "show the character devices",
Luiz Capitulino588b3832009-12-10 17:16:08 -02002534 .user_print = qemu_chr_info_print,
2535 .mhandler.info_new = qemu_chr_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002536 },
2537 {
2538 .name = "block",
2539 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002540 .params = "",
2541 .help = "show the block devices",
Luiz Capitulinod15e5462009-12-10 17:16:06 -02002542 .user_print = bdrv_info_print,
2543 .mhandler.info_new = bdrv_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002544 },
2545 {
2546 .name = "blockstats",
2547 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002548 .params = "",
2549 .help = "show block device statistics",
Luiz Capitulino218a5362009-12-10 17:16:07 -02002550 .user_print = bdrv_stats_print,
2551 .mhandler.info_new = bdrv_info_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002552 },
2553 {
2554 .name = "registers",
2555 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002556 .params = "",
2557 .help = "show the cpu registers",
Luiz Capitulino910df892009-10-07 13:41:51 -03002558 .mhandler.info = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002559 },
2560 {
2561 .name = "cpus",
2562 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002563 .params = "",
2564 .help = "show infos for each CPU",
Luiz Capitulino8f3cec02009-10-07 13:42:04 -03002565 .user_print = monitor_print_cpus,
2566 .mhandler.info_new = do_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002567 },
2568 {
2569 .name = "history",
2570 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002571 .params = "",
2572 .help = "show the command line history",
Luiz Capitulino910df892009-10-07 13:41:51 -03002573 .mhandler.info = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002574 },
2575 {
2576 .name = "irq",
2577 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002578 .params = "",
2579 .help = "show the interrupts statistics (if available)",
Luiz Capitulino910df892009-10-07 13:41:51 -03002580 .mhandler.info = irq_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002581 },
2582 {
2583 .name = "pic",
2584 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002585 .params = "",
2586 .help = "show i8259 (PIC) state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002587 .mhandler.info = pic_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002588 },
2589 {
2590 .name = "pci",
2591 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002592 .params = "",
2593 .help = "show PCI info",
Luiz Capitulino163c8a52010-01-21 19:15:40 -02002594 .user_print = do_pci_info_print,
2595 .mhandler.info_new = do_pci_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002596 },
aurel327c664e22009-03-03 06:12:22 +00002597#if defined(TARGET_I386) || defined(TARGET_SH4)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002598 {
2599 .name = "tlb",
2600 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002601 .params = "",
2602 .help = "show virtual to physical memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002603 .mhandler.info = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002604 },
aurel327c664e22009-03-03 06:12:22 +00002605#endif
2606#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002607 {
2608 .name = "mem",
2609 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002610 .params = "",
2611 .help = "show the active virtual memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002612 .mhandler.info = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002613 },
2614 {
2615 .name = "hpet",
2616 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002617 .params = "",
2618 .help = "show state of HPET",
Luiz Capitulino14f07202009-12-10 17:16:02 -02002619 .user_print = do_info_hpet_print,
2620 .mhandler.info_new = do_info_hpet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002621 },
bellardb86bda52004-09-18 19:32:46 +00002622#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002623 {
2624 .name = "jit",
2625 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002626 .params = "",
2627 .help = "show dynamic compiler info",
Luiz Capitulino910df892009-10-07 13:41:51 -03002628 .mhandler.info = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002629 },
2630 {
2631 .name = "kvm",
2632 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002633 .params = "",
2634 .help = "show KVM information",
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002635 .user_print = do_info_kvm_print,
2636 .mhandler.info_new = do_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002637 },
2638 {
2639 .name = "numa",
2640 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002641 .params = "",
2642 .help = "show NUMA information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002643 .mhandler.info = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002644 },
2645 {
2646 .name = "usb",
2647 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002648 .params = "",
2649 .help = "show guest USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002650 .mhandler.info = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002651 },
2652 {
2653 .name = "usbhost",
2654 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002655 .params = "",
2656 .help = "show host USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002657 .mhandler.info = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002658 },
2659 {
2660 .name = "profile",
2661 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002662 .params = "",
2663 .help = "show profiling information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002664 .mhandler.info = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002665 },
2666 {
2667 .name = "capture",
2668 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002669 .params = "",
2670 .help = "show capture information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002671 .mhandler.info = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002672 },
2673 {
2674 .name = "snapshots",
2675 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002676 .params = "",
2677 .help = "show the currently saved VM snapshots",
Luiz Capitulino910df892009-10-07 13:41:51 -03002678 .mhandler.info = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002679 },
2680 {
2681 .name = "status",
2682 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002683 .params = "",
2684 .help = "show the current VM status (running|paused)",
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002685 .user_print = do_info_status_print,
2686 .mhandler.info_new = do_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002687 },
2688 {
2689 .name = "pcmcia",
2690 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002691 .params = "",
2692 .help = "show guest PCMCIA status",
Luiz Capitulino910df892009-10-07 13:41:51 -03002693 .mhandler.info = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002694 },
2695 {
2696 .name = "mice",
2697 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002698 .params = "",
2699 .help = "show which guest mouse is receiving events",
Luiz Capitulinoe78c48e2009-12-10 17:16:04 -02002700 .user_print = do_info_mice_print,
2701 .mhandler.info_new = do_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002702 },
2703 {
2704 .name = "vnc",
2705 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002706 .params = "",
2707 .help = "show the vnc server status",
Luiz Capitulinod96fd292009-12-10 17:16:10 -02002708 .user_print = do_info_vnc_print,
2709 .mhandler.info_new = do_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002710 },
2711 {
2712 .name = "name",
2713 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002714 .params = "",
2715 .help = "show the current VM name",
Luiz Capitulinoe05486c2009-12-10 17:16:01 -02002716 .user_print = do_info_name_print,
2717 .mhandler.info_new = do_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002718 },
2719 {
2720 .name = "uuid",
2721 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002722 .params = "",
2723 .help = "show the current VM UUID",
Luiz Capitulino9603ceb2009-12-10 17:16:03 -02002724 .user_print = do_info_uuid_print,
2725 .mhandler.info_new = do_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002726 },
j_mayer76a66252007-03-07 08:32:30 +00002727#if defined(TARGET_PPC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002728 {
2729 .name = "cpustats",
2730 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002731 .params = "",
2732 .help = "show CPU statistics",
Luiz Capitulino910df892009-10-07 13:41:51 -03002733 .mhandler.info = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002734 },
j_mayer76a66252007-03-07 08:32:30 +00002735#endif
blueswir131a60e22007-10-26 18:42:59 +00002736#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002737 {
2738 .name = "usernet",
2739 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002740 .params = "",
2741 .help = "show user network stack connection states",
Luiz Capitulino910df892009-10-07 13:41:51 -03002742 .mhandler.info = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002743 },
blueswir131a60e22007-10-26 18:42:59 +00002744#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002745 {
2746 .name = "migrate",
2747 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002748 .params = "",
2749 .help = "show migration status",
Luiz Capitulinoc86a6682009-12-10 17:16:05 -02002750 .user_print = do_info_migrate_print,
2751 .mhandler.info_new = do_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002752 },
2753 {
2754 .name = "balloon",
2755 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002756 .params = "",
2757 .help = "show balloon information",
Luiz Capitulinocc1d9c72009-10-07 13:42:03 -03002758 .user_print = monitor_print_balloon,
Adam Litke625a5be2010-01-26 14:17:35 -06002759 .mhandler.info_async = do_info_balloon,
2760 .async = 1,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002761 },
2762 {
2763 .name = "qtree",
2764 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002765 .params = "",
2766 .help = "show device tree",
Luiz Capitulino910df892009-10-07 13:41:51 -03002767 .mhandler.info = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002768 },
2769 {
2770 .name = "qdm",
2771 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002772 .params = "",
2773 .help = "show qdev device model list",
Luiz Capitulino910df892009-10-07 13:41:51 -03002774 .mhandler.info = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002775 },
2776 {
2777 .name = "roms",
2778 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002779 .params = "",
2780 .help = "show roms",
Luiz Capitulino910df892009-10-07 13:41:51 -03002781 .mhandler.info = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002782 },
2783 {
2784 .name = NULL,
2785 },
bellard9dc39cb2004-03-14 21:38:27 +00002786};
2787
bellard9307c4c2004-04-04 12:57:25 +00002788/*******************************************************************/
2789
2790static const char *pch;
2791static jmp_buf expr_env;
2792
bellard92a31b12005-02-10 22:00:52 +00002793#define MD_TLONG 0
2794#define MD_I32 1
2795
bellard9307c4c2004-04-04 12:57:25 +00002796typedef struct MonitorDef {
2797 const char *name;
2798 int offset;
blueswir18662d652008-10-02 18:32:44 +00002799 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002800 int type;
bellard9307c4c2004-04-04 12:57:25 +00002801} MonitorDef;
2802
bellard57206fd2004-04-25 18:54:52 +00002803#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002804static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002805{
bellard6a00d602005-11-21 23:25:50 +00002806 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002807 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002808}
2809#endif
2810
bellarda541f292004-04-12 20:39:29 +00002811#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002812static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002813{
bellard6a00d602005-11-21 23:25:50 +00002814 CPUState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002815 unsigned int u;
2816 int i;
2817
2818 u = 0;
2819 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002820 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002821
2822 return u;
2823}
2824
blueswir18662d652008-10-02 18:32:44 +00002825static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002826{
bellard6a00d602005-11-21 23:25:50 +00002827 CPUState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00002828 return env->msr;
bellarda541f292004-04-12 20:39:29 +00002829}
2830
blueswir18662d652008-10-02 18:32:44 +00002831static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002832{
bellard6a00d602005-11-21 23:25:50 +00002833 CPUState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00002834 return env->xer;
bellarda541f292004-04-12 20:39:29 +00002835}
bellard9fddaa02004-05-21 12:59:32 +00002836
blueswir18662d652008-10-02 18:32:44 +00002837static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002838{
bellard6a00d602005-11-21 23:25:50 +00002839 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002840 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00002841}
2842
blueswir18662d652008-10-02 18:32:44 +00002843static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002844{
bellard6a00d602005-11-21 23:25:50 +00002845 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002846 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00002847}
2848
blueswir18662d652008-10-02 18:32:44 +00002849static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002850{
bellard6a00d602005-11-21 23:25:50 +00002851 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002852 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00002853}
bellarda541f292004-04-12 20:39:29 +00002854#endif
2855
bellarde95c8d52004-09-30 22:22:08 +00002856#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00002857#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00002858static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002859{
bellard6a00d602005-11-21 23:25:50 +00002860 CPUState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00002861
2862 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00002863}
bellard7b936c02005-10-30 17:05:13 +00002864#endif
bellarde95c8d52004-09-30 22:22:08 +00002865
blueswir18662d652008-10-02 18:32:44 +00002866static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002867{
bellard6a00d602005-11-21 23:25:50 +00002868 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002869 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00002870}
2871#endif
2872
blueswir18662d652008-10-02 18:32:44 +00002873static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00002874#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00002875
2876#define SEG(name, seg) \
bellard92a31b12005-02-10 22:00:52 +00002877 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
bellard57206fd2004-04-25 18:54:52 +00002878 { name ".base", offsetof(CPUState, segs[seg].base) },\
bellard92a31b12005-02-10 22:00:52 +00002879 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00002880
bellard9307c4c2004-04-04 12:57:25 +00002881 { "eax", offsetof(CPUState, regs[0]) },
2882 { "ecx", offsetof(CPUState, regs[1]) },
2883 { "edx", offsetof(CPUState, regs[2]) },
2884 { "ebx", offsetof(CPUState, regs[3]) },
2885 { "esp|sp", offsetof(CPUState, regs[4]) },
2886 { "ebp|fp", offsetof(CPUState, regs[5]) },
2887 { "esi", offsetof(CPUState, regs[6]) },
bellard01038d22004-09-13 21:36:46 +00002888 { "edi", offsetof(CPUState, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00002889#ifdef TARGET_X86_64
2890 { "r8", offsetof(CPUState, regs[8]) },
2891 { "r9", offsetof(CPUState, regs[9]) },
2892 { "r10", offsetof(CPUState, regs[10]) },
2893 { "r11", offsetof(CPUState, regs[11]) },
2894 { "r12", offsetof(CPUState, regs[12]) },
2895 { "r13", offsetof(CPUState, regs[13]) },
2896 { "r14", offsetof(CPUState, regs[14]) },
2897 { "r15", offsetof(CPUState, regs[15]) },
2898#endif
bellard9307c4c2004-04-04 12:57:25 +00002899 { "eflags", offsetof(CPUState, eflags) },
bellard57206fd2004-04-25 18:54:52 +00002900 { "eip", offsetof(CPUState, eip) },
2901 SEG("cs", R_CS)
2902 SEG("ds", R_DS)
2903 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00002904 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00002905 SEG("fs", R_FS)
2906 SEG("gs", R_GS)
2907 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00002908#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00002909 /* General purpose registers */
bellarda541f292004-04-12 20:39:29 +00002910 { "r0", offsetof(CPUState, gpr[0]) },
2911 { "r1", offsetof(CPUState, gpr[1]) },
2912 { "r2", offsetof(CPUState, gpr[2]) },
2913 { "r3", offsetof(CPUState, gpr[3]) },
2914 { "r4", offsetof(CPUState, gpr[4]) },
2915 { "r5", offsetof(CPUState, gpr[5]) },
2916 { "r6", offsetof(CPUState, gpr[6]) },
2917 { "r7", offsetof(CPUState, gpr[7]) },
2918 { "r8", offsetof(CPUState, gpr[8]) },
2919 { "r9", offsetof(CPUState, gpr[9]) },
2920 { "r10", offsetof(CPUState, gpr[10]) },
2921 { "r11", offsetof(CPUState, gpr[11]) },
2922 { "r12", offsetof(CPUState, gpr[12]) },
2923 { "r13", offsetof(CPUState, gpr[13]) },
2924 { "r14", offsetof(CPUState, gpr[14]) },
2925 { "r15", offsetof(CPUState, gpr[15]) },
2926 { "r16", offsetof(CPUState, gpr[16]) },
2927 { "r17", offsetof(CPUState, gpr[17]) },
2928 { "r18", offsetof(CPUState, gpr[18]) },
2929 { "r19", offsetof(CPUState, gpr[19]) },
2930 { "r20", offsetof(CPUState, gpr[20]) },
2931 { "r21", offsetof(CPUState, gpr[21]) },
2932 { "r22", offsetof(CPUState, gpr[22]) },
2933 { "r23", offsetof(CPUState, gpr[23]) },
2934 { "r24", offsetof(CPUState, gpr[24]) },
2935 { "r25", offsetof(CPUState, gpr[25]) },
2936 { "r26", offsetof(CPUState, gpr[26]) },
2937 { "r27", offsetof(CPUState, gpr[27]) },
2938 { "r28", offsetof(CPUState, gpr[28]) },
2939 { "r29", offsetof(CPUState, gpr[29]) },
2940 { "r30", offsetof(CPUState, gpr[30]) },
2941 { "r31", offsetof(CPUState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00002942 /* Floating point registers */
2943 { "f0", offsetof(CPUState, fpr[0]) },
2944 { "f1", offsetof(CPUState, fpr[1]) },
2945 { "f2", offsetof(CPUState, fpr[2]) },
2946 { "f3", offsetof(CPUState, fpr[3]) },
2947 { "f4", offsetof(CPUState, fpr[4]) },
2948 { "f5", offsetof(CPUState, fpr[5]) },
2949 { "f6", offsetof(CPUState, fpr[6]) },
2950 { "f7", offsetof(CPUState, fpr[7]) },
2951 { "f8", offsetof(CPUState, fpr[8]) },
2952 { "f9", offsetof(CPUState, fpr[9]) },
2953 { "f10", offsetof(CPUState, fpr[10]) },
2954 { "f11", offsetof(CPUState, fpr[11]) },
2955 { "f12", offsetof(CPUState, fpr[12]) },
2956 { "f13", offsetof(CPUState, fpr[13]) },
2957 { "f14", offsetof(CPUState, fpr[14]) },
2958 { "f15", offsetof(CPUState, fpr[15]) },
2959 { "f16", offsetof(CPUState, fpr[16]) },
2960 { "f17", offsetof(CPUState, fpr[17]) },
2961 { "f18", offsetof(CPUState, fpr[18]) },
2962 { "f19", offsetof(CPUState, fpr[19]) },
2963 { "f20", offsetof(CPUState, fpr[20]) },
2964 { "f21", offsetof(CPUState, fpr[21]) },
2965 { "f22", offsetof(CPUState, fpr[22]) },
2966 { "f23", offsetof(CPUState, fpr[23]) },
2967 { "f24", offsetof(CPUState, fpr[24]) },
2968 { "f25", offsetof(CPUState, fpr[25]) },
2969 { "f26", offsetof(CPUState, fpr[26]) },
2970 { "f27", offsetof(CPUState, fpr[27]) },
2971 { "f28", offsetof(CPUState, fpr[28]) },
2972 { "f29", offsetof(CPUState, fpr[29]) },
2973 { "f30", offsetof(CPUState, fpr[30]) },
2974 { "f31", offsetof(CPUState, fpr[31]) },
2975 { "fpscr", offsetof(CPUState, fpscr) },
2976 /* Next instruction pointer */
bellard57206fd2004-04-25 18:54:52 +00002977 { "nip|pc", offsetof(CPUState, nip) },
bellarda541f292004-04-12 20:39:29 +00002978 { "lr", offsetof(CPUState, lr) },
2979 { "ctr", offsetof(CPUState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00002980 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00002981 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00002982 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00002983 { "msr", 0, &monitor_get_msr, },
2984 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00002985 { "tbu", 0, &monitor_get_tbu, },
2986 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00002987#if defined(TARGET_PPC64)
2988 /* Address space register */
2989 { "asr", offsetof(CPUState, asr) },
2990#endif
2991 /* Segment registers */
bellarda541f292004-04-12 20:39:29 +00002992 { "sdr1", offsetof(CPUState, sdr1) },
2993 { "sr0", offsetof(CPUState, sr[0]) },
2994 { "sr1", offsetof(CPUState, sr[1]) },
2995 { "sr2", offsetof(CPUState, sr[2]) },
2996 { "sr3", offsetof(CPUState, sr[3]) },
2997 { "sr4", offsetof(CPUState, sr[4]) },
2998 { "sr5", offsetof(CPUState, sr[5]) },
2999 { "sr6", offsetof(CPUState, sr[6]) },
3000 { "sr7", offsetof(CPUState, sr[7]) },
3001 { "sr8", offsetof(CPUState, sr[8]) },
3002 { "sr9", offsetof(CPUState, sr[9]) },
3003 { "sr10", offsetof(CPUState, sr[10]) },
3004 { "sr11", offsetof(CPUState, sr[11]) },
3005 { "sr12", offsetof(CPUState, sr[12]) },
3006 { "sr13", offsetof(CPUState, sr[13]) },
3007 { "sr14", offsetof(CPUState, sr[14]) },
3008 { "sr15", offsetof(CPUState, sr[15]) },
3009 /* Too lazy to put BATs and SPRs ... */
bellarde95c8d52004-09-30 22:22:08 +00003010#elif defined(TARGET_SPARC)
3011 { "g0", offsetof(CPUState, gregs[0]) },
3012 { "g1", offsetof(CPUState, gregs[1]) },
3013 { "g2", offsetof(CPUState, gregs[2]) },
3014 { "g3", offsetof(CPUState, gregs[3]) },
3015 { "g4", offsetof(CPUState, gregs[4]) },
3016 { "g5", offsetof(CPUState, gregs[5]) },
3017 { "g6", offsetof(CPUState, gregs[6]) },
3018 { "g7", offsetof(CPUState, gregs[7]) },
3019 { "o0", 0, monitor_get_reg },
3020 { "o1", 1, monitor_get_reg },
3021 { "o2", 2, monitor_get_reg },
3022 { "o3", 3, monitor_get_reg },
3023 { "o4", 4, monitor_get_reg },
3024 { "o5", 5, monitor_get_reg },
3025 { "o6", 6, monitor_get_reg },
3026 { "o7", 7, monitor_get_reg },
3027 { "l0", 8, monitor_get_reg },
3028 { "l1", 9, monitor_get_reg },
3029 { "l2", 10, monitor_get_reg },
3030 { "l3", 11, monitor_get_reg },
3031 { "l4", 12, monitor_get_reg },
3032 { "l5", 13, monitor_get_reg },
3033 { "l6", 14, monitor_get_reg },
3034 { "l7", 15, monitor_get_reg },
3035 { "i0", 16, monitor_get_reg },
3036 { "i1", 17, monitor_get_reg },
3037 { "i2", 18, monitor_get_reg },
3038 { "i3", 19, monitor_get_reg },
3039 { "i4", 20, monitor_get_reg },
3040 { "i5", 21, monitor_get_reg },
3041 { "i6", 22, monitor_get_reg },
3042 { "i7", 23, monitor_get_reg },
3043 { "pc", offsetof(CPUState, pc) },
3044 { "npc", offsetof(CPUState, npc) },
3045 { "y", offsetof(CPUState, y) },
bellard7b936c02005-10-30 17:05:13 +00003046#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003047 { "psr", 0, &monitor_get_psr, },
3048 { "wim", offsetof(CPUState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003049#endif
bellarde95c8d52004-09-30 22:22:08 +00003050 { "tbr", offsetof(CPUState, tbr) },
3051 { "fsr", offsetof(CPUState, fsr) },
3052 { "f0", offsetof(CPUState, fpr[0]) },
3053 { "f1", offsetof(CPUState, fpr[1]) },
3054 { "f2", offsetof(CPUState, fpr[2]) },
3055 { "f3", offsetof(CPUState, fpr[3]) },
3056 { "f4", offsetof(CPUState, fpr[4]) },
3057 { "f5", offsetof(CPUState, fpr[5]) },
3058 { "f6", offsetof(CPUState, fpr[6]) },
3059 { "f7", offsetof(CPUState, fpr[7]) },
3060 { "f8", offsetof(CPUState, fpr[8]) },
3061 { "f9", offsetof(CPUState, fpr[9]) },
3062 { "f10", offsetof(CPUState, fpr[10]) },
3063 { "f11", offsetof(CPUState, fpr[11]) },
3064 { "f12", offsetof(CPUState, fpr[12]) },
3065 { "f13", offsetof(CPUState, fpr[13]) },
3066 { "f14", offsetof(CPUState, fpr[14]) },
3067 { "f15", offsetof(CPUState, fpr[15]) },
3068 { "f16", offsetof(CPUState, fpr[16]) },
3069 { "f17", offsetof(CPUState, fpr[17]) },
3070 { "f18", offsetof(CPUState, fpr[18]) },
3071 { "f19", offsetof(CPUState, fpr[19]) },
3072 { "f20", offsetof(CPUState, fpr[20]) },
3073 { "f21", offsetof(CPUState, fpr[21]) },
3074 { "f22", offsetof(CPUState, fpr[22]) },
3075 { "f23", offsetof(CPUState, fpr[23]) },
3076 { "f24", offsetof(CPUState, fpr[24]) },
3077 { "f25", offsetof(CPUState, fpr[25]) },
3078 { "f26", offsetof(CPUState, fpr[26]) },
3079 { "f27", offsetof(CPUState, fpr[27]) },
3080 { "f28", offsetof(CPUState, fpr[28]) },
3081 { "f29", offsetof(CPUState, fpr[29]) },
3082 { "f30", offsetof(CPUState, fpr[30]) },
3083 { "f31", offsetof(CPUState, fpr[31]) },
bellard7b936c02005-10-30 17:05:13 +00003084#ifdef TARGET_SPARC64
3085 { "f32", offsetof(CPUState, fpr[32]) },
3086 { "f34", offsetof(CPUState, fpr[34]) },
3087 { "f36", offsetof(CPUState, fpr[36]) },
3088 { "f38", offsetof(CPUState, fpr[38]) },
3089 { "f40", offsetof(CPUState, fpr[40]) },
3090 { "f42", offsetof(CPUState, fpr[42]) },
3091 { "f44", offsetof(CPUState, fpr[44]) },
3092 { "f46", offsetof(CPUState, fpr[46]) },
3093 { "f48", offsetof(CPUState, fpr[48]) },
3094 { "f50", offsetof(CPUState, fpr[50]) },
3095 { "f52", offsetof(CPUState, fpr[52]) },
3096 { "f54", offsetof(CPUState, fpr[54]) },
3097 { "f56", offsetof(CPUState, fpr[56]) },
3098 { "f58", offsetof(CPUState, fpr[58]) },
3099 { "f60", offsetof(CPUState, fpr[60]) },
3100 { "f62", offsetof(CPUState, fpr[62]) },
3101 { "asi", offsetof(CPUState, asi) },
3102 { "pstate", offsetof(CPUState, pstate) },
3103 { "cansave", offsetof(CPUState, cansave) },
3104 { "canrestore", offsetof(CPUState, canrestore) },
3105 { "otherwin", offsetof(CPUState, otherwin) },
3106 { "wstate", offsetof(CPUState, wstate) },
3107 { "cleanwin", offsetof(CPUState, cleanwin) },
3108 { "fprs", offsetof(CPUState, fprs) },
3109#endif
bellard9307c4c2004-04-04 12:57:25 +00003110#endif
3111 { NULL },
3112};
3113
aliguori376253e2009-03-05 23:01:23 +00003114static void expr_error(Monitor *mon, const char *msg)
bellard9dc39cb2004-03-14 21:38:27 +00003115{
aliguori376253e2009-03-05 23:01:23 +00003116 monitor_printf(mon, "%s\n", msg);
bellard9307c4c2004-04-04 12:57:25 +00003117 longjmp(expr_env, 1);
3118}
3119
Markus Armbruster09b94182010-01-20 13:07:30 +01003120/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003121static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003122{
blueswir18662d652008-10-02 18:32:44 +00003123 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003124 void *ptr;
3125
bellard9307c4c2004-04-04 12:57:25 +00003126 for(md = monitor_defs; md->name != NULL; md++) {
3127 if (compare_cmd(name, md->name)) {
3128 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003129 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003130 } else {
bellard6a00d602005-11-21 23:25:50 +00003131 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003132 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003133 switch(md->type) {
3134 case MD_I32:
3135 *pval = *(int32_t *)ptr;
3136 break;
3137 case MD_TLONG:
3138 *pval = *(target_long *)ptr;
3139 break;
3140 default:
3141 *pval = 0;
3142 break;
3143 }
bellard9307c4c2004-04-04 12:57:25 +00003144 }
3145 return 0;
3146 }
3147 }
3148 return -1;
3149}
3150
3151static void next(void)
3152{
Blue Swirl660f11b2009-07-31 21:16:51 +00003153 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003154 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003155 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003156 pch++;
3157 }
3158}
3159
aliguori376253e2009-03-05 23:01:23 +00003160static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003161
aliguori376253e2009-03-05 23:01:23 +00003162static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003163{
blueswir1c2efc952007-09-25 17:28:42 +00003164 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003165 char *p;
bellard6a00d602005-11-21 23:25:50 +00003166 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003167
3168 switch(*pch) {
3169 case '+':
3170 next();
aliguori376253e2009-03-05 23:01:23 +00003171 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003172 break;
3173 case '-':
3174 next();
aliguori376253e2009-03-05 23:01:23 +00003175 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003176 break;
3177 case '~':
3178 next();
aliguori376253e2009-03-05 23:01:23 +00003179 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003180 break;
3181 case '(':
3182 next();
aliguori376253e2009-03-05 23:01:23 +00003183 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003184 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003185 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003186 }
3187 next();
3188 break;
bellard81d09122004-07-14 17:21:37 +00003189 case '\'':
3190 pch++;
3191 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003192 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003193 n = *pch;
3194 pch++;
3195 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003196 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003197 next();
3198 break;
bellard9307c4c2004-04-04 12:57:25 +00003199 case '$':
3200 {
3201 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003202 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003203
bellard9307c4c2004-04-04 12:57:25 +00003204 pch++;
3205 q = buf;
3206 while ((*pch >= 'a' && *pch <= 'z') ||
3207 (*pch >= 'A' && *pch <= 'Z') ||
3208 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003209 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003210 if ((q - buf) < sizeof(buf) - 1)
3211 *q++ = *pch;
3212 pch++;
3213 }
blueswir1cd390082008-11-16 13:53:32 +00003214 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003215 pch++;
3216 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003217 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003218 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003219 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003220 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003221 }
3222 break;
3223 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003224 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003225 n = 0;
3226 break;
3227 default:
blueswir17743e582007-09-24 18:39:04 +00003228#if TARGET_PHYS_ADDR_BITS > 32
bellard4f4fbf72006-06-25 18:28:12 +00003229 n = strtoull(pch, &p, 0);
3230#else
bellard9307c4c2004-04-04 12:57:25 +00003231 n = strtoul(pch, &p, 0);
bellard4f4fbf72006-06-25 18:28:12 +00003232#endif
bellard9307c4c2004-04-04 12:57:25 +00003233 if (pch == p) {
aliguori376253e2009-03-05 23:01:23 +00003234 expr_error(mon, "invalid char in expression");
bellard9307c4c2004-04-04 12:57:25 +00003235 }
3236 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003237 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003238 pch++;
3239 break;
3240 }
3241 return n;
3242}
3243
3244
aliguori376253e2009-03-05 23:01:23 +00003245static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003246{
blueswir1c2efc952007-09-25 17:28:42 +00003247 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003248 int op;
ths3b46e622007-09-17 08:09:54 +00003249
aliguori376253e2009-03-05 23:01:23 +00003250 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003251 for(;;) {
3252 op = *pch;
3253 if (op != '*' && op != '/' && op != '%')
3254 break;
3255 next();
aliguori376253e2009-03-05 23:01:23 +00003256 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003257 switch(op) {
3258 default:
3259 case '*':
3260 val *= val2;
3261 break;
3262 case '/':
3263 case '%':
ths5fafdf22007-09-16 21:08:06 +00003264 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003265 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003266 if (op == '/')
3267 val /= val2;
3268 else
3269 val %= val2;
3270 break;
3271 }
3272 }
3273 return val;
3274}
3275
aliguori376253e2009-03-05 23:01:23 +00003276static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003277{
blueswir1c2efc952007-09-25 17:28:42 +00003278 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003279 int op;
bellard9307c4c2004-04-04 12:57:25 +00003280
aliguori376253e2009-03-05 23:01:23 +00003281 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003282 for(;;) {
3283 op = *pch;
3284 if (op != '&' && op != '|' && op != '^')
3285 break;
3286 next();
aliguori376253e2009-03-05 23:01:23 +00003287 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003288 switch(op) {
3289 default:
3290 case '&':
3291 val &= val2;
3292 break;
3293 case '|':
3294 val |= val2;
3295 break;
3296 case '^':
3297 val ^= val2;
3298 break;
3299 }
3300 }
3301 return val;
3302}
3303
aliguori376253e2009-03-05 23:01:23 +00003304static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003305{
blueswir1c2efc952007-09-25 17:28:42 +00003306 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003307 int op;
bellard9307c4c2004-04-04 12:57:25 +00003308
aliguori376253e2009-03-05 23:01:23 +00003309 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003310 for(;;) {
3311 op = *pch;
3312 if (op != '+' && op != '-')
3313 break;
3314 next();
aliguori376253e2009-03-05 23:01:23 +00003315 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003316 if (op == '+')
3317 val += val2;
3318 else
3319 val -= val2;
3320 }
3321 return val;
3322}
3323
aliguori376253e2009-03-05 23:01:23 +00003324static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003325{
3326 pch = *pp;
3327 if (setjmp(expr_env)) {
3328 *pp = pch;
3329 return -1;
3330 }
blueswir1cd390082008-11-16 13:53:32 +00003331 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003332 pch++;
aliguori376253e2009-03-05 23:01:23 +00003333 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003334 *pp = pch;
3335 return 0;
3336}
3337
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003338static int get_double(Monitor *mon, double *pval, const char **pp)
3339{
3340 const char *p = *pp;
3341 char *tailp;
3342 double d;
3343
3344 d = strtod(p, &tailp);
3345 if (tailp == p) {
3346 monitor_printf(mon, "Number expected\n");
3347 return -1;
3348 }
3349 if (d != d || d - d != 0) {
3350 /* NaN or infinity */
3351 monitor_printf(mon, "Bad number\n");
3352 return -1;
3353 }
3354 *pval = d;
3355 *pp = tailp;
3356 return 0;
3357}
3358
bellard9307c4c2004-04-04 12:57:25 +00003359static int get_str(char *buf, int buf_size, const char **pp)
3360{
3361 const char *p;
3362 char *q;
3363 int c;
3364
bellard81d09122004-07-14 17:21:37 +00003365 q = buf;
bellard9307c4c2004-04-04 12:57:25 +00003366 p = *pp;
blueswir1cd390082008-11-16 13:53:32 +00003367 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003368 p++;
3369 if (*p == '\0') {
3370 fail:
bellard81d09122004-07-14 17:21:37 +00003371 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003372 *pp = p;
3373 return -1;
3374 }
bellard9307c4c2004-04-04 12:57:25 +00003375 if (*p == '\"') {
3376 p++;
3377 while (*p != '\0' && *p != '\"') {
3378 if (*p == '\\') {
3379 p++;
3380 c = *p++;
3381 switch(c) {
3382 case 'n':
3383 c = '\n';
3384 break;
3385 case 'r':
3386 c = '\r';
3387 break;
3388 case '\\':
3389 case '\'':
3390 case '\"':
3391 break;
3392 default:
3393 qemu_printf("unsupported escape code: '\\%c'\n", c);
3394 goto fail;
3395 }
3396 if ((q - buf) < buf_size - 1) {
3397 *q++ = c;
3398 }
3399 } else {
3400 if ((q - buf) < buf_size - 1) {
3401 *q++ = *p;
3402 }
3403 p++;
3404 }
3405 }
3406 if (*p != '\"') {
bellard5b602122004-05-22 21:41:05 +00003407 qemu_printf("unterminated string\n");
bellard9307c4c2004-04-04 12:57:25 +00003408 goto fail;
3409 }
3410 p++;
3411 } else {
blueswir1cd390082008-11-16 13:53:32 +00003412 while (*p != '\0' && !qemu_isspace(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003413 if ((q - buf) < buf_size - 1) {
3414 *q++ = *p;
3415 }
3416 p++;
3417 }
bellard9307c4c2004-04-04 12:57:25 +00003418 }
bellard81d09122004-07-14 17:21:37 +00003419 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003420 *pp = p;
3421 return 0;
3422}
3423
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003424/*
3425 * Store the command-name in cmdname, and return a pointer to
3426 * the remaining of the command string.
3427 */
3428static const char *get_command_name(const char *cmdline,
3429 char *cmdname, size_t nlen)
3430{
3431 size_t len;
3432 const char *p, *pstart;
3433
3434 p = cmdline;
3435 while (qemu_isspace(*p))
3436 p++;
3437 if (*p == '\0')
3438 return NULL;
3439 pstart = p;
3440 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3441 p++;
3442 len = p - pstart;
3443 if (len > nlen - 1)
3444 len = nlen - 1;
3445 memcpy(cmdname, pstart, len);
3446 cmdname[len] = '\0';
3447 return p;
3448}
3449
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003450/**
3451 * Read key of 'type' into 'key' and return the current
3452 * 'type' pointer.
3453 */
3454static char *key_get_info(const char *type, char **key)
3455{
3456 size_t len;
3457 char *p, *str;
3458
3459 if (*type == ',')
3460 type++;
3461
3462 p = strchr(type, ':');
3463 if (!p) {
3464 *key = NULL;
3465 return NULL;
3466 }
3467 len = p - type;
3468
3469 str = qemu_malloc(len + 1);
3470 memcpy(str, type, len);
3471 str[len] = '\0';
3472
3473 *key = str;
3474 return ++p;
3475}
3476
bellard9307c4c2004-04-04 12:57:25 +00003477static int default_fmt_format = 'x';
3478static int default_fmt_size = 4;
3479
3480#define MAX_ARGS 16
3481
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003482static int is_valid_option(const char *c, const char *typestr)
3483{
3484 char option[3];
3485
3486 option[0] = '-';
3487 option[1] = *c;
3488 option[2] = '\0';
3489
3490 typestr = strstr(typestr, option);
3491 return (typestr != NULL);
3492}
3493
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003494static const mon_cmd_t *monitor_find_command(const char *cmdname)
3495{
3496 const mon_cmd_t *cmd;
3497
3498 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3499 if (compare_cmd(cmdname, cmd->name)) {
3500 return cmd;
3501 }
3502 }
3503
3504 return NULL;
3505}
3506
Anthony Liguoric227f092009-10-01 16:12:16 -05003507static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003508 const char *cmdline,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003509 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003510{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003511 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003512 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003513 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003514 char cmdname[256];
3515 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003516 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003517
3518#ifdef DEBUG
aliguori376253e2009-03-05 23:01:23 +00003519 monitor_printf(mon, "command='%s'\n", cmdline);
bellard9dc39cb2004-03-14 21:38:27 +00003520#endif
ths3b46e622007-09-17 08:09:54 +00003521
bellard9307c4c2004-04-04 12:57:25 +00003522 /* extract the command name */
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003523 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3524 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003525 return NULL;
ths3b46e622007-09-17 08:09:54 +00003526
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003527 cmd = monitor_find_command(cmdname);
3528 if (!cmd) {
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003529 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003530 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003531 }
bellard9307c4c2004-04-04 12:57:25 +00003532
bellard9307c4c2004-04-04 12:57:25 +00003533 /* parse the parameters */
3534 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003535 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003536 typestr = key_get_info(typestr, &key);
3537 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003538 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003539 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003540 typestr++;
3541 switch(c) {
3542 case 'F':
bellard81d09122004-07-14 17:21:37 +00003543 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003544 case 's':
3545 {
3546 int ret;
ths3b46e622007-09-17 08:09:54 +00003547
blueswir1cd390082008-11-16 13:53:32 +00003548 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003549 p++;
3550 if (*typestr == '?') {
3551 typestr++;
3552 if (*p == '\0') {
3553 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003554 break;
bellard9307c4c2004-04-04 12:57:25 +00003555 }
3556 }
3557 ret = get_str(buf, sizeof(buf), &p);
3558 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003559 switch(c) {
3560 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003561 monitor_printf(mon, "%s: filename expected\n",
3562 cmdname);
bellard81d09122004-07-14 17:21:37 +00003563 break;
3564 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003565 monitor_printf(mon, "%s: block device name expected\n",
3566 cmdname);
bellard81d09122004-07-14 17:21:37 +00003567 break;
3568 default:
aliguori376253e2009-03-05 23:01:23 +00003569 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003570 break;
3571 }
bellard9307c4c2004-04-04 12:57:25 +00003572 goto fail;
3573 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003574 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003575 }
3576 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003577 case 'O':
3578 {
3579 QemuOptsList *opts_list;
3580 QemuOpts *opts;
3581
3582 opts_list = qemu_find_opts(key);
3583 if (!opts_list || opts_list->desc->name) {
3584 goto bad_type;
3585 }
3586 while (qemu_isspace(*p)) {
3587 p++;
3588 }
3589 if (!*p)
3590 break;
3591 if (get_str(buf, sizeof(buf), &p) < 0) {
3592 goto fail;
3593 }
3594 opts = qemu_opts_parse(opts_list, buf, 1);
3595 if (!opts) {
3596 goto fail;
3597 }
3598 qemu_opts_to_qdict(opts, qdict);
3599 qemu_opts_del(opts);
3600 }
3601 break;
bellard9307c4c2004-04-04 12:57:25 +00003602 case '/':
3603 {
3604 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003605
blueswir1cd390082008-11-16 13:53:32 +00003606 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003607 p++;
3608 if (*p == '/') {
3609 /* format found */
3610 p++;
3611 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003612 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003613 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003614 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003615 count = count * 10 + (*p - '0');
3616 p++;
3617 }
3618 }
3619 size = -1;
3620 format = -1;
3621 for(;;) {
3622 switch(*p) {
3623 case 'o':
3624 case 'd':
3625 case 'u':
3626 case 'x':
3627 case 'i':
3628 case 'c':
3629 format = *p++;
3630 break;
3631 case 'b':
3632 size = 1;
3633 p++;
3634 break;
3635 case 'h':
3636 size = 2;
3637 p++;
3638 break;
3639 case 'w':
3640 size = 4;
3641 p++;
3642 break;
3643 case 'g':
3644 case 'L':
3645 size = 8;
3646 p++;
3647 break;
3648 default:
3649 goto next;
3650 }
3651 }
3652 next:
blueswir1cd390082008-11-16 13:53:32 +00003653 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003654 monitor_printf(mon, "invalid char in format: '%c'\n",
3655 *p);
bellard9307c4c2004-04-04 12:57:25 +00003656 goto fail;
3657 }
bellard9307c4c2004-04-04 12:57:25 +00003658 if (format < 0)
3659 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003660 if (format != 'i') {
3661 /* for 'i', not specifying a size gives -1 as size */
3662 if (size < 0)
3663 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003664 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003665 }
bellard9307c4c2004-04-04 12:57:25 +00003666 default_fmt_format = format;
3667 } else {
3668 count = 1;
3669 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003670 if (format != 'i') {
3671 size = default_fmt_size;
3672 } else {
3673 size = -1;
3674 }
bellard9307c4c2004-04-04 12:57:25 +00003675 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003676 qdict_put(qdict, "count", qint_from_int(count));
3677 qdict_put(qdict, "format", qint_from_int(format));
3678 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003679 }
3680 break;
3681 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003682 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003683 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003684 {
blueswir1c2efc952007-09-25 17:28:42 +00003685 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003686
blueswir1cd390082008-11-16 13:53:32 +00003687 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003688 p++;
bellard34405572004-06-08 00:55:58 +00003689 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003690 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003691 if (*p == '\0') {
3692 typestr++;
3693 break;
3694 }
bellard34405572004-06-08 00:55:58 +00003695 } else {
3696 if (*p == '.') {
3697 p++;
blueswir1cd390082008-11-16 13:53:32 +00003698 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003699 p++;
bellard34405572004-06-08 00:55:58 +00003700 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003701 typestr++;
3702 break;
bellard34405572004-06-08 00:55:58 +00003703 }
3704 }
bellard13224a82006-07-14 22:03:35 +00003705 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003706 }
aliguori376253e2009-03-05 23:01:23 +00003707 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003708 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003709 /* Check if 'i' is greater than 32-bit */
3710 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3711 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3712 monitor_printf(mon, "integer is for 32-bit values\n");
3713 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003714 } else if (c == 'M') {
3715 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003716 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003717 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003718 }
3719 break;
Markus Armbrusteree9545d2010-03-26 09:07:08 +01003720 case 'f':
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003721 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003722 {
3723 double val;
3724
3725 while (qemu_isspace(*p))
3726 p++;
3727 if (*typestr == '?') {
3728 typestr++;
3729 if (*p == '\0') {
3730 break;
3731 }
3732 }
3733 if (get_double(mon, &val, &p) < 0) {
3734 goto fail;
3735 }
Markus Armbrusteree9545d2010-03-26 09:07:08 +01003736 if (c == 'f' && *p) {
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003737 switch (*p) {
3738 case 'K': case 'k':
3739 val *= 1 << 10; p++; break;
3740 case 'M': case 'm':
3741 val *= 1 << 20; p++; break;
3742 case 'G': case 'g':
3743 val *= 1 << 30; p++; break;
3744 }
3745 }
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003746 if (c == 'T' && p[0] && p[1] == 's') {
3747 switch (*p) {
3748 case 'm':
3749 val /= 1e3; p += 2; break;
3750 case 'u':
3751 val /= 1e6; p += 2; break;
3752 case 'n':
3753 val /= 1e9; p += 2; break;
3754 }
3755 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003756 if (*p && !qemu_isspace(*p)) {
3757 monitor_printf(mon, "Unknown unit suffix\n");
3758 goto fail;
3759 }
3760 qdict_put(qdict, key, qfloat_from_double(val));
3761 }
3762 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003763 case 'b':
3764 {
3765 const char *beg;
3766 int val;
3767
3768 while (qemu_isspace(*p)) {
3769 p++;
3770 }
3771 beg = p;
3772 while (qemu_isgraph(*p)) {
3773 p++;
3774 }
3775 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3776 val = 1;
3777 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3778 val = 0;
3779 } else {
3780 monitor_printf(mon, "Expected 'on' or 'off'\n");
3781 goto fail;
3782 }
3783 qdict_put(qdict, key, qbool_from_int(val));
3784 }
3785 break;
bellard9307c4c2004-04-04 12:57:25 +00003786 case '-':
3787 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003788 const char *tmp = p;
3789 int has_option, skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00003790 /* option */
ths3b46e622007-09-17 08:09:54 +00003791
bellard9307c4c2004-04-04 12:57:25 +00003792 c = *typestr++;
3793 if (c == '\0')
3794 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00003795 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003796 p++;
3797 has_option = 0;
3798 if (*p == '-') {
3799 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003800 if(c != *p) {
3801 if(!is_valid_option(p, typestr)) {
3802
3803 monitor_printf(mon, "%s: unsupported option -%c\n",
3804 cmdname, *p);
3805 goto fail;
3806 } else {
3807 skip_key = 1;
3808 }
bellard9307c4c2004-04-04 12:57:25 +00003809 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003810 if(skip_key) {
3811 p = tmp;
3812 } else {
3813 p++;
3814 has_option = 1;
3815 }
bellard9307c4c2004-04-04 12:57:25 +00003816 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003817 qdict_put(qdict, key, qint_from_int(has_option));
bellard9307c4c2004-04-04 12:57:25 +00003818 }
3819 break;
3820 default:
3821 bad_type:
aliguori376253e2009-03-05 23:01:23 +00003822 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00003823 goto fail;
3824 }
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003825 qemu_free(key);
3826 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00003827 }
3828 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00003829 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003830 p++;
3831 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00003832 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3833 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00003834 goto fail;
3835 }
3836
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003837 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02003838
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003839fail:
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003840 qemu_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003841 return NULL;
3842}
3843
Markus Armbrusterd6f46832010-02-17 10:52:26 +01003844void monitor_set_error(Monitor *mon, QError *qerror)
3845{
3846 /* report only the first error */
3847 if (!mon->error) {
3848 mon->error = qerror;
3849 } else {
3850 MON_DEBUG("Additional error report at %s:%d\n",
3851 qerror->file, qerror->linenr);
3852 QDECREF(qerror);
3853 }
3854}
3855
Adam Litke940cc302010-01-25 12:18:44 -06003856static int is_async_return(const QObject *data)
3857{
Luiz Capitulino82617d72010-01-27 18:01:17 -02003858 if (data && qobject_type(data) == QTYPE_QDICT) {
3859 return qdict_haskey(qobject_to_qdict(data), "__mon_async");
3860 }
3861
3862 return 0;
Adam Litke940cc302010-01-25 12:18:44 -06003863}
3864
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003865static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3866{
Markus Armbrustercde0fc72010-03-02 14:56:34 +01003867 if (monitor_ctrl_mode(mon)) {
3868 if (ret && !monitor_has_error(mon)) {
3869 /*
3870 * If it returns failure, it must have passed on error.
3871 *
3872 * Action: Report an internal error to the client if in QMP.
3873 */
Markus Armbrusterab5b0272010-03-02 18:15:09 +01003874 qerror_report(QERR_UNDEFINED_ERROR);
Markus Armbrustercde0fc72010-03-02 14:56:34 +01003875 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
3876 cmd->name);
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003877 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003878
3879#ifdef CONFIG_DEBUG_MONITOR
Markus Armbrustercde0fc72010-03-02 14:56:34 +01003880 if (!ret && monitor_has_error(mon)) {
3881 /*
3882 * If it returns success, it must not have passed an error.
3883 *
3884 * Action: Report the passed error to the client.
3885 */
3886 MON_DEBUG("command '%s' returned success but passed an error\n",
3887 cmd->name);
3888 }
Luiz Capitulino10e4f602010-02-10 23:50:06 -02003889
Markus Armbrustercde0fc72010-03-02 14:56:34 +01003890 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
3891 /*
3892 * Handlers should not call Monitor print functions.
3893 *
3894 * Action: Ignore them in QMP.
3895 *
3896 * (XXX: we don't check any 'info' or 'query' command here
3897 * because the user print function _is_ called by do_info(), hence
3898 * we will trigger this check. This problem will go away when we
3899 * make 'query' commands real and kill do_info())
3900 */
3901 MON_DEBUG("command '%s' called print functions %d time(s)\n",
3902 cmd->name, mon_print_count_get(mon));
3903 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003904#endif
Markus Armbrustercde0fc72010-03-02 14:56:34 +01003905 } else {
3906 assert(!monitor_has_error(mon));
3907 QDECREF(mon->error);
3908 mon->error = NULL;
3909 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003910}
3911
Luiz Capitulino99e2fc12009-11-26 22:58:53 -02003912static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3913 const QDict *params)
3914{
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003915 int ret;
Luiz Capitulino99e2fc12009-11-26 22:58:53 -02003916 QObject *data = NULL;
3917
Luiz Capitulino10e4f602010-02-10 23:50:06 -02003918 mon_print_count_init(mon);
3919
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003920 ret = cmd->mhandler.cmd_new(mon, params, &data);
3921 handler_audit(mon, cmd, ret);
Luiz Capitulino25b422e2009-11-26 22:58:59 -02003922
Adam Litke940cc302010-01-25 12:18:44 -06003923 if (is_async_return(data)) {
3924 /*
3925 * Asynchronous commands have no initial return data but they can
3926 * generate errors. Data is returned via the async completion handler.
3927 */
3928 if (monitor_ctrl_mode(mon) && monitor_has_error(mon)) {
3929 monitor_protocol_emitter(mon, NULL);
3930 }
3931 } else if (monitor_ctrl_mode(mon)) {
Luiz Capitulino25b422e2009-11-26 22:58:59 -02003932 /* Monitor Protocol */
3933 monitor_protocol_emitter(mon, data);
3934 } else {
3935 /* User Protocol */
3936 if (data)
3937 cmd->user_print(mon, data);
3938 }
Luiz Capitulino99e2fc12009-11-26 22:58:53 -02003939
3940 qobject_decref(data);
3941}
3942
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02003943static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003944{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003945 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05003946 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003947
3948 qdict = qdict_new();
3949
Luiz Capitulino590fb3b2009-08-28 15:27:24 -03003950 cmd = monitor_parse_command(mon, cmdline, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03003951 if (!cmd)
3952 goto out;
3953
Adam Litke940cc302010-01-25 12:18:44 -06003954 if (monitor_handler_is_async(cmd)) {
3955 user_async_cmd_handler(mon, cmd, qdict);
3956 } else if (monitor_handler_ported(cmd)) {
Luiz Capitulino99e2fc12009-11-26 22:58:53 -02003957 monitor_call_handler(mon, cmd, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03003958 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03003959 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003960 }
3961
Luiz Capitulino13917be2009-10-07 13:41:54 -03003962out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003963 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00003964}
3965
bellard81d09122004-07-14 17:21:37 +00003966static void cmd_completion(const char *name, const char *list)
3967{
3968 const char *p, *pstart;
3969 char cmd[128];
3970 int len;
3971
3972 p = list;
3973 for(;;) {
3974 pstart = p;
3975 p = strchr(p, '|');
3976 if (!p)
3977 p = pstart + strlen(pstart);
3978 len = p - pstart;
3979 if (len > sizeof(cmd) - 2)
3980 len = sizeof(cmd) - 2;
3981 memcpy(cmd, pstart, len);
3982 cmd[len] = '\0';
3983 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
aliguori731b0362009-03-05 23:01:42 +00003984 readline_add_completion(cur_mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00003985 }
3986 if (*p == '\0')
3987 break;
3988 p++;
3989 }
3990}
3991
3992static void file_completion(const char *input)
3993{
3994 DIR *ffs;
3995 struct dirent *d;
3996 char path[1024];
3997 char file[1024], file_prefix[1024];
3998 int input_path_len;
3999 const char *p;
4000
ths5fafdf22007-09-16 21:08:06 +00004001 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004002 if (!p) {
4003 input_path_len = 0;
4004 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004005 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004006 } else {
4007 input_path_len = p - input + 1;
4008 memcpy(path, input, input_path_len);
4009 if (input_path_len > sizeof(path) - 1)
4010 input_path_len = sizeof(path) - 1;
4011 path[input_path_len] = '\0';
4012 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4013 }
4014#ifdef DEBUG_COMPLETION
aliguori376253e2009-03-05 23:01:23 +00004015 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4016 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004017#endif
4018 ffs = opendir(path);
4019 if (!ffs)
4020 return;
4021 for(;;) {
4022 struct stat sb;
4023 d = readdir(ffs);
4024 if (!d)
4025 break;
4026 if (strstart(d->d_name, file_prefix, NULL)) {
4027 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004028 if (input_path_len < sizeof(file))
4029 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4030 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004031 /* stat the file to find out if it's a directory.
4032 * In that case add a slash to speed up typing long paths
4033 */
4034 stat(file, &sb);
4035 if(S_ISDIR(sb.st_mode))
blueswir1363a37d2008-08-21 17:58:08 +00004036 pstrcat(file, sizeof(file), "/");
aliguori731b0362009-03-05 23:01:42 +00004037 readline_add_completion(cur_mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004038 }
4039 }
4040 closedir(ffs);
4041}
4042
aliguori51de9762009-03-05 23:00:43 +00004043static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004044{
aliguori51de9762009-03-05 23:00:43 +00004045 const char *name = bdrv_get_device_name(bs);
bellard81d09122004-07-14 17:21:37 +00004046 const char *input = opaque;
4047
4048 if (input[0] == '\0' ||
4049 !strncmp(name, (char *)input, strlen(input))) {
aliguori731b0362009-03-05 23:01:42 +00004050 readline_add_completion(cur_mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004051 }
4052}
4053
4054/* NOTE: this parser is an approximate form of the real command parser */
4055static void parse_cmdline(const char *cmdline,
4056 int *pnb_args, char **args)
4057{
4058 const char *p;
4059 int nb_args, ret;
4060 char buf[1024];
4061
4062 p = cmdline;
4063 nb_args = 0;
4064 for(;;) {
blueswir1cd390082008-11-16 13:53:32 +00004065 while (qemu_isspace(*p))
bellard81d09122004-07-14 17:21:37 +00004066 p++;
4067 if (*p == '\0')
4068 break;
4069 if (nb_args >= MAX_ARGS)
4070 break;
4071 ret = get_str(buf, sizeof(buf), &p);
4072 args[nb_args] = qemu_strdup(buf);
4073 nb_args++;
4074 if (ret < 0)
4075 break;
4076 }
4077 *pnb_args = nb_args;
4078}
4079
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004080static const char *next_arg_type(const char *typestr)
4081{
4082 const char *p = strchr(typestr, ':');
4083 return (p != NULL ? ++p : typestr);
4084}
4085
aliguori4c36ba32009-03-05 23:01:37 +00004086static void monitor_find_completion(const char *cmdline)
bellard81d09122004-07-14 17:21:37 +00004087{
4088 const char *cmdname;
4089 char *args[MAX_ARGS];
4090 int nb_args, i, len;
4091 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004092 const mon_cmd_t *cmd;
bellard64866c32006-05-07 18:03:31 +00004093 const KeyDef *key;
bellard81d09122004-07-14 17:21:37 +00004094
4095 parse_cmdline(cmdline, &nb_args, args);
4096#ifdef DEBUG_COMPLETION
4097 for(i = 0; i < nb_args; i++) {
aliguori376253e2009-03-05 23:01:23 +00004098 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard81d09122004-07-14 17:21:37 +00004099 }
4100#endif
4101
4102 /* if the line ends with a space, it means we want to complete the
4103 next arg */
4104 len = strlen(cmdline);
blueswir1cd390082008-11-16 13:53:32 +00004105 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
bellard81d09122004-07-14 17:21:37 +00004106 if (nb_args >= MAX_ARGS)
4107 return;
4108 args[nb_args++] = qemu_strdup("");
4109 }
4110 if (nb_args <= 1) {
4111 /* command completion */
4112 if (nb_args == 0)
4113 cmdname = "";
4114 else
4115 cmdname = args[0];
aliguori731b0362009-03-05 23:01:42 +00004116 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
aliguori376253e2009-03-05 23:01:23 +00004117 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004118 cmd_completion(cmdname, cmd->name);
4119 }
4120 } else {
4121 /* find the command */
aliguori376253e2009-03-05 23:01:23 +00004122 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004123 if (compare_cmd(args[0], cmd->name))
4124 goto found;
4125 }
4126 return;
4127 found:
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004128 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004129 for(i = 0; i < nb_args - 2; i++) {
4130 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004131 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004132 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004133 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004134 }
4135 }
4136 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004137 if (*ptype == '-' && ptype[1] != '\0') {
4138 ptype += 2;
4139 }
bellard81d09122004-07-14 17:21:37 +00004140 switch(*ptype) {
4141 case 'F':
4142 /* file completion */
aliguori731b0362009-03-05 23:01:42 +00004143 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004144 file_completion(str);
4145 break;
4146 case 'B':
4147 /* block device name completion */
aliguori731b0362009-03-05 23:01:42 +00004148 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004149 bdrv_iterate(block_completion_it, (void *)str);
4150 break;
bellard7fe48482004-10-09 18:08:01 +00004151 case 's':
4152 /* XXX: more generic ? */
4153 if (!strcmp(cmd->name, "info")) {
aliguori731b0362009-03-05 23:01:42 +00004154 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard7fe48482004-10-09 18:08:01 +00004155 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4156 cmd_completion(str, cmd->name);
4157 }
bellard64866c32006-05-07 18:03:31 +00004158 } else if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004159 char *sep = strrchr(str, '-');
4160 if (sep)
4161 str = sep + 1;
aliguori731b0362009-03-05 23:01:42 +00004162 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard64866c32006-05-07 18:03:31 +00004163 for(key = key_defs; key->name != NULL; key++) {
4164 cmd_completion(str, key->name);
4165 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004166 } else if (!strcmp(cmd->name, "help|?")) {
4167 readline_set_completion_index(cur_mon->rs, strlen(str));
4168 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4169 cmd_completion(str, cmd->name);
4170 }
bellard7fe48482004-10-09 18:08:01 +00004171 }
4172 break;
bellard81d09122004-07-14 17:21:37 +00004173 default:
4174 break;
4175 }
4176 }
4177 for(i = 0; i < nb_args; i++)
4178 qemu_free(args[i]);
4179}
4180
aliguori731b0362009-03-05 23:01:42 +00004181static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004182{
aliguori731b0362009-03-05 23:01:42 +00004183 Monitor *mon = opaque;
4184
Jan Kiszkac62313b2009-12-04 14:05:29 +01004185 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004186}
4187
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004188typedef struct CmdArgs {
4189 QString *name;
4190 int type;
4191 int flag;
4192 int optional;
4193} CmdArgs;
4194
4195static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
4196{
4197 if (!cmd_args->optional) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004198 qerror_report(QERR_MISSING_PARAMETER, name);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004199 return -1;
4200 }
4201
4202 if (cmd_args->type == '-') {
4203 /* handlers expect a value, they need to be changed */
4204 qdict_put(args, name, qint_from_int(0));
4205 }
4206
4207 return 0;
4208}
4209
4210static int check_arg(const CmdArgs *cmd_args, QDict *args)
4211{
4212 QObject *value;
4213 const char *name;
4214
4215 name = qstring_get_str(cmd_args->name);
4216
4217 if (!args) {
4218 return check_opt(cmd_args, name, args);
4219 }
4220
4221 value = qdict_get(args, name);
4222 if (!value) {
4223 return check_opt(cmd_args, name, args);
4224 }
4225
4226 switch (cmd_args->type) {
4227 case 'F':
4228 case 'B':
4229 case 's':
4230 if (qobject_type(value) != QTYPE_QSTRING) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004231 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "string");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004232 return -1;
4233 }
4234 break;
4235 case '/': {
4236 int i;
4237 const char *keys[] = { "count", "format", "size", NULL };
4238
4239 for (i = 0; keys[i]; i++) {
4240 QObject *obj = qdict_get(args, keys[i]);
4241 if (!obj) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004242 qerror_report(QERR_MISSING_PARAMETER, name);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004243 return -1;
4244 }
4245 if (qobject_type(obj) != QTYPE_QINT) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004246 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004247 return -1;
4248 }
4249 }
4250 break;
4251 }
4252 case 'i':
4253 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02004254 case 'M':
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004255 if (qobject_type(value) != QTYPE_QINT) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004256 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004257 return -1;
4258 }
4259 break;
Markus Armbrusteree9545d2010-03-26 09:07:08 +01004260 case 'f':
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01004261 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01004262 if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004263 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "number");
Markus Armbruster3350a4d2010-01-25 14:23:03 +01004264 return -1;
4265 }
4266 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01004267 case 'b':
4268 if (qobject_type(value) != QTYPE_QBOOL) {
4269 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
4270 return -1;
4271 }
4272 break;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004273 case '-':
4274 if (qobject_type(value) != QTYPE_QINT &&
4275 qobject_type(value) != QTYPE_QBOOL) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004276 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004277 return -1;
4278 }
4279 if (qobject_type(value) == QTYPE_QBOOL) {
4280 /* handlers expect a QInt, they need to be changed */
4281 qdict_put(args, name,
4282 qint_from_int(qbool_get_int(qobject_to_qbool(value))));
4283 }
4284 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01004285 case 'O':
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004286 default:
4287 /* impossible */
4288 abort();
4289 }
4290
4291 return 0;
4292}
4293
4294static void cmd_args_init(CmdArgs *cmd_args)
4295{
4296 cmd_args->name = qstring_new();
4297 cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
4298}
4299
Markus Armbruster361127d2010-02-10 20:24:35 +01004300static int check_opts(QemuOptsList *opts_list, QDict *args)
4301{
4302 assert(!opts_list->desc->name);
4303 return 0;
4304}
4305
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004306/*
4307 * This is not trivial, we have to parse Monitor command's argument
4308 * type syntax to be able to check the arguments provided by clients.
4309 *
4310 * In the near future we will be using an array for that and will be
4311 * able to drop all this parsing...
4312 */
4313static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
4314{
4315 int err;
4316 const char *p;
4317 CmdArgs cmd_args;
Markus Armbruster361127d2010-02-10 20:24:35 +01004318 QemuOptsList *opts_list;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004319
Blue Swirldd5121b2009-12-04 20:52:02 +00004320 if (cmd->args_type == NULL) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004321 return (qdict_size(args) == 0 ? 0 : -1);
4322 }
4323
4324 err = 0;
4325 cmd_args_init(&cmd_args);
Markus Armbruster361127d2010-02-10 20:24:35 +01004326 opts_list = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004327
4328 for (p = cmd->args_type;; p++) {
4329 if (*p == ':') {
4330 cmd_args.type = *++p;
4331 p++;
4332 if (cmd_args.type == '-') {
4333 cmd_args.flag = *p++;
4334 cmd_args.optional = 1;
Markus Armbruster361127d2010-02-10 20:24:35 +01004335 } else if (cmd_args.type == 'O') {
4336 opts_list = qemu_find_opts(qstring_get_str(cmd_args.name));
4337 assert(opts_list);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004338 } else if (*p == '?') {
4339 cmd_args.optional = 1;
4340 p++;
4341 }
4342
4343 assert(*p == ',' || *p == '\0');
Markus Armbruster361127d2010-02-10 20:24:35 +01004344 if (opts_list) {
4345 err = check_opts(opts_list, args);
4346 opts_list = NULL;
4347 } else {
4348 err = check_arg(&cmd_args, args);
4349 QDECREF(cmd_args.name);
4350 cmd_args_init(&cmd_args);
4351 }
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004352
4353 if (err < 0) {
4354 break;
4355 }
4356 } else {
4357 qstring_append_chr(cmd_args.name, *p);
4358 }
4359
4360 if (*p == '\0') {
4361 break;
4362 }
4363 }
4364
4365 QDECREF(cmd_args.name);
4366 return err;
4367}
4368
Luiz Capitulino09069b12010-02-04 18:10:06 -02004369static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4370{
4371 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4372 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4373}
4374
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004375static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4376{
4377 int err;
4378 QObject *obj;
4379 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004380 const mon_cmd_t *cmd;
4381 Monitor *mon = cur_mon;
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004382 const char *cmd_name, *info_item;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004383
4384 args = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004385
4386 obj = json_parser_parse(tokens, NULL);
4387 if (!obj) {
4388 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004389 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004390 goto err_out;
4391 } else if (qobject_type(obj) != QTYPE_QDICT) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004392 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004393 qobject_decref(obj);
4394 goto err_out;
4395 }
4396
4397 input = qobject_to_qdict(obj);
4398
4399 mon->mc->id = qdict_get(input, "id");
4400 qobject_incref(mon->mc->id);
4401
4402 obj = qdict_get(input, "execute");
4403 if (!obj) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004404 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004405 goto err_input;
4406 } else if (qobject_type(obj) != QTYPE_QSTRING) {
Luiz Capitulino88f7db82010-04-07 14:49:37 -03004407 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute", "string");
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004408 goto err_input;
4409 }
4410
4411 cmd_name = qstring_get_str(qobject_to_qstring(obj));
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004412
Luiz Capitulino09069b12010-02-04 18:10:06 -02004413 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004414 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulino09069b12010-02-04 18:10:06 -02004415 goto err_input;
4416 }
4417
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004418 /*
4419 * XXX: We need this special case until we get info handlers
4420 * converted into 'query-' commands
4421 */
4422 if (compare_cmd(cmd_name, "info")) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004423 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004424 goto err_input;
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004425 } else if (strstart(cmd_name, "query-", &info_item)) {
4426 cmd = monitor_find_command("info");
4427 qdict_put_obj(input, "arguments",
4428 qobject_from_jsonf("{ 'item': %s }", info_item));
4429 } else {
4430 cmd = monitor_find_command(cmd_name);
Luiz Capitulino43e713c2009-12-18 13:24:59 -02004431 if (!cmd || !monitor_handler_ported(cmd)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004432 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004433 goto err_input;
4434 }
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004435 }
4436
4437 obj = qdict_get(input, "arguments");
4438 if (!obj) {
4439 args = qdict_new();
Luiz Capitulino04f8c052010-04-06 16:39:42 -03004440 } else if (qobject_type(obj) != QTYPE_QDICT) {
4441 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments", "object");
4442 goto err_input;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004443 } else {
4444 args = qobject_to_qdict(obj);
4445 QINCREF(args);
4446 }
4447
4448 QDECREF(input);
4449
4450 err = monitor_check_qmp_args(cmd, args);
4451 if (err < 0) {
4452 goto err_out;
4453 }
4454
Adam Litke940cc302010-01-25 12:18:44 -06004455 if (monitor_handler_is_async(cmd)) {
4456 qmp_async_cmd_handler(mon, cmd, args);
4457 } else {
4458 monitor_call_handler(mon, cmd, args);
4459 }
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004460 goto out;
4461
4462err_input:
4463 QDECREF(input);
4464err_out:
4465 monitor_protocol_emitter(mon, NULL);
4466out:
4467 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004468}
4469
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004470/**
4471 * monitor_control_read(): Read and handle QMP input
4472 */
4473static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4474{
4475 Monitor *old_mon = cur_mon;
4476
4477 cur_mon = opaque;
4478
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004479 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004480
4481 cur_mon = old_mon;
4482}
4483
aliguori731b0362009-03-05 23:01:42 +00004484static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004485{
aliguori731b0362009-03-05 23:01:42 +00004486 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004487 int i;
aliguori376253e2009-03-05 23:01:23 +00004488
aliguori731b0362009-03-05 23:01:42 +00004489 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004490
aliguoricde76ee2009-03-05 23:01:51 +00004491 if (cur_mon->rs) {
4492 for (i = 0; i < size; i++)
4493 readline_handle_byte(cur_mon->rs, buf[i]);
4494 } else {
4495 if (size == 0 || buf[size - 1] != 0)
4496 monitor_printf(cur_mon, "corrupted command\n");
4497 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004498 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004499 }
aliguori731b0362009-03-05 23:01:42 +00004500
4501 cur_mon = old_mon;
4502}
aliguorid8f44602008-10-06 13:52:44 +00004503
aliguori376253e2009-03-05 23:01:23 +00004504static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004505{
aliguori731b0362009-03-05 23:01:42 +00004506 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004507 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004508 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004509}
4510
aliguoricde76ee2009-03-05 23:01:51 +00004511int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004512{
aliguoricde76ee2009-03-05 23:01:51 +00004513 if (!mon->rs)
4514 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004515 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004516 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004517}
4518
aliguori376253e2009-03-05 23:01:23 +00004519void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004520{
aliguoricde76ee2009-03-05 23:01:51 +00004521 if (!mon->rs)
4522 return;
aliguori731b0362009-03-05 23:01:42 +00004523 if (--mon->suspend_cnt == 0)
4524 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004525}
4526
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004527static QObject *get_qmp_greeting(void)
4528{
4529 QObject *ver;
4530
4531 do_info_version(NULL, &ver);
4532 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4533}
4534
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004535/**
4536 * monitor_control_event(): Print QMP gretting
4537 */
4538static void monitor_control_event(void *opaque, int event)
4539{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004540 QObject *data;
4541 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004542
Luiz Capitulino47116d12010-02-08 17:01:30 -02004543 switch (event) {
4544 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004545 mon->mc->command_mode = 0;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004546 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004547 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004548 monitor_json_emitter(mon, data);
4549 qobject_decref(data);
Luiz Capitulino47116d12010-02-08 17:01:30 -02004550 break;
4551 case CHR_EVENT_CLOSED:
4552 json_message_parser_destroy(&mon->mc->parser);
4553 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004554 }
4555}
4556
aliguori731b0362009-03-05 23:01:42 +00004557static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004558{
aliguori376253e2009-03-05 23:01:23 +00004559 Monitor *mon = opaque;
4560
aliguori2724b182009-03-05 23:01:47 +00004561 switch (event) {
4562 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004563 mon->mux_out = 0;
4564 if (mon->reset_seen) {
4565 readline_restart(mon->rs);
4566 monitor_resume(mon);
4567 monitor_flush(mon);
4568 } else {
4569 mon->suspend_cnt = 0;
4570 }
aliguori2724b182009-03-05 23:01:47 +00004571 break;
ths86e94de2007-01-05 22:01:59 +00004572
aliguori2724b182009-03-05 23:01:47 +00004573 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004574 if (mon->reset_seen) {
4575 if (mon->suspend_cnt == 0) {
4576 monitor_printf(mon, "\n");
4577 }
4578 monitor_flush(mon);
4579 monitor_suspend(mon);
4580 } else {
4581 mon->suspend_cnt++;
4582 }
4583 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004584 break;
4585
Amit Shahb6b8df52009-10-07 18:31:16 +05304586 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004587 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4588 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004589 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004590 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004591 }
4592 mon->reset_seen = 1;
aliguori2724b182009-03-05 23:01:47 +00004593 break;
4594 }
ths86e94de2007-01-05 22:01:59 +00004595}
4596
aliguori76655d62009-03-06 20:27:37 +00004597
4598/*
4599 * Local variables:
4600 * c-indent-level: 4
4601 * c-basic-offset: 4
4602 * tab-width: 8
4603 * End:
4604 */
4605
aliguori731b0362009-03-05 23:01:42 +00004606void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004607{
aliguori731b0362009-03-05 23:01:42 +00004608 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00004609 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00004610
4611 if (is_first_init) {
balrogc8256f92008-06-08 22:45:01 +00004612 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
ths20d8a3e2007-02-18 17:04:49 +00004613 is_first_init = 0;
4614 }
aliguori87127162009-03-05 23:01:29 +00004615
4616 mon = qemu_mallocz(sizeof(*mon));
ths20d8a3e2007-02-18 17:04:49 +00004617
aliguori87127162009-03-05 23:01:29 +00004618 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00004619 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00004620 if (flags & MONITOR_USE_READLINE) {
4621 mon->rs = readline_init(mon, monitor_find_completion);
4622 monitor_read_command(mon, 0);
4623 }
aliguori87127162009-03-05 23:01:29 +00004624
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004625 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004626 mon->mc = qemu_mallocz(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004627 /* Control mode requires special handlers */
4628 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4629 monitor_control_event, mon);
4630 } else {
4631 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4632 monitor_event, mon);
4633 }
aliguori87127162009-03-05 23:01:29 +00004634
Blue Swirl72cf2d42009-09-12 07:36:22 +00004635 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01004636 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4637 default_mon = mon;
bellard7e2515e2004-08-01 21:52:19 +00004638}
4639
aliguori376253e2009-03-05 23:01:23 +00004640static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004641{
aliguoribb5fc202009-03-05 23:01:15 +00004642 BlockDriverState *bs = opaque;
4643 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00004644
aliguoribb5fc202009-03-05 23:01:15 +00004645 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00004646 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00004647 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00004648 }
aliguori731b0362009-03-05 23:01:42 +00004649 if (mon->password_completion_cb)
4650 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00004651
aliguori731b0362009-03-05 23:01:42 +00004652 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00004653}
aliguoric0f4ce72009-03-05 23:01:01 +00004654
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004655int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4656 BlockDriverCompletionFunc *completion_cb,
4657 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00004658{
aliguoricde76ee2009-03-05 23:01:51 +00004659 int err;
4660
aliguoribb5fc202009-03-05 23:01:15 +00004661 if (!bdrv_key_required(bs)) {
4662 if (completion_cb)
4663 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004664 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00004665 }
aliguoric0f4ce72009-03-05 23:01:01 +00004666
Luiz Capitulino94171e12009-12-07 21:37:00 +01004667 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004668 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004669 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01004670 }
4671
aliguori376253e2009-03-05 23:01:23 +00004672 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4673 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00004674
aliguori731b0362009-03-05 23:01:42 +00004675 mon->password_completion_cb = completion_cb;
4676 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00004677
aliguoricde76ee2009-03-05 23:01:51 +00004678 err = monitor_read_password(mon, bdrv_password_cb, bs);
4679
4680 if (err && completion_cb)
4681 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004682
4683 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00004684}