blob: 9ad857820b7fc8b68e906e4528d18131eaa1aef0 [file] [log] [blame]
bellard9dc39cb2004-03-14 21:38:27 +00001/*
2 * QEMU monitor
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard9dc39cb2004-03-14 21:38:27 +00004 * Copyright (c) 2003-2004 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellard9dc39cb2004-03-14 21:38:27 +00006 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
blueswir1511d2b12009-03-07 15:32:56 +000024#include <dirent.h>
pbrook87ecb682007-11-17 17:14:51 +000025#include "hw/hw.h"
Paolo Bonzinib4a42f82013-02-04 11:37:52 +010026#include "monitor/qdev.h"
pbrook87ecb682007-11-17 17:14:51 +000027#include "hw/usb.h"
28#include "hw/pcmcia.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010029#include "hw/i386/pc.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020030#include "hw/pci/pci.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010031#include "sysemu/watchdog.h"
Gerd Hoffmann45a50b12009-10-01 16:42:33 +020032#include "hw/loader.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010033#include "exec/gdbstub.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020034#include "net/net.h"
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000035#include "net/slirp.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020036#include "sysemu/char.h"
Gerd Hoffmann75721502010-10-07 12:22:54 +020037#include "ui/qemu-spice.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010038#include "sysemu/sysemu.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010039#include "monitor/monitor.h"
Stefan Hajnoczi0150cd82013-11-14 11:54:15 +010040#include "qemu/readline.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010041#include "ui/console.h"
Gerd Hoffmannc751a742013-12-04 15:02:28 +010042#include "ui/input.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010043#include "sysemu/blockdev.h"
pbrook87ecb682007-11-17 17:14:51 +000044#include "audio/audio.h"
Paolo Bonzini76cad712012-10-24 11:12:21 +020045#include "disas/disas.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010046#include "sysemu/balloon.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010047#include "qemu/timer.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010048#include "migration/migration.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010049#include "sysemu/kvm.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010050#include "qemu/acl.h"
Paolo Bonzinibdee56f2013-04-02 18:28:41 +020051#include "sysemu/tpm.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010052#include "qapi/qmp/qint.h"
53#include "qapi/qmp/qfloat.h"
54#include "qapi/qmp/qlist.h"
55#include "qapi/qmp/qbool.h"
56#include "qapi/qmp/qstring.h"
57#include "qapi/qmp/qjson.h"
58#include "qapi/qmp/json-streamer.h"
59#include "qapi/qmp/json-parser.h"
Hani Benhabiles1094fd32014-02-06 23:30:13 +010060#include <qom/object_interfaces.h>
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010061#include "qemu/osdep.h"
Blue Swirl2b41f102011-06-19 20:38:22 +000062#include "cpu.h"
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +010063#include "trace.h"
Lluís31965ae2011-08-31 20:31:24 +020064#include "trace/control.h"
Lluís6d8a7642011-08-31 20:30:43 +020065#ifdef CONFIG_TRACE_SIMPLE
Lluís31965ae2011-08-31 20:31:24 +020066#include "trace/simple.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053067#endif
Paolo Bonzini022c62c2012-12-17 18:19:49 +010068#include "exec/memory.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050069#include "qmp-commands.h"
70#include "hmp.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010071#include "qemu/thread.h"
ths6a5bd302007-12-03 17:05:38 +000072
Jan Kiszka661f1922011-10-16 11:53:13 +020073/* for pic/irq_info */
74#if defined(TARGET_SPARC)
Paolo Bonzini0d09e412013-02-05 17:06:20 +010075#include "hw/sparc/sun4m.h"
Jan Kiszka661f1922011-10-16 11:53:13 +020076#endif
Paolo Bonzini0d09e412013-02-05 17:06:20 +010077#include "hw/lm32/lm32_pic.h"
Jan Kiszka661f1922011-10-16 11:53:13 +020078
bellard9dc39cb2004-03-14 21:38:27 +000079//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000080//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000081
bellard9307c4c2004-04-04 12:57:25 +000082/*
83 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000084 *
bellard9307c4c2004-04-04 12:57:25 +000085 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000086 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000087 * 's' string (accept optional quote)
Wenchao Xia129be002013-08-27 20:38:26 +080088 * 'S' it just appends the rest of the string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +010089 * 'O' option string of the form NAME=VALUE,...
90 * parsed according to QemuOptsList given by its name
91 * Example: 'device:O' uses qemu_device_opts.
92 * Restriction: only lists with empty desc are supported
93 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +000094 * 'i' 32 bit integer
95 * 'l' target long (32 or 64 bit)
Luiz Capitulino91162842012-04-26 17:34:30 -030096 * 'M' Non-negative target long (32 or 64 bit), in user mode the
97 * value is multiplied by 2^20 (think Mebibyte)
Jes Sorensendbc0c672010-10-21 17:15:47 +020098 * 'o' octets (aka bytes)
Kevin Wolf5e009842013-06-05 14:19:27 +020099 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
100 * K, k suffix, which multiplies the value by 2^60 for suffixes E
101 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
102 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +0100103 * 'T' double
104 * user mode accepts an optional ms, us, ns suffix,
105 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +0000106 * '/' optional gdb-like print format (like "/10x")
107 *
Luiz Capitulinofb466602009-08-28 15:27:27 -0300108 * '?' optional type (for all types, except '/')
109 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +0100110 * 'b' boolean
111 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -0300112 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +0000113 *
114 */
115
Adam Litke940cc302010-01-25 12:18:44 -0600116typedef struct MonitorCompletionData MonitorCompletionData;
117struct MonitorCompletionData {
118 Monitor *mon;
119 void (*user_print)(Monitor *mon, const QObject *data);
120};
121
Anthony Liguoric227f092009-10-01 16:12:16 -0500122typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000123 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000124 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000125 const char *params;
126 const char *help;
Luiz Capitulinoa2876f52009-10-07 13:41:53 -0300127 void (*user_print)(Monitor *mon, const QObject *data);
Luiz Capitulino910df892009-10-07 13:41:51 -0300128 union {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -0300129 void (*cmd)(Monitor *mon, const QDict *qdict);
Luiz Capitulino261394d2010-02-10 23:50:02 -0200130 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600131 int (*cmd_async)(Monitor *mon, const QDict *params,
132 MonitorCompletion *cb, void *opaque);
Luiz Capitulino910df892009-10-07 13:41:51 -0300133 } mhandler;
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200134 int flags;
Wenchao Xia5f3d3352013-01-14 14:06:27 +0800135 /* @sub_table is a list of 2nd level of commands. If it do not exist,
136 * mhandler should be used. If it exist, sub_table[?].mhandler should be
137 * used, and mhandler of 1st level plays the role of help function.
138 */
139 struct mon_cmd_t *sub_table;
Hani Benhabilesbfa40f72014-04-13 16:25:06 +0100140 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
Anthony Liguoric227f092009-10-01 16:12:16 -0500141} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000142
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100143/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500144typedef struct mon_fd_t mon_fd_t;
145struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100146 char *name;
147 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500148 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100149};
150
Corey Bryantba1c0482012-08-14 16:43:43 -0400151/* file descriptor associated with a file descriptor set */
152typedef struct MonFdsetFd MonFdsetFd;
153struct MonFdsetFd {
154 int fd;
155 bool removed;
156 char *opaque;
157 QLIST_ENTRY(MonFdsetFd) next;
158};
159
160/* file descriptor set containing fds passed via SCM_RIGHTS */
161typedef struct MonFdset MonFdset;
162struct MonFdset {
163 int64_t id;
164 QLIST_HEAD(, MonFdsetFd) fds;
Corey Bryantadb696f2012-08-14 16:43:47 -0400165 QLIST_HEAD(, MonFdsetFd) dup_fds;
Corey Bryantba1c0482012-08-14 16:43:43 -0400166 QLIST_ENTRY(MonFdset) next;
167};
168
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200169typedef struct MonitorControl {
170 QObject *id;
171 JSONMessageParser parser;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200172 int command_mode;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200173} MonitorControl;
174
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100175/*
176 * To prevent flooding clients, events can be throttled. The
177 * throttling is calculated globally, rather than per-Monitor
178 * instance.
179 */
180typedef struct MonitorEventState {
181 MonitorEvent event; /* Event being tracked */
182 int64_t rate; /* Period over which to throttle. 0 to disable */
183 int64_t last; /* Time at which event was last emitted */
184 QEMUTimer *timer; /* Timer for handling delayed events */
185 QObject *data; /* Event pending delayed dispatch */
186} MonitorEventState;
187
aliguori87127162009-03-05 23:01:29 +0000188struct Monitor {
189 CharDriverState *chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200190 int mux_out;
191 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000192 int flags;
193 int suspend_cnt;
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400194 bool skip_flush;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400195 QString *outbuf;
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200196 guint watch;
aliguori731b0362009-03-05 23:01:42 +0000197 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200198 MonitorControl *mc;
Andreas Färbercb446ec2013-05-01 14:24:52 +0200199 CPUState *mon_cpu;
aliguori731b0362009-03-05 23:01:42 +0000200 BlockDriverCompletionFunc *password_completion_cb;
201 void *password_opaque;
Wenchao Xia77172392013-08-27 20:38:20 +0800202 mon_cmd_t *cmd_table;
Luiz Capitulino8204a912009-11-18 23:05:31 -0200203 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500204 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000205 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000206};
207
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300208/* QMP checker flags */
209#define QMP_ACCEPT_UNKNOWNS 1
210
Blue Swirl72cf2d42009-09-12 07:36:22 +0000211static QLIST_HEAD(mon_list, Monitor) mon_list;
Corey Bryantba1c0482012-08-14 16:43:43 -0400212static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
Corey Bryantefb87c12012-08-14 16:43:48 -0400213static int mon_refcount;
bellard7e2515e2004-08-01 21:52:19 +0000214
Wayne Xia816f8922011-10-12 11:32:41 +0800215static mon_cmd_t mon_cmds[];
216static mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000217
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300218static const mon_cmd_t qmp_cmds[];
219
Markus Armbruster8631b602010-02-18 11:41:55 +0100220Monitor *cur_mon;
221Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000222
Stefan Hajnoczic60bf332013-11-14 11:54:14 +0100223static void monitor_command_cb(void *opaque, const char *cmdline,
224 void *readline_opaque);
aliguori83ab7952008-08-19 14:44:22 +0000225
Luiz Capitulino09069b12010-02-04 18:10:06 -0200226static inline int qmp_cmd_mode(const Monitor *mon)
227{
228 return (mon->mc ? mon->mc->command_mode : 0);
229}
230
Luiz Capitulino418173c2009-11-26 22:58:51 -0200231/* Return true if in control mode, false otherwise */
232static inline int monitor_ctrl_mode(const Monitor *mon)
233{
234 return (mon->flags & MONITOR_USE_CONTROL);
235}
236
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100237/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
238int monitor_cur_is_qmp(void)
239{
240 return cur_mon && monitor_ctrl_mode(cur_mon);
241}
242
Anthony Liguori7060b472011-09-02 12:34:50 -0500243void monitor_read_command(Monitor *mon, int show_prompt)
aliguori731b0362009-03-05 23:01:42 +0000244{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200245 if (!mon->rs)
246 return;
247
aliguori731b0362009-03-05 23:01:42 +0000248 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
249 if (show_prompt)
250 readline_show_prompt(mon->rs);
251}
bellard6a00d602005-11-21 23:25:50 +0000252
Anthony Liguori7060b472011-09-02 12:34:50 -0500253int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
254 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000255{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100256 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100257 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100258 return -EINVAL;
259 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000260 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
261 /* prompt is printed on return from the command handler */
262 return 0;
263 } else {
264 monitor_printf(mon, "terminal does not support password prompting\n");
265 return -ENOTTY;
266 }
aliguoribb5fc202009-03-05 23:01:15 +0000267}
268
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100269static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
270 void *opaque)
271{
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200272 Monitor *mon = opaque;
273
274 mon->watch = 0;
275 monitor_flush(mon);
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100276 return FALSE;
277}
278
aliguori376253e2009-03-05 23:01:23 +0000279void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000280{
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100281 int rc;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400282 size_t len;
283 const char *buf;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100284
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400285 if (mon->skip_flush) {
286 return;
287 }
288
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400289 buf = qstring_get_str(mon->outbuf);
290 len = qstring_get_length(mon->outbuf);
291
Paolo Bonzinia4cc73d2013-05-31 14:00:27 +0200292 if (len && !mon->mux_out) {
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400293 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
Stratos Psomadakis056f49f2014-01-27 12:30:15 +0200294 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
295 /* all flushed or error */
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400296 QDECREF(mon->outbuf);
297 mon->outbuf = qstring_new();
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100298 return;
299 }
300 if (rc > 0) {
301 /* partinal write */
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400302 QString *tmp = qstring_from_str(buf + rc);
303 QDECREF(mon->outbuf);
304 mon->outbuf = tmp;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100305 }
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200306 if (mon->watch == 0) {
307 mon->watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT,
308 monitor_unblocked, mon);
309 }
bellard7e2515e2004-08-01 21:52:19 +0000310 }
311}
312
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400313/* flush at every end of line */
aliguori376253e2009-03-05 23:01:23 +0000314static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000315{
ths60fe76f2007-12-16 03:02:09 +0000316 char c;
aliguori731b0362009-03-05 23:01:42 +0000317
bellard7e2515e2004-08-01 21:52:19 +0000318 for(;;) {
319 c = *str++;
320 if (c == '\0')
321 break;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400322 if (c == '\n') {
323 qstring_append_chr(mon->outbuf, '\r');
324 }
325 qstring_append_chr(mon->outbuf, c);
326 if (c == '\n') {
aliguori376253e2009-03-05 23:01:23 +0000327 monitor_flush(mon);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400328 }
bellard7e2515e2004-08-01 21:52:19 +0000329 }
330}
331
aliguori376253e2009-03-05 23:01:23 +0000332void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000333{
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400334 char *buf;
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200335
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200336 if (!mon)
337 return;
338
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200339 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200340 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200341 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200342
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400343 buf = g_strdup_vprintf(fmt, ap);
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200344 monitor_puts(mon, buf);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400345 g_free(buf);
bellard7e2515e2004-08-01 21:52:19 +0000346}
347
aliguori376253e2009-03-05 23:01:23 +0000348void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000349{
350 va_list ap;
351 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000352 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000353 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000354}
355
Stefan Weil8b7968f2010-09-23 21:28:05 +0200356static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
357 const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000358{
359 va_list ap;
360 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000361 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000362 va_end(ap);
363 return 0;
364}
365
Luiz Capitulino13c74252009-10-07 13:41:55 -0300366static void monitor_user_noop(Monitor *mon, const QObject *data) { }
367
Luiz Capitulino9e807212010-09-16 10:58:59 -0300368static inline int handler_is_qobject(const mon_cmd_t *cmd)
Luiz Capitulino13917be2009-10-07 13:41:54 -0300369{
370 return cmd->user_print != NULL;
371}
372
Luiz Capitulino4903de02010-09-16 11:01:32 -0300373static inline bool handler_is_async(const mon_cmd_t *cmd)
Adam Litke940cc302010-01-25 12:18:44 -0600374{
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200375 return cmd->flags & MONITOR_CMD_ASYNC;
Adam Litke940cc302010-01-25 12:18:44 -0600376}
377
Luiz Capitulino8204a912009-11-18 23:05:31 -0200378static inline int monitor_has_error(const Monitor *mon)
379{
380 return mon->error != NULL;
381}
382
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200383static void monitor_json_emitter(Monitor *mon, const QObject *data)
384{
385 QString *json;
386
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200387 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
388 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200389 assert(json != NULL);
390
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200391 qstring_append_chr(json, '\n');
392 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200393
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200394 QDECREF(json);
395}
396
Luiz Capitulinode253f12012-07-27 16:18:16 -0300397static QDict *build_qmp_error_dict(const QError *err)
398{
399 QObject *obj;
400
401 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
402 ErrorClass_lookup[err->err_class],
403 qerror_human(err));
404
405 return qobject_to_qdict(obj);
406}
407
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200408static void monitor_protocol_emitter(Monitor *mon, QObject *data)
409{
410 QDict *qmp;
411
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +0100412 trace_monitor_protocol_emitter(mon);
413
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200414 if (!monitor_has_error(mon)) {
415 /* success response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300416 qmp = qdict_new();
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200417 if (data) {
418 qobject_incref(data);
419 qdict_put_obj(qmp, "return", data);
420 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200421 /* return an empty QDict by default */
422 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200423 }
424 } else {
425 /* error response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300426 qmp = build_qmp_error_dict(mon->error);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200427 QDECREF(mon->error);
428 mon->error = NULL;
429 }
430
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200431 if (mon->mc->id) {
432 qdict_put_obj(qmp, "id", mon->mc->id);
433 mon->mc->id = NULL;
434 }
435
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200436 monitor_json_emitter(mon, QOBJECT(qmp));
437 QDECREF(qmp);
438}
439
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200440static void timestamp_put(QDict *qdict)
441{
442 int err;
443 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000444 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200445
Blue Swirld08d6f02009-12-04 18:06:39 +0000446 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200447 if (err < 0)
448 return;
449
450 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
451 "'microseconds': %" PRId64 " }",
452 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200453 qdict_put_obj(qdict, "timestamp", obj);
454}
455
Daniel P. Berrange48608532012-05-21 17:59:51 +0100456
457static const char *monitor_event_names[] = {
458 [QEVENT_SHUTDOWN] = "SHUTDOWN",
459 [QEVENT_RESET] = "RESET",
460 [QEVENT_POWERDOWN] = "POWERDOWN",
461 [QEVENT_STOP] = "STOP",
462 [QEVENT_RESUME] = "RESUME",
463 [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
464 [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
465 [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
466 [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
467 [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
468 [QEVENT_WATCHDOG] = "WATCHDOG",
469 [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
470 [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
471 [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
472 [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
473 [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200474 [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200475 [QEVENT_BLOCK_JOB_READY] = "BLOCK_JOB_READY",
Michael S. Tsirkin0402a5d2013-03-06 14:58:59 +0200476 [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100477 [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
Amos Kongb1be4282013-06-14 15:45:52 +0800478 [QEVENT_NIC_RX_FILTER_CHANGED] = "NIC_RX_FILTER_CHANGED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100479 [QEVENT_SUSPEND] = "SUSPEND",
Luiz Capitulino25df49f2012-08-08 17:03:01 -0300480 [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100481 [QEVENT_WAKEUP] = "WAKEUP",
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100482 [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
Yonit Halperin2fdd16e2012-08-21 11:51:57 +0300483 [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
Hu Taoc401a8a2013-04-26 11:24:41 +0800484 [QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",
Max Reitza40f1c22013-08-30 14:34:25 +0200485 [QEVENT_BLOCK_IMAGE_CORRUPTED] = "BLOCK_IMAGE_CORRUPTED",
Benoît Canet95c6bff2014-02-21 22:21:15 +0100486 [QEVENT_QUORUM_FAILURE] = "QUORUM_FAILURE",
487 [QEVENT_QUORUM_REPORT_BAD] = "QUORUM_REPORT_BAD",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100488};
489QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
490
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100491MonitorEventState monitor_event_state[QEVENT_MAX];
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100492
493/*
494 * Emits the event to every monitor instance
495 */
496static void
497monitor_protocol_event_emit(MonitorEvent event,
498 QObject *data)
499{
500 Monitor *mon;
501
502 trace_monitor_protocol_event_emit(event, data);
503 QLIST_FOREACH(mon, &mon_list, entry) {
504 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
505 monitor_json_emitter(mon, data);
506 }
507 }
508}
509
510
511/*
512 * Queue a new event for emission to Monitor instances,
513 * applying any rate limiting if required.
514 */
515static void
516monitor_protocol_event_queue(MonitorEvent event,
517 QObject *data)
518{
519 MonitorEventState *evstate;
Alex Blighbc72ad62013-08-21 16:03:08 +0100520 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100521 assert(event < QEVENT_MAX);
522
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100523 evstate = &(monitor_event_state[event]);
524 trace_monitor_protocol_event_queue(event,
525 data,
526 evstate->rate,
527 evstate->last,
528 now);
529
530 /* Rate limit of 0 indicates no throttling */
531 if (!evstate->rate) {
532 monitor_protocol_event_emit(event, data);
533 evstate->last = now;
534 } else {
535 int64_t delta = now - evstate->last;
536 if (evstate->data ||
537 delta < evstate->rate) {
538 /* If there's an existing event pending, replace
539 * it with the new event, otherwise schedule a
540 * timer for delayed emission
541 */
542 if (evstate->data) {
543 qobject_decref(evstate->data);
544 } else {
545 int64_t then = evstate->last + evstate->rate;
Alex Blighbc72ad62013-08-21 16:03:08 +0100546 timer_mod_ns(evstate->timer, then);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100547 }
548 evstate->data = data;
549 qobject_incref(evstate->data);
550 } else {
551 monitor_protocol_event_emit(event, data);
552 evstate->last = now;
553 }
554 }
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100555}
556
557
558/*
559 * The callback invoked by QemuTimer when a delayed
560 * event is ready to be emitted
561 */
562static void monitor_protocol_event_handler(void *opaque)
563{
564 MonitorEventState *evstate = opaque;
Alex Blighbc72ad62013-08-21 16:03:08 +0100565 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100566
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100567
568 trace_monitor_protocol_event_handler(evstate->event,
569 evstate->data,
570 evstate->last,
571 now);
572 if (evstate->data) {
573 monitor_protocol_event_emit(evstate->event, evstate->data);
574 qobject_decref(evstate->data);
575 evstate->data = NULL;
576 }
577 evstate->last = now;
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100578}
579
580
581/*
582 * @event: the event ID to be limited
583 * @rate: the rate limit in milliseconds
584 *
585 * Sets a rate limit on a particular event, so no
586 * more than 1 event will be emitted within @rate
587 * milliseconds
588 */
589static void
590monitor_protocol_event_throttle(MonitorEvent event,
591 int64_t rate)
592{
593 MonitorEventState *evstate;
594 assert(event < QEVENT_MAX);
595
596 evstate = &(monitor_event_state[event]);
597
598 trace_monitor_protocol_event_throttle(event, rate);
599 evstate->event = event;
600 evstate->rate = rate * SCALE_MS;
Alex Blighbc72ad62013-08-21 16:03:08 +0100601 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100602 SCALE_MS,
603 monitor_protocol_event_handler,
604 evstate);
605 evstate->last = 0;
606 evstate->data = NULL;
607}
608
609
610/* Global, one-time initializer to configure the rate limiting
611 * and initialize state */
612static void monitor_protocol_event_init(void)
613{
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100614 /* Limit RTC & BALLOON events to 1 per second */
615 monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
616 monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
617 monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
Benoît Canetc88a1de2014-02-21 22:21:20 +0100618 /* limit the rate of quorum events to avoid hammering the management */
619 monitor_protocol_event_throttle(QEVENT_QUORUM_REPORT_BAD, 1000);
620 monitor_protocol_event_throttle(QEVENT_QUORUM_FAILURE, 1000);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100621}
622
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200623/**
624 * monitor_protocol_event(): Generate a Monitor event
625 *
626 * Event-specific data can be emitted through the (optional) 'data' parameter.
627 */
628void monitor_protocol_event(MonitorEvent event, QObject *data)
629{
630 QDict *qmp;
631 const char *event_name;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200632
Blue Swirl242cd002009-12-04 18:05:45 +0000633 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200634
Daniel P. Berrange48608532012-05-21 17:59:51 +0100635 event_name = monitor_event_names[event];
636 assert(event_name != NULL);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200637
638 qmp = qdict_new();
639 timestamp_put(qmp);
640 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200641 if (data) {
642 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200643 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200644 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200645
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100646 trace_monitor_protocol_event(event, event_name, qmp);
647 monitor_protocol_event_queue(event, QOBJECT(qmp));
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200648 QDECREF(qmp);
649}
650
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200651static int do_qmp_capabilities(Monitor *mon, const QDict *params,
652 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200653{
654 /* Will setup QMP capabilities in the future */
655 if (monitor_ctrl_mode(mon)) {
656 mon->mc->command_mode = 1;
657 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200658
659 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200660}
661
Luiz Capitulino0268d972010-10-22 10:08:02 -0200662static void handle_user_command(Monitor *mon, const char *cmdline);
663
Wenchao Xiab01fe892013-08-27 20:38:19 +0800664static void monitor_data_init(Monitor *mon)
665{
666 memset(mon, 0, sizeof(Monitor));
667 mon->outbuf = qstring_new();
Wenchao Xia77172392013-08-27 20:38:20 +0800668 /* Use *mon_cmds by default. */
669 mon->cmd_table = mon_cmds;
Wenchao Xiab01fe892013-08-27 20:38:19 +0800670}
671
672static void monitor_data_destroy(Monitor *mon)
673{
674 QDECREF(mon->outbuf);
675}
676
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200677char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
678 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200679{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200680 char *output = NULL;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200681 Monitor *old_mon, hmp;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200682
Wenchao Xiab01fe892013-08-27 20:38:19 +0800683 monitor_data_init(&hmp);
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400684 hmp.skip_flush = true;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200685
686 old_mon = cur_mon;
687 cur_mon = &hmp;
688
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200689 if (has_cpu_index) {
690 int ret = monitor_set_cpu(cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200691 if (ret < 0) {
692 cur_mon = old_mon;
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200693 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
694 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200695 goto out;
696 }
697 }
698
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200699 handle_user_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200700 cur_mon = old_mon;
701
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400702 if (qstring_get_length(hmp.outbuf) > 0) {
703 output = g_strdup(qstring_get_str(hmp.outbuf));
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200704 } else {
705 output = g_strdup("");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200706 }
707
708out:
Wenchao Xiab01fe892013-08-27 20:38:19 +0800709 monitor_data_destroy(&hmp);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200710 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200711}
712
bellard9dc39cb2004-03-14 21:38:27 +0000713static int compare_cmd(const char *name, const char *list)
714{
715 const char *p, *pstart;
716 int len;
717 len = strlen(name);
718 p = list;
719 for(;;) {
720 pstart = p;
721 p = strchr(p, '|');
722 if (!p)
723 p = pstart + strlen(pstart);
724 if ((p - pstart) == len && !memcmp(pstart, name, len))
725 return 1;
726 if (*p == '\0')
727 break;
728 p++;
729 }
730 return 0;
731}
732
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800733static int get_str(char *buf, int buf_size, const char **pp)
734{
735 const char *p;
736 char *q;
737 int c;
738
739 q = buf;
740 p = *pp;
741 while (qemu_isspace(*p)) {
742 p++;
743 }
744 if (*p == '\0') {
745 fail:
746 *q = '\0';
747 *pp = p;
748 return -1;
749 }
750 if (*p == '\"') {
751 p++;
752 while (*p != '\0' && *p != '\"') {
753 if (*p == '\\') {
754 p++;
755 c = *p++;
756 switch (c) {
757 case 'n':
758 c = '\n';
759 break;
760 case 'r':
761 c = '\r';
762 break;
763 case '\\':
764 case '\'':
765 case '\"':
766 break;
767 default:
768 qemu_printf("unsupported escape code: '\\%c'\n", c);
769 goto fail;
770 }
771 if ((q - buf) < buf_size - 1) {
772 *q++ = c;
773 }
774 } else {
775 if ((q - buf) < buf_size - 1) {
776 *q++ = *p;
777 }
778 p++;
779 }
780 }
781 if (*p != '\"') {
782 qemu_printf("unterminated string\n");
783 goto fail;
784 }
785 p++;
786 } else {
787 while (*p != '\0' && !qemu_isspace(*p)) {
788 if ((q - buf) < buf_size - 1) {
789 *q++ = *p;
790 }
791 p++;
792 }
793 }
794 *q = '\0';
795 *pp = p;
796 return 0;
797}
798
799#define MAX_ARGS 16
800
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800801static void free_cmdline_args(char **args, int nb_args)
802{
803 int i;
804
805 assert(nb_args <= MAX_ARGS);
806
807 for (i = 0; i < nb_args; i++) {
808 g_free(args[i]);
809 }
810
811}
812
813/*
814 * Parse the command line to get valid args.
815 * @cmdline: command line to be parsed.
816 * @pnb_args: location to store the number of args, must NOT be NULL.
817 * @args: location to store the args, which should be freed by caller, must
818 * NOT be NULL.
819 *
820 * Returns 0 on success, negative on failure.
821 *
822 * NOTE: this parser is an approximate form of the real command parser. Number
823 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
824 * return with failure.
825 */
826static int parse_cmdline(const char *cmdline,
827 int *pnb_args, char **args)
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800828{
829 const char *p;
830 int nb_args, ret;
831 char buf[1024];
832
833 p = cmdline;
834 nb_args = 0;
835 for (;;) {
836 while (qemu_isspace(*p)) {
837 p++;
838 }
839 if (*p == '\0') {
840 break;
841 }
842 if (nb_args >= MAX_ARGS) {
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800843 goto fail;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800844 }
845 ret = get_str(buf, sizeof(buf), &p);
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800846 if (ret < 0) {
847 goto fail;
848 }
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800849 args[nb_args] = g_strdup(buf);
850 nb_args++;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800851 }
852 *pnb_args = nb_args;
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800853 return 0;
854
855 fail:
856 free_cmdline_args(args, nb_args);
857 return -1;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800858}
859
Wenchao Xia66855492013-08-27 20:38:23 +0800860static void help_cmd_dump_one(Monitor *mon,
861 const mon_cmd_t *cmd,
862 char **prefix_args,
863 int prefix_args_nb)
864{
865 int i;
866
867 for (i = 0; i < prefix_args_nb; i++) {
868 monitor_printf(mon, "%s ", prefix_args[i]);
869 }
870 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
871}
872
873/* @args[@arg_index] is the valid command need to find in @cmds */
Anthony Liguoric227f092009-10-01 16:12:16 -0500874static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
Wenchao Xia66855492013-08-27 20:38:23 +0800875 char **args, int nb_args, int arg_index)
bellard9dc39cb2004-03-14 21:38:27 +0000876{
Anthony Liguoric227f092009-10-01 16:12:16 -0500877 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000878
Wenchao Xia66855492013-08-27 20:38:23 +0800879 /* No valid arg need to compare with, dump all in *cmds */
880 if (arg_index >= nb_args) {
881 for (cmd = cmds; cmd->name != NULL; cmd++) {
882 help_cmd_dump_one(mon, cmd, args, arg_index);
883 }
884 return;
885 }
886
887 /* Find one entry to dump */
888 for (cmd = cmds; cmd->name != NULL; cmd++) {
889 if (compare_cmd(args[arg_index], cmd->name)) {
890 if (cmd->sub_table) {
891 /* continue with next arg */
892 help_cmd_dump(mon, cmd->sub_table,
893 args, nb_args, arg_index + 1);
894 } else {
895 help_cmd_dump_one(mon, cmd, args, arg_index);
896 }
897 break;
898 }
bellard9dc39cb2004-03-14 21:38:27 +0000899 }
900}
901
aliguori376253e2009-03-05 23:01:23 +0000902static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000903{
Wenchao Xia66855492013-08-27 20:38:23 +0800904 char *args[MAX_ARGS];
905 int nb_args = 0;
906
907 /* 1. parse user input */
908 if (name) {
909 /* special case for log, directly dump and return */
910 if (!strcmp(name, "log")) {
Peter Maydell38dad9e2013-02-11 16:41:25 +0000911 const QEMULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000912 monitor_printf(mon, "Log items (comma separated):\n");
913 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
Peter Maydell38dad9e2013-02-11 16:41:25 +0000914 for (item = qemu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000915 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000916 }
Wenchao Xia66855492013-08-27 20:38:23 +0800917 return;
918 }
919
920 if (parse_cmdline(name, &nb_args, args) < 0) {
921 return;
bellardf193c792004-03-21 17:06:25 +0000922 }
bellard9dc39cb2004-03-14 21:38:27 +0000923 }
Wenchao Xia66855492013-08-27 20:38:23 +0800924
925 /* 2. dump the contents according to parsed args */
926 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
927
928 free_cmdline_args(args, nb_args);
bellard9dc39cb2004-03-14 21:38:27 +0000929}
930
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300931static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300932{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300933 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300934}
935
Lluísfc764102011-08-31 20:31:18 +0200936static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530937{
938 const char *tp_name = qdict_get_str(qdict, "name");
939 bool new_state = qdict_get_bool(qdict, "option");
Blue Swirlf871d682010-10-13 19:14:29 +0000940
Lluís Vilanovaca285c32013-03-05 14:47:43 +0100941 bool found = false;
942 TraceEvent *ev = NULL;
943 while ((ev = trace_event_pattern(tp_name, ev)) != NULL) {
944 found = true;
945 if (!trace_event_get_state_static(ev)) {
946 monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);
947 } else {
948 trace_event_set_state_dynamic(ev, new_state);
949 }
950 }
951 if (!trace_event_is_pattern(tp_name) && !found) {
Blue Swirlf871d682010-10-13 19:14:29 +0000952 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
953 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530954}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100955
Michael Rothc45a8162011-10-02 08:44:37 -0500956#ifdef CONFIG_TRACE_SIMPLE
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100957static void do_trace_file(Monitor *mon, const QDict *qdict)
958{
959 const char *op = qdict_get_try_str(qdict, "op");
960 const char *arg = qdict_get_try_str(qdict, "arg");
961
962 if (!op) {
963 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
964 } else if (!strcmp(op, "on")) {
965 st_set_trace_file_enabled(true);
966 } else if (!strcmp(op, "off")) {
967 st_set_trace_file_enabled(false);
968 } else if (!strcmp(op, "flush")) {
969 st_flush_trace_buffer();
970 } else if (!strcmp(op, "set")) {
971 if (arg) {
972 st_set_trace_file(arg);
973 }
974 } else {
975 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
976 help_cmd(mon, "trace-file");
977 }
978}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530979#endif
980
Adam Litke940cc302010-01-25 12:18:44 -0600981static void user_monitor_complete(void *opaque, QObject *ret_data)
982{
983 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
984
985 if (ret_data) {
986 data->user_print(data->mon, ret_data);
987 }
988 monitor_resume(data->mon);
Anthony Liguori7267c092011-08-20 22:09:37 -0500989 g_free(data);
Adam Litke940cc302010-01-25 12:18:44 -0600990}
991
992static void qmp_monitor_complete(void *opaque, QObject *ret_data)
993{
994 monitor_protocol_emitter(opaque, ret_data);
995}
996
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300997static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
998 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -0600999{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03001000 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -06001001}
1002
Adam Litke940cc302010-01-25 12:18:44 -06001003static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1004 const QDict *params)
1005{
1006 int ret;
1007
Anthony Liguori7267c092011-08-20 22:09:37 -05001008 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
Adam Litke940cc302010-01-25 12:18:44 -06001009 cb_data->mon = mon;
1010 cb_data->user_print = cmd->user_print;
1011 monitor_suspend(mon);
1012 ret = cmd->mhandler.cmd_async(mon, params,
1013 user_monitor_complete, cb_data);
1014 if (ret < 0) {
1015 monitor_resume(mon);
Anthony Liguori7267c092011-08-20 22:09:37 -05001016 g_free(cb_data);
Adam Litke940cc302010-01-25 12:18:44 -06001017 }
1018}
1019
Wenchao Xia84c44612013-01-14 14:06:29 +08001020static void do_info_help(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +00001021{
Luiz Capitulino13c74252009-10-07 13:41:55 -03001022 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +00001023}
1024
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001025CommandInfoList *qmp_query_commands(Error **errp)
bellard9bc9d1c2004-10-10 15:15:51 +00001026{
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001027 CommandInfoList *info, *cmd_list = NULL;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001028 const mon_cmd_t *cmd;
1029
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03001030 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino40e5a012011-10-21 16:15:31 -02001031 info = g_malloc0(sizeof(*info));
1032 info->value = g_malloc0(sizeof(*info->value));
1033 info->value->name = g_strdup(cmd->name);
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001034
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001035 info->next = cmd_list;
1036 cmd_list = info;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001037 }
1038
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001039 return cmd_list;
thsa36e69d2007-12-02 05:18:19 +00001040}
1041
Daniel P. Berrange48608532012-05-21 17:59:51 +01001042EventInfoList *qmp_query_events(Error **errp)
1043{
1044 EventInfoList *info, *ev_list = NULL;
1045 MonitorEvent e;
1046
1047 for (e = 0 ; e < QEVENT_MAX ; e++) {
1048 const char *event_name = monitor_event_names[e];
1049 assert(event_name != NULL);
1050 info = g_malloc0(sizeof(*info));
1051 info->value = g_malloc0(sizeof(*info->value));
1052 info->value->name = g_strdup(event_name);
1053
1054 info->next = ev_list;
1055 ev_list = info;
1056 }
1057
1058 return ev_list;
1059}
1060
Luiz Capitulinob025c8b2011-10-06 14:02:57 -03001061/* set the current CPU defined by the user */
1062int monitor_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +00001063{
Andreas Färber55e5c282012-12-17 06:18:02 +01001064 CPUState *cpu;
bellard6a00d602005-11-21 23:25:50 +00001065
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001066 cpu = qemu_get_cpu(cpu_index);
1067 if (cpu == NULL) {
1068 return -1;
bellard6a00d602005-11-21 23:25:50 +00001069 }
Andreas Färbercb446ec2013-05-01 14:24:52 +02001070 cur_mon->mon_cpu = cpu;
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001071 return 0;
bellard6a00d602005-11-21 23:25:50 +00001072}
1073
Andreas Färber9349b4f2012-03-14 01:38:32 +01001074static CPUArchState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +00001075{
aliguori731b0362009-03-05 23:01:42 +00001076 if (!cur_mon->mon_cpu) {
Luiz Capitulinob025c8b2011-10-06 14:02:57 -03001077 monitor_set_cpu(0);
bellard6a00d602005-11-21 23:25:50 +00001078 }
Avi Kivity4c0960c2009-08-17 23:19:53 +03001079 cpu_synchronize_state(cur_mon->mon_cpu);
Andreas Färbercb446ec2013-05-01 14:24:52 +02001080 return cur_mon->mon_cpu->env_ptr;
bellard6a00d602005-11-21 23:25:50 +00001081}
1082
Luiz Capitulino99b77962011-10-24 10:53:44 -02001083int monitor_get_cpu_index(void)
1084{
Andreas Färber55e5c282012-12-17 06:18:02 +01001085 CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
1086 return cpu->cpu_index;
Luiz Capitulino99b77962011-10-24 10:53:44 -02001087}
1088
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001089static void do_info_registers(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001090{
Andreas Färber878096e2013-05-27 01:33:50 +02001091 CPUState *cpu;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001092 CPUArchState *env;
bellard6a00d602005-11-21 23:25:50 +00001093 env = mon_get_cpu();
Andreas Färber878096e2013-05-27 01:33:50 +02001094 cpu = ENV_GET_CPU(env);
1095 cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +00001096}
1097
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001098static void do_info_jit(Monitor *mon, const QDict *qdict)
bellarde3db7222005-01-26 22:00:47 +00001099{
aliguori376253e2009-03-05 23:01:23 +00001100 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +00001101}
1102
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001103static void do_info_history(Monitor *mon, const QDict *qdict)
bellardaa455482004-04-04 13:07:25 +00001104{
1105 int i;
bellard7e2515e2004-08-01 21:52:19 +00001106 const char *str;
ths3b46e622007-09-17 08:09:54 +00001107
aliguoricde76ee2009-03-05 23:01:51 +00001108 if (!mon->rs)
1109 return;
bellard7e2515e2004-08-01 21:52:19 +00001110 i = 0;
1111 for(;;) {
aliguori731b0362009-03-05 23:01:42 +00001112 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +00001113 if (!str)
1114 break;
aliguori376253e2009-03-05 23:01:23 +00001115 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +00001116 i++;
bellardaa455482004-04-04 13:07:25 +00001117 }
1118}
1119
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001120static void do_info_cpu_stats(Monitor *mon, const QDict *qdict)
j_mayer76a66252007-03-07 08:32:30 +00001121{
Andreas Färber878096e2013-05-27 01:33:50 +02001122 CPUState *cpu;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001123 CPUArchState *env;
j_mayer76a66252007-03-07 08:32:30 +00001124
1125 env = mon_get_cpu();
Andreas Färber878096e2013-05-27 01:33:50 +02001126 cpu = ENV_GET_CPU(env);
1127 cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +00001128}
j_mayer76a66252007-03-07 08:32:30 +00001129
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001130static void do_trace_print_events(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +05301131{
Lluísfc764102011-08-31 20:31:18 +02001132 trace_print_events((FILE *)mon, &monitor_fprintf);
Prerna Saxena22890ab2010-06-24 17:04:53 +05301133}
Prerna Saxena22890ab2010-06-24 17:04:53 +05301134
Yonit Halperinedc5cb12011-10-17 10:03:18 +02001135static int client_migrate_info(Monitor *mon, const QDict *qdict,
1136 MonitorCompletion cb, void *opaque)
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001137{
1138 const char *protocol = qdict_get_str(qdict, "protocol");
1139 const char *hostname = qdict_get_str(qdict, "hostname");
1140 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1141 int port = qdict_get_try_int(qdict, "port", -1);
1142 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1143 int ret;
1144
1145 if (strcmp(protocol, "spice") == 0) {
1146 if (!using_spice) {
1147 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1148 return -1;
1149 }
1150
Yonit Halperin6ec5dae2012-03-18 09:42:39 +02001151 if (port == -1 && tls_port == -1) {
1152 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1153 return -1;
1154 }
1155
Yonit Halperinedc5cb12011-10-17 10:03:18 +02001156 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1157 cb, opaque);
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001158 if (ret != 0) {
1159 qerror_report(QERR_UNDEFINED_ERROR);
1160 return -1;
1161 }
1162 return 0;
1163 }
1164
1165 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1166 return -1;
1167}
1168
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001169static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001170{
Peter Maydell9a7e5422013-02-11 16:41:20 +00001171 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001172}
1173
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001174static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001175{
1176 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001177 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001178
bellard9307c4c2004-04-04 12:57:25 +00001179 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001180 mask = 0;
1181 } else {
Peter Maydell4fde1eb2013-02-11 16:41:22 +00001182 mask = qemu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001183 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001184 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001185 return;
1186 }
1187 }
Peter Maydell24537a02013-02-11 16:41:23 +00001188 qemu_set_log(mask);
bellardf193c792004-03-21 17:06:25 +00001189}
1190
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001191static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001192{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001193 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001194 if (!option || !strcmp(option, "on")) {
1195 singlestep = 1;
1196 } else if (!strcmp(option, "off")) {
1197 singlestep = 0;
1198 } else {
1199 monitor_printf(mon, "unexpected option %s\n", option);
1200 }
1201}
1202
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001203static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001204{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001205 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001206 if (!device)
1207 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1208 if (gdbserver_start(device) < 0) {
1209 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1210 device);
1211 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001212 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001213 } else {
aliguori59030a82009-04-05 18:43:41 +00001214 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1215 device);
bellard8a7ddc32004-03-31 19:00:16 +00001216 }
1217}
1218
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001219static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001220{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001221 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001222 if (select_watchdog_action(action) == -1) {
1223 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1224 }
1225}
1226
aliguori376253e2009-03-05 23:01:23 +00001227static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001228{
aliguori376253e2009-03-05 23:01:23 +00001229 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001230 switch(c) {
1231 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001232 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001233 break;
1234 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001235 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001236 break;
1237 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001238 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001239 break;
1240 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001241 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001242 break;
1243 default:
1244 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001245 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001246 } else {
aliguori376253e2009-03-05 23:01:23 +00001247 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001248 }
1249 break;
1250 }
aliguori376253e2009-03-05 23:01:23 +00001251 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001252}
1253
aliguori376253e2009-03-05 23:01:23 +00001254static void memory_dump(Monitor *mon, int count, int format, int wsize,
Avi Kivitya8170e52012-10-23 12:30:10 +02001255 hwaddr addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001256{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001257 CPUArchState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001258 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001259 uint8_t buf[16];
1260 uint64_t v;
1261
1262 if (format == 'i') {
1263 int flags;
1264 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001265 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001266#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001267 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001268 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001269 } else if (wsize == 4) {
1270 flags = 0;
1271 } else {
bellard6a15fd12006-04-12 21:07:07 +00001272 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001273 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001274 if (env) {
1275#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001276 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001277 (env->segs[R_CS].flags & DESC_L_MASK))
1278 flags = 2;
1279 else
1280#endif
1281 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1282 flags = 1;
1283 }
bellard4c27ba22004-04-25 18:05:08 +00001284 }
1285#endif
aliguori376253e2009-03-05 23:01:23 +00001286 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001287 return;
1288 }
1289
1290 len = wsize * count;
1291 if (wsize == 1)
1292 line_size = 8;
1293 else
1294 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001295 max_digits = 0;
1296
1297 switch(format) {
1298 case 'o':
1299 max_digits = (wsize * 8 + 2) / 3;
1300 break;
1301 default:
1302 case 'x':
1303 max_digits = (wsize * 8) / 4;
1304 break;
1305 case 'u':
1306 case 'd':
1307 max_digits = (wsize * 8 * 10 + 32) / 33;
1308 break;
1309 case 'c':
1310 wsize = 1;
1311 break;
1312 }
1313
1314 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001315 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001316 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001317 else
aliguori376253e2009-03-05 23:01:23 +00001318 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001319 l = len;
1320 if (l > line_size)
1321 l = line_size;
1322 if (is_physical) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001323 cpu_physical_memory_read(addr, buf, l);
bellard9307c4c2004-04-04 12:57:25 +00001324 } else {
bellard6a00d602005-11-21 23:25:50 +00001325 env = mon_get_cpu();
Andreas Färberf17ec442013-06-29 19:40:58 +02001326 if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001327 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001328 break;
1329 }
bellard9307c4c2004-04-04 12:57:25 +00001330 }
ths5fafdf22007-09-16 21:08:06 +00001331 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001332 while (i < l) {
1333 switch(wsize) {
1334 default:
1335 case 1:
1336 v = ldub_raw(buf + i);
1337 break;
1338 case 2:
1339 v = lduw_raw(buf + i);
1340 break;
1341 case 4:
bellard92a31b12005-02-10 22:00:52 +00001342 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001343 break;
1344 case 8:
1345 v = ldq_raw(buf + i);
1346 break;
1347 }
aliguori376253e2009-03-05 23:01:23 +00001348 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001349 switch(format) {
1350 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001351 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001352 break;
1353 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001354 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001355 break;
1356 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001357 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001358 break;
1359 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001360 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001361 break;
1362 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001363 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001364 break;
1365 }
1366 i += wsize;
1367 }
aliguori376253e2009-03-05 23:01:23 +00001368 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001369 addr += l;
1370 len -= l;
1371 }
1372}
1373
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001374static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001375{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001376 int count = qdict_get_int(qdict, "count");
1377 int format = qdict_get_int(qdict, "format");
1378 int size = qdict_get_int(qdict, "size");
1379 target_long addr = qdict_get_int(qdict, "addr");
1380
aliguori376253e2009-03-05 23:01:23 +00001381 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001382}
1383
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001384static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001385{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001386 int count = qdict_get_int(qdict, "count");
1387 int format = qdict_get_int(qdict, "format");
1388 int size = qdict_get_int(qdict, "size");
Avi Kivitya8170e52012-10-23 12:30:10 +02001389 hwaddr addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001390
aliguori376253e2009-03-05 23:01:23 +00001391 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001392}
1393
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001394static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001395{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001396 int format = qdict_get_int(qdict, "format");
Avi Kivitya8170e52012-10-23 12:30:10 +02001397 hwaddr val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001398
bellard9307c4c2004-04-04 12:57:25 +00001399 switch(format) {
1400 case 'o':
Avi Kivitya8170e52012-10-23 12:30:10 +02001401 monitor_printf(mon, "%#" HWADDR_PRIo, val);
bellard9307c4c2004-04-04 12:57:25 +00001402 break;
1403 case 'x':
Avi Kivitya8170e52012-10-23 12:30:10 +02001404 monitor_printf(mon, "%#" HWADDR_PRIx, val);
bellard9307c4c2004-04-04 12:57:25 +00001405 break;
1406 case 'u':
Avi Kivitya8170e52012-10-23 12:30:10 +02001407 monitor_printf(mon, "%" HWADDR_PRIu, val);
bellard9307c4c2004-04-04 12:57:25 +00001408 break;
1409 default:
1410 case 'd':
Avi Kivitya8170e52012-10-23 12:30:10 +02001411 monitor_printf(mon, "%" HWADDR_PRId, val);
bellard9307c4c2004-04-04 12:57:25 +00001412 break;
1413 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001414 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001415 break;
1416 }
aliguori376253e2009-03-05 23:01:23 +00001417 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001418}
1419
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001420static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001421{
1422 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +00001423 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001424 uint32_t start = qdict_get_int(qdict, "start");
1425 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001426
1427 sum = 0;
1428 for(addr = start; addr < (start + size); addr++) {
Edgar E. Iglesias2c174492013-12-17 14:05:40 +10001429 uint8_t val = ldub_phys(&address_space_memory, addr);
bellarde4cf1ad2005-06-04 20:15:57 +00001430 /* BSD sum algorithm ('sum' Unix command) */
1431 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001432 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +00001433 }
aliguori376253e2009-03-05 23:01:23 +00001434 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001435}
1436
bellard13224a82006-07-14 22:03:35 +00001437static int mouse_button_state;
1438
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001439static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001440{
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001441 int dx, dy, dz, button;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001442 const char *dx_str = qdict_get_str(qdict, "dx_str");
1443 const char *dy_str = qdict_get_str(qdict, "dy_str");
1444 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001445
bellard13224a82006-07-14 22:03:35 +00001446 dx = strtol(dx_str, NULL, 0);
1447 dy = strtol(dy_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001448 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1449 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1450
1451 if (dz_str) {
bellard13224a82006-07-14 22:03:35 +00001452 dz = strtol(dz_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001453 if (dz != 0) {
1454 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1455 qemu_input_queue_btn(NULL, button, true);
1456 qemu_input_event_sync();
1457 qemu_input_queue_btn(NULL, button, false);
1458 }
1459 }
1460 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +00001461}
1462
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001463static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001464{
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001465 static uint32_t bmap[INPUT_BUTTON_MAX] = {
1466 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1467 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1468 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1469 };
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001470 int button_state = qdict_get_int(qdict, "button_state");
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001471
1472 if (mouse_button_state == button_state) {
1473 return;
1474 }
1475 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1476 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +00001477 mouse_button_state = button_state;
bellard13224a82006-07-14 22:03:35 +00001478}
1479
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001480static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001481{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001482 int size = qdict_get_int(qdict, "size");
1483 int addr = qdict_get_int(qdict, "addr");
1484 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001485 uint32_t val;
1486 int suffix;
1487
1488 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001489 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001490 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001491 addr++;
1492 }
1493 addr &= 0xffff;
1494
1495 switch(size) {
1496 default:
1497 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001498 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001499 suffix = 'b';
1500 break;
1501 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001502 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001503 suffix = 'w';
1504 break;
1505 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001506 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001507 suffix = 'l';
1508 break;
1509 }
aliguori376253e2009-03-05 23:01:23 +00001510 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1511 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001512}
bellarda3a91a32004-06-04 11:06:21 +00001513
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001514static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001515{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001516 int size = qdict_get_int(qdict, "size");
1517 int addr = qdict_get_int(qdict, "addr");
1518 int val = qdict_get_int(qdict, "val");
1519
Jan Kiszkaf1147842009-07-14 10:20:11 +02001520 addr &= IOPORTS_MASK;
1521
1522 switch (size) {
1523 default:
1524 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001525 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001526 break;
1527 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001528 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001529 break;
1530 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001531 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001532 break;
1533 }
1534}
1535
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001536static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001537{
1538 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001539 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001540
Jan Kiszka76e30d02009-07-02 00:19:02 +02001541 res = qemu_boot_set(bootdevice);
1542 if (res == 0) {
1543 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1544 } else if (res > 0) {
1545 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001546 } else {
aliguori376253e2009-03-05 23:01:23 +00001547 monitor_printf(mon, "no function defined to set boot device list for "
1548 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001549 }
1550}
1551
bellardb86bda52004-09-18 19:32:46 +00001552#if defined(TARGET_I386)
Avi Kivitya8170e52012-10-23 12:30:10 +02001553static void print_pte(Monitor *mon, hwaddr addr,
1554 hwaddr pte,
1555 hwaddr mask)
bellardb86bda52004-09-18 19:32:46 +00001556{
Blue Swirld65aaf32010-12-11 18:56:24 +00001557#ifdef TARGET_X86_64
1558 if (addr & (1ULL << 47)) {
1559 addr |= -1LL << 48;
1560 }
1561#endif
1562 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1563 " %c%c%c%c%c%c%c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001564 addr,
1565 pte & mask,
Blue Swirld65aaf32010-12-11 18:56:24 +00001566 pte & PG_NX_MASK ? 'X' : '-',
aliguori376253e2009-03-05 23:01:23 +00001567 pte & PG_GLOBAL_MASK ? 'G' : '-',
1568 pte & PG_PSE_MASK ? 'P' : '-',
1569 pte & PG_DIRTY_MASK ? 'D' : '-',
1570 pte & PG_ACCESSED_MASK ? 'A' : '-',
1571 pte & PG_PCD_MASK ? 'C' : '-',
1572 pte & PG_PWT_MASK ? 'T' : '-',
1573 pte & PG_USER_MASK ? 'U' : '-',
1574 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001575}
1576
Andreas Färber9349b4f2012-03-14 01:38:32 +01001577static void tlb_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001578{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001579 unsigned int l1, l2;
bellardb86bda52004-09-18 19:32:46 +00001580 uint32_t pgd, pde, pte;
1581
bellardb86bda52004-09-18 19:32:46 +00001582 pgd = env->cr[3] & ~0xfff;
1583 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001584 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001585 pde = le32_to_cpu(pde);
1586 if (pde & PG_PRESENT_MASK) {
1587 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
Blue Swirld65aaf32010-12-11 18:56:24 +00001588 /* 4M pages */
1589 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
bellardb86bda52004-09-18 19:32:46 +00001590 } else {
1591 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001592 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001593 pte = le32_to_cpu(pte);
1594 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00001595 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00001596 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00001597 ~0xfff);
1598 }
1599 }
1600 }
1601 }
1602 }
1603}
1604
Andreas Färber9349b4f2012-03-14 01:38:32 +01001605static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001606{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001607 unsigned int l1, l2, l3;
Blue Swirld65aaf32010-12-11 18:56:24 +00001608 uint64_t pdpe, pde, pte;
1609 uint64_t pdp_addr, pd_addr, pt_addr;
1610
1611 pdp_addr = env->cr[3] & ~0x1f;
1612 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001613 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001614 pdpe = le64_to_cpu(pdpe);
1615 if (pdpe & PG_PRESENT_MASK) {
1616 pd_addr = pdpe & 0x3fffffffff000ULL;
1617 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001618 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001619 pde = le64_to_cpu(pde);
1620 if (pde & PG_PRESENT_MASK) {
1621 if (pde & PG_PSE_MASK) {
1622 /* 2M pages with PAE, CR4.PSE is ignored */
1623 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
Avi Kivitya8170e52012-10-23 12:30:10 +02001624 ~((hwaddr)(1 << 20) - 1));
Blue Swirld65aaf32010-12-11 18:56:24 +00001625 } else {
1626 pt_addr = pde & 0x3fffffffff000ULL;
1627 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001628 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001629 pte = le64_to_cpu(pte);
1630 if (pte & PG_PRESENT_MASK) {
1631 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1632 + (l3 << 12),
1633 pte & ~PG_PSE_MASK,
Avi Kivitya8170e52012-10-23 12:30:10 +02001634 ~(hwaddr)0xfff);
Blue Swirld65aaf32010-12-11 18:56:24 +00001635 }
1636 }
1637 }
1638 }
1639 }
1640 }
1641 }
1642}
1643
1644#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001645static void tlb_info_64(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001646{
1647 uint64_t l1, l2, l3, l4;
1648 uint64_t pml4e, pdpe, pde, pte;
1649 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1650
1651 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1652 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001653 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001654 pml4e = le64_to_cpu(pml4e);
1655 if (pml4e & PG_PRESENT_MASK) {
1656 pdp_addr = pml4e & 0x3fffffffff000ULL;
1657 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001658 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001659 pdpe = le64_to_cpu(pdpe);
1660 if (pdpe & PG_PRESENT_MASK) {
1661 if (pdpe & PG_PSE_MASK) {
1662 /* 1G pages, CR4.PSE is ignored */
1663 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1664 0x3ffffc0000000ULL);
1665 } else {
1666 pd_addr = pdpe & 0x3fffffffff000ULL;
1667 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001668 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001669 pde = le64_to_cpu(pde);
1670 if (pde & PG_PRESENT_MASK) {
1671 if (pde & PG_PSE_MASK) {
1672 /* 2M pages, CR4.PSE is ignored */
1673 print_pte(mon, (l1 << 39) + (l2 << 30) +
1674 (l3 << 21), pde,
1675 0x3ffffffe00000ULL);
1676 } else {
1677 pt_addr = pde & 0x3fffffffff000ULL;
1678 for (l4 = 0; l4 < 512; l4++) {
1679 cpu_physical_memory_read(pt_addr
1680 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001681 &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001682 pte = le64_to_cpu(pte);
1683 if (pte & PG_PRESENT_MASK) {
1684 print_pte(mon, (l1 << 39) +
1685 (l2 << 30) +
1686 (l3 << 21) + (l4 << 12),
1687 pte & ~PG_PSE_MASK,
1688 0x3fffffffff000ULL);
1689 }
1690 }
1691 }
1692 }
1693 }
1694 }
1695 }
1696 }
1697 }
1698 }
1699}
1700#endif
1701
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001702static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld65aaf32010-12-11 18:56:24 +00001703{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001704 CPUArchState *env;
Blue Swirld65aaf32010-12-11 18:56:24 +00001705
1706 env = mon_get_cpu();
1707
1708 if (!(env->cr[0] & CR0_PG_MASK)) {
1709 monitor_printf(mon, "PG disabled\n");
1710 return;
1711 }
1712 if (env->cr[4] & CR4_PAE_MASK) {
1713#ifdef TARGET_X86_64
1714 if (env->hflags & HF_LMA_MASK) {
1715 tlb_info_64(mon, env);
1716 } else
1717#endif
1718 {
1719 tlb_info_pae32(mon, env);
1720 }
1721 } else {
1722 tlb_info_32(mon, env);
1723 }
1724}
1725
Avi Kivitya8170e52012-10-23 12:30:10 +02001726static void mem_print(Monitor *mon, hwaddr *pstart,
Blue Swirl1b3cba62010-12-11 18:56:27 +00001727 int *plast_prot,
Avi Kivitya8170e52012-10-23 12:30:10 +02001728 hwaddr end, int prot)
bellardb86bda52004-09-18 19:32:46 +00001729{
bellard9746b152004-11-11 18:30:24 +00001730 int prot1;
1731 prot1 = *plast_prot;
1732 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00001733 if (*pstart != -1) {
Blue Swirl1b3cba62010-12-11 18:56:27 +00001734 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1735 TARGET_FMT_plx " %c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001736 *pstart, end, end - *pstart,
1737 prot1 & PG_USER_MASK ? 'u' : '-',
1738 'r',
1739 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00001740 }
1741 if (prot != 0)
1742 *pstart = end;
1743 else
1744 *pstart = -1;
1745 *plast_prot = prot;
1746 }
1747}
1748
Andreas Färber9349b4f2012-03-14 01:38:32 +01001749static void mem_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001750{
Austin Clementsb49ca722011-08-14 23:19:21 -04001751 unsigned int l1, l2;
1752 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001753 uint32_t pgd, pde, pte;
Avi Kivitya8170e52012-10-23 12:30:10 +02001754 hwaddr start, end;
bellardb86bda52004-09-18 19:32:46 +00001755
bellardb86bda52004-09-18 19:32:46 +00001756 pgd = env->cr[3] & ~0xfff;
1757 last_prot = 0;
1758 start = -1;
1759 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001760 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001761 pde = le32_to_cpu(pde);
1762 end = l1 << 22;
1763 if (pde & PG_PRESENT_MASK) {
1764 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1765 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00001766 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001767 } else {
1768 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001769 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001770 pte = le32_to_cpu(pte);
1771 end = (l1 << 22) + (l2 << 12);
1772 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001773 prot = pte & pde &
1774 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
bellardb86bda52004-09-18 19:32:46 +00001775 } else {
1776 prot = 0;
1777 }
aliguori376253e2009-03-05 23:01:23 +00001778 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001779 }
1780 }
1781 } else {
1782 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00001783 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001784 }
1785 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001786 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001787 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
bellardb86bda52004-09-18 19:32:46 +00001788}
Blue Swirl1b3cba62010-12-11 18:56:27 +00001789
Andreas Färber9349b4f2012-03-14 01:38:32 +01001790static void mem_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001791{
Austin Clementsb49ca722011-08-14 23:19:21 -04001792 unsigned int l1, l2, l3;
1793 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001794 uint64_t pdpe, pde, pte;
1795 uint64_t pdp_addr, pd_addr, pt_addr;
Avi Kivitya8170e52012-10-23 12:30:10 +02001796 hwaddr start, end;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001797
1798 pdp_addr = env->cr[3] & ~0x1f;
1799 last_prot = 0;
1800 start = -1;
1801 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001802 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001803 pdpe = le64_to_cpu(pdpe);
1804 end = l1 << 30;
1805 if (pdpe & PG_PRESENT_MASK) {
1806 pd_addr = pdpe & 0x3fffffffff000ULL;
1807 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001808 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001809 pde = le64_to_cpu(pde);
1810 end = (l1 << 30) + (l2 << 21);
1811 if (pde & PG_PRESENT_MASK) {
1812 if (pde & PG_PSE_MASK) {
1813 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1814 PG_PRESENT_MASK);
1815 mem_print(mon, &start, &last_prot, end, prot);
1816 } else {
1817 pt_addr = pde & 0x3fffffffff000ULL;
1818 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001819 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001820 pte = le64_to_cpu(pte);
1821 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1822 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001823 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1824 PG_PRESENT_MASK);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001825 } else {
1826 prot = 0;
1827 }
1828 mem_print(mon, &start, &last_prot, end, prot);
1829 }
1830 }
1831 } else {
1832 prot = 0;
1833 mem_print(mon, &start, &last_prot, end, prot);
1834 }
1835 }
1836 } else {
1837 prot = 0;
1838 mem_print(mon, &start, &last_prot, end, prot);
1839 }
1840 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001841 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001842 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001843}
1844
1845
1846#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001847static void mem_info_64(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001848{
1849 int prot, last_prot;
1850 uint64_t l1, l2, l3, l4;
1851 uint64_t pml4e, pdpe, pde, pte;
1852 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1853
1854 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1855 last_prot = 0;
1856 start = -1;
1857 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001858 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001859 pml4e = le64_to_cpu(pml4e);
1860 end = l1 << 39;
1861 if (pml4e & PG_PRESENT_MASK) {
1862 pdp_addr = pml4e & 0x3fffffffff000ULL;
1863 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001864 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001865 pdpe = le64_to_cpu(pdpe);
1866 end = (l1 << 39) + (l2 << 30);
1867 if (pdpe & PG_PRESENT_MASK) {
1868 if (pdpe & PG_PSE_MASK) {
Blue Swirl2d5b5072011-01-15 08:31:00 +00001869 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1870 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001871 prot &= pml4e;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001872 mem_print(mon, &start, &last_prot, end, prot);
1873 } else {
1874 pd_addr = pdpe & 0x3fffffffff000ULL;
1875 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001876 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001877 pde = le64_to_cpu(pde);
1878 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1879 if (pde & PG_PRESENT_MASK) {
1880 if (pde & PG_PSE_MASK) {
1881 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1882 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001883 prot &= pml4e & pdpe;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001884 mem_print(mon, &start, &last_prot, end, prot);
1885 } else {
1886 pt_addr = pde & 0x3fffffffff000ULL;
1887 for (l4 = 0; l4 < 512; l4++) {
1888 cpu_physical_memory_read(pt_addr
1889 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001890 &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001891 pte = le64_to_cpu(pte);
1892 end = (l1 << 39) + (l2 << 30) +
1893 (l3 << 21) + (l4 << 12);
1894 if (pte & PG_PRESENT_MASK) {
1895 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1896 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001897 prot &= pml4e & pdpe & pde;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001898 } else {
1899 prot = 0;
1900 }
1901 mem_print(mon, &start, &last_prot, end, prot);
1902 }
1903 }
1904 } else {
1905 prot = 0;
1906 mem_print(mon, &start, &last_prot, end, prot);
1907 }
1908 }
1909 }
1910 } else {
1911 prot = 0;
1912 mem_print(mon, &start, &last_prot, end, prot);
1913 }
1914 }
1915 } else {
1916 prot = 0;
1917 mem_print(mon, &start, &last_prot, end, prot);
1918 }
1919 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001920 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001921 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001922}
1923#endif
1924
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001925static void mem_info(Monitor *mon, const QDict *qdict)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001926{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001927 CPUArchState *env;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001928
1929 env = mon_get_cpu();
1930
1931 if (!(env->cr[0] & CR0_PG_MASK)) {
1932 monitor_printf(mon, "PG disabled\n");
1933 return;
1934 }
1935 if (env->cr[4] & CR4_PAE_MASK) {
1936#ifdef TARGET_X86_64
1937 if (env->hflags & HF_LMA_MASK) {
1938 mem_info_64(mon, env);
1939 } else
1940#endif
1941 {
1942 mem_info_pae32(mon, env);
1943 }
1944 } else {
1945 mem_info_32(mon, env);
1946 }
1947}
bellardb86bda52004-09-18 19:32:46 +00001948#endif
1949
aurel327c664e22009-03-03 06:12:22 +00001950#if defined(TARGET_SH4)
1951
aliguori376253e2009-03-05 23:01:23 +00001952static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00001953{
aliguori376253e2009-03-05 23:01:23 +00001954 monitor_printf(mon, " tlb%i:\t"
1955 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1956 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1957 "dirty=%hhu writethrough=%hhu\n",
1958 idx,
1959 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1960 tlb->v, tlb->sh, tlb->c, tlb->pr,
1961 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00001962}
1963
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001964static void tlb_info(Monitor *mon, const QDict *qdict)
aurel327c664e22009-03-03 06:12:22 +00001965{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001966 CPUArchState *env = mon_get_cpu();
aurel327c664e22009-03-03 06:12:22 +00001967 int i;
1968
aliguori376253e2009-03-05 23:01:23 +00001969 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001970 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001971 print_tlb (mon, i, &env->itlb[i]);
1972 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001973 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001974 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00001975}
1976
1977#endif
1978
Max Filippov692f7372012-01-07 20:02:40 +04001979#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001980static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld41160a2010-12-19 13:42:56 +00001981{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001982 CPUArchState *env1 = mon_get_cpu();
Blue Swirld41160a2010-12-19 13:42:56 +00001983
1984 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1985}
1986#endif
1987
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001988static void do_info_mtree(Monitor *mon, const QDict *qdict)
Blue Swirl314e2982011-09-11 20:22:05 +00001989{
1990 mtree_info((fprintf_function)monitor_printf, mon);
1991}
1992
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001993static void do_info_numa(Monitor *mon, const QDict *qdict)
aliguori030ea372009-04-21 22:30:47 +00001994{
aliguorib28b6232009-04-22 20:20:29 +00001995 int i;
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01001996 CPUState *cpu;
aliguori030ea372009-04-21 22:30:47 +00001997
1998 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1999 for (i = 0; i < nb_numa_nodes; i++) {
2000 monitor_printf(mon, "node %d cpus:", i);
Andreas Färberbdc44642013-06-24 23:50:24 +02002001 CPU_FOREACH(cpu) {
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01002002 if (cpu->numa_node == i) {
Andreas Färber55e5c282012-12-17 06:18:02 +01002003 monitor_printf(mon, " %d", cpu->cpu_index);
aliguori030ea372009-04-21 22:30:47 +00002004 }
2005 }
2006 monitor_printf(mon, "\n");
2007 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2008 node_mem[i] >> 20);
2009 }
2010}
2011
bellard5f1ce942006-02-08 22:40:15 +00002012#ifdef CONFIG_PROFILER
2013
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002014int64_t qemu_time;
2015int64_t dev_time;
2016
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002017static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002018{
aliguori376253e2009-03-05 23:01:23 +00002019 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002020 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00002021 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002022 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00002023 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002024 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002025}
2026#else
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002027static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002028{
aliguori376253e2009-03-05 23:01:23 +00002029 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002030}
2031#endif
2032
bellardec36b692006-07-16 18:57:03 +00002033/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002034static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002035
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002036static void do_info_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002037{
2038 int i;
2039 CaptureState *s;
2040
2041 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002042 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002043 s->ops.info (s->opaque);
2044 }
2045}
2046
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002047static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002048{
2049 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002050 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002051 CaptureState *s;
2052
2053 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2054 if (i == n) {
2055 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002056 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -05002057 g_free (s);
bellardec36b692006-07-16 18:57:03 +00002058 return;
2059 }
2060 }
2061}
2062
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002063static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002064{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002065 const char *path = qdict_get_str(qdict, "path");
2066 int has_freq = qdict_haskey(qdict, "freq");
2067 int freq = qdict_get_try_int(qdict, "freq", -1);
2068 int has_bits = qdict_haskey(qdict, "bits");
2069 int bits = qdict_get_try_int(qdict, "bits", -1);
2070 int has_channels = qdict_haskey(qdict, "nchannels");
2071 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002072 CaptureState *s;
2073
Anthony Liguori7267c092011-08-20 22:09:37 -05002074 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002075
2076 freq = has_freq ? freq : 44100;
2077 bits = has_bits ? bits : 16;
2078 nchannels = has_channels ? nchannels : 2;
2079
2080 if (wav_start_capture (s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002081 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05002082 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002083 return;
bellardec36b692006-07-16 18:57:03 +00002084 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002085 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002086}
bellardec36b692006-07-16 18:57:03 +00002087
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002088static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002089{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002090 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002091
aliguori76655d62009-03-06 20:27:37 +00002092 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002093 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002094 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002095 return acl;
2096}
aliguori76655d62009-03-06 20:27:37 +00002097
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002098static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002099{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002100 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002101 qemu_acl *acl = find_acl(mon, aclname);
2102 qemu_acl_entry *entry;
2103 int i = 0;
2104
2105 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002106 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002107 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002108 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002109 i++;
2110 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002111 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002112 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002113 }
2114}
2115
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002116static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002117{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002118 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002119 qemu_acl *acl = find_acl(mon, aclname);
2120
2121 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002122 qemu_acl_reset(acl);
2123 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002124 }
2125}
aliguori76655d62009-03-06 20:27:37 +00002126
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002127static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002128{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002129 const char *aclname = qdict_get_str(qdict, "aclname");
2130 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002131 qemu_acl *acl = find_acl(mon, aclname);
2132
2133 if (acl) {
2134 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002135 acl->defaultDeny = 0;
2136 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002137 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002138 acl->defaultDeny = 1;
2139 monitor_printf(mon, "acl: policy set to 'deny'\n");
2140 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002141 monitor_printf(mon, "acl: unknown policy '%s', "
2142 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002143 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002144 }
2145}
aliguori76655d62009-03-06 20:27:37 +00002146
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002147static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002148{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002149 const char *aclname = qdict_get_str(qdict, "aclname");
2150 const char *match = qdict_get_str(qdict, "match");
2151 const char *policy = qdict_get_str(qdict, "policy");
2152 int has_index = qdict_haskey(qdict, "index");
2153 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002154 qemu_acl *acl = find_acl(mon, aclname);
2155 int deny, ret;
2156
2157 if (acl) {
2158 if (strcmp(policy, "allow") == 0) {
2159 deny = 0;
2160 } else if (strcmp(policy, "deny") == 0) {
2161 deny = 1;
2162 } else {
2163 monitor_printf(mon, "acl: unknown policy '%s', "
2164 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002165 return;
2166 }
aliguori28a76be2009-03-06 20:27:40 +00002167 if (has_index)
2168 ret = qemu_acl_insert(acl, deny, match, index);
2169 else
2170 ret = qemu_acl_append(acl, deny, match);
2171 if (ret < 0)
2172 monitor_printf(mon, "acl: unable to add acl entry\n");
2173 else
2174 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002175 }
2176}
aliguori76655d62009-03-06 20:27:37 +00002177
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002178static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002179{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002180 const char *aclname = qdict_get_str(qdict, "aclname");
2181 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002182 qemu_acl *acl = find_acl(mon, aclname);
2183 int ret;
aliguori76655d62009-03-06 20:27:37 +00002184
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002185 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002186 ret = qemu_acl_remove(acl, match);
2187 if (ret < 0)
2188 monitor_printf(mon, "acl: no matching acl entry\n");
2189 else
2190 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002191 }
2192}
2193
Huang Ying79c4f6b2009-06-23 10:05:14 +08002194#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002195static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002196{
Andreas Färber8c5cf3b2012-05-03 15:22:54 +02002197 X86CPU *cpu;
Andreas Färber55e5c282012-12-17 06:18:02 +01002198 CPUState *cs;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002199 int cpu_index = qdict_get_int(qdict, "cpu_index");
2200 int bank = qdict_get_int(qdict, "bank");
2201 uint64_t status = qdict_get_int(qdict, "status");
2202 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2203 uint64_t addr = qdict_get_int(qdict, "addr");
2204 uint64_t misc = qdict_get_int(qdict, "misc");
Jan Kiszka747461c2011-03-02 08:56:10 +01002205 int flags = MCE_INJECT_UNCOND_AO;
Huang Ying79c4f6b2009-06-23 10:05:14 +08002206
Jan Kiszka747461c2011-03-02 08:56:10 +01002207 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2208 flags |= MCE_INJECT_BROADCAST;
2209 }
Andreas Färberc51a9442013-05-17 16:57:52 +02002210 cs = qemu_get_cpu(cpu_index);
2211 if (cs != NULL) {
2212 cpu = X86_CPU(cs);
2213 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2214 flags);
Jin Dongming31ce5e02010-12-10 17:21:02 +09002215 }
Huang Ying79c4f6b2009-06-23 10:05:14 +08002216}
2217#endif
2218
Corey Bryant208c9d12012-06-22 14:36:09 -04002219void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002220{
Anthony Liguoric227f092009-10-01 16:12:16 -05002221 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002222 int fd;
2223
Corey Bryant208c9d12012-06-22 14:36:09 -04002224 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002225 if (fd == -1) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002226 error_set(errp, QERR_FD_NOT_SUPPLIED);
2227 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002228 }
2229
2230 if (qemu_isdigit(fdname[0])) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002231 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2232 "a name not starting with a digit");
2233 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002234 }
2235
Corey Bryant208c9d12012-06-22 14:36:09 -04002236 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002237 if (strcmp(monfd->name, fdname) != 0) {
2238 continue;
2239 }
2240
2241 close(monfd->fd);
2242 monfd->fd = fd;
Corey Bryant208c9d12012-06-22 14:36:09 -04002243 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002244 }
2245
Anthony Liguori7267c092011-08-20 22:09:37 -05002246 monfd = g_malloc0(sizeof(mon_fd_t));
2247 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002248 monfd->fd = fd;
2249
Corey Bryant208c9d12012-06-22 14:36:09 -04002250 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002251}
2252
Corey Bryant208c9d12012-06-22 14:36:09 -04002253void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002254{
Anthony Liguoric227f092009-10-01 16:12:16 -05002255 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002256
Corey Bryant208c9d12012-06-22 14:36:09 -04002257 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002258 if (strcmp(monfd->name, fdname) != 0) {
2259 continue;
2260 }
2261
Blue Swirl72cf2d42009-09-12 07:36:22 +00002262 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002263 close(monfd->fd);
Anthony Liguori7267c092011-08-20 22:09:37 -05002264 g_free(monfd->name);
2265 g_free(monfd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002266 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002267 }
2268
Corey Bryant208c9d12012-06-22 14:36:09 -04002269 error_set(errp, QERR_FD_NOT_FOUND, fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002270}
2271
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002272static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002273{
Luiz Capitulino13548692011-07-29 15:36:43 -03002274 int saved_vm_running = runstate_is_running();
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002275 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002276
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002277 vm_stop(RUN_STATE_RESTORE_VM);
Juan Quintelac8d41b22009-08-20 19:42:21 +02002278
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002279 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002280 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002281 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002282}
2283
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002284int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01002285{
Anthony Liguoric227f092009-10-01 16:12:16 -05002286 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002287
Blue Swirl72cf2d42009-09-12 07:36:22 +00002288 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002289 int fd;
2290
2291 if (strcmp(monfd->name, fdname) != 0) {
2292 continue;
2293 }
2294
2295 fd = monfd->fd;
2296
2297 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002298 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05002299 g_free(monfd->name);
2300 g_free(monfd);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002301
2302 return fd;
2303 }
2304
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002305 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002306 return -1;
2307}
2308
Corey Bryantba1c0482012-08-14 16:43:43 -04002309static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2310{
2311 MonFdsetFd *mon_fdset_fd;
2312 MonFdsetFd *mon_fdset_fd_next;
2313
2314 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantebe52b52012-10-18 15:19:33 -04002315 if ((mon_fdset_fd->removed ||
2316 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2317 runstate_is_running()) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002318 close(mon_fdset_fd->fd);
2319 g_free(mon_fdset_fd->opaque);
2320 QLIST_REMOVE(mon_fdset_fd, next);
2321 g_free(mon_fdset_fd);
2322 }
2323 }
2324
Corey Bryantadb696f2012-08-14 16:43:47 -04002325 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002326 QLIST_REMOVE(mon_fdset, next);
2327 g_free(mon_fdset);
2328 }
2329}
2330
Corey Bryantefb87c12012-08-14 16:43:48 -04002331static void monitor_fdsets_cleanup(void)
2332{
2333 MonFdset *mon_fdset;
2334 MonFdset *mon_fdset_next;
2335
2336 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2337 monitor_fdset_cleanup(mon_fdset);
2338 }
2339}
2340
Corey Bryantba1c0482012-08-14 16:43:43 -04002341AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2342 const char *opaque, Error **errp)
2343{
2344 int fd;
2345 Monitor *mon = cur_mon;
Corey Bryantba1c0482012-08-14 16:43:43 -04002346 AddfdInfo *fdinfo;
2347
2348 fd = qemu_chr_fe_get_msgfd(mon->chr);
2349 if (fd == -1) {
2350 error_set(errp, QERR_FD_NOT_SUPPLIED);
2351 goto error;
2352 }
2353
Corey Bryante446f702012-10-18 15:19:32 -04002354 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2355 has_opaque, opaque, errp);
2356 if (fdinfo) {
2357 return fdinfo;
Corey Bryant9ac54af2012-10-18 15:19:31 -04002358 }
2359
Corey Bryantba1c0482012-08-14 16:43:43 -04002360error:
2361 if (fd != -1) {
2362 close(fd);
2363 }
2364 return NULL;
2365}
2366
2367void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2368{
2369 MonFdset *mon_fdset;
2370 MonFdsetFd *mon_fdset_fd;
2371 char fd_str[60];
2372
2373 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2374 if (mon_fdset->id != fdset_id) {
2375 continue;
2376 }
2377 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2378 if (has_fd) {
2379 if (mon_fdset_fd->fd != fd) {
2380 continue;
2381 }
2382 mon_fdset_fd->removed = true;
2383 break;
2384 } else {
2385 mon_fdset_fd->removed = true;
2386 }
2387 }
2388 if (has_fd && !mon_fdset_fd) {
2389 goto error;
2390 }
2391 monitor_fdset_cleanup(mon_fdset);
2392 return;
2393 }
2394
2395error:
2396 if (has_fd) {
2397 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2398 fdset_id, fd);
2399 } else {
2400 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2401 }
2402 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2403}
2404
2405FdsetInfoList *qmp_query_fdsets(Error **errp)
2406{
2407 MonFdset *mon_fdset;
2408 MonFdsetFd *mon_fdset_fd;
2409 FdsetInfoList *fdset_list = NULL;
2410
2411 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2412 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2413 FdsetFdInfoList *fdsetfd_list = NULL;
2414
2415 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2416 fdset_info->value->fdset_id = mon_fdset->id;
2417
2418 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2419 FdsetFdInfoList *fdsetfd_info;
2420
2421 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2422 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2423 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2424 if (mon_fdset_fd->opaque) {
2425 fdsetfd_info->value->has_opaque = true;
2426 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2427 } else {
2428 fdsetfd_info->value->has_opaque = false;
2429 }
2430
2431 fdsetfd_info->next = fdsetfd_list;
2432 fdsetfd_list = fdsetfd_info;
2433 }
2434
2435 fdset_info->value->fds = fdsetfd_list;
2436
2437 fdset_info->next = fdset_list;
2438 fdset_list = fdset_info;
2439 }
2440
2441 return fdset_list;
2442}
2443
Corey Bryante446f702012-10-18 15:19:32 -04002444AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2445 bool has_opaque, const char *opaque,
2446 Error **errp)
2447{
2448 MonFdset *mon_fdset = NULL;
2449 MonFdsetFd *mon_fdset_fd;
2450 AddfdInfo *fdinfo;
2451
2452 if (has_fdset_id) {
2453 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2454 /* Break if match found or match impossible due to ordering by ID */
2455 if (fdset_id <= mon_fdset->id) {
2456 if (fdset_id < mon_fdset->id) {
2457 mon_fdset = NULL;
2458 }
2459 break;
2460 }
2461 }
2462 }
2463
2464 if (mon_fdset == NULL) {
2465 int64_t fdset_id_prev = -1;
2466 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2467
2468 if (has_fdset_id) {
2469 if (fdset_id < 0) {
2470 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2471 "a non-negative value");
2472 return NULL;
2473 }
2474 /* Use specified fdset ID */
2475 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2476 mon_fdset_cur = mon_fdset;
2477 if (fdset_id < mon_fdset_cur->id) {
2478 break;
2479 }
2480 }
2481 } else {
2482 /* Use first available fdset ID */
2483 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2484 mon_fdset_cur = mon_fdset;
2485 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2486 fdset_id_prev = mon_fdset_cur->id;
2487 continue;
2488 }
2489 break;
2490 }
2491 }
2492
2493 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2494 if (has_fdset_id) {
2495 mon_fdset->id = fdset_id;
2496 } else {
2497 mon_fdset->id = fdset_id_prev + 1;
2498 }
2499
2500 /* The fdset list is ordered by fdset ID */
2501 if (!mon_fdset_cur) {
2502 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2503 } else if (mon_fdset->id < mon_fdset_cur->id) {
2504 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2505 } else {
2506 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2507 }
2508 }
2509
2510 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2511 mon_fdset_fd->fd = fd;
2512 mon_fdset_fd->removed = false;
2513 if (has_opaque) {
2514 mon_fdset_fd->opaque = g_strdup(opaque);
2515 }
2516 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2517
2518 fdinfo = g_malloc0(sizeof(*fdinfo));
2519 fdinfo->fdset_id = mon_fdset->id;
2520 fdinfo->fd = mon_fdset_fd->fd;
2521
2522 return fdinfo;
2523}
2524
Corey Bryantadb696f2012-08-14 16:43:47 -04002525int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2526{
Blue Swirlb2dc64c2012-08-18 20:14:54 +00002527#ifndef _WIN32
Corey Bryantadb696f2012-08-14 16:43:47 -04002528 MonFdset *mon_fdset;
2529 MonFdsetFd *mon_fdset_fd;
2530 int mon_fd_flags;
2531
Corey Bryantadb696f2012-08-14 16:43:47 -04002532 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2533 if (mon_fdset->id != fdset_id) {
2534 continue;
2535 }
2536 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2537 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2538 if (mon_fd_flags == -1) {
2539 return -1;
2540 }
2541
2542 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2543 return mon_fdset_fd->fd;
2544 }
2545 }
2546 errno = EACCES;
2547 return -1;
2548 }
2549#endif
2550
2551 errno = ENOENT;
2552 return -1;
2553}
2554
2555int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2556{
2557 MonFdset *mon_fdset;
2558 MonFdsetFd *mon_fdset_fd_dup;
2559
2560 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2561 if (mon_fdset->id != fdset_id) {
2562 continue;
2563 }
2564 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2565 if (mon_fdset_fd_dup->fd == dup_fd) {
2566 return -1;
2567 }
2568 }
2569 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2570 mon_fdset_fd_dup->fd = dup_fd;
2571 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2572 return 0;
2573 }
2574 return -1;
2575}
2576
2577static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2578{
2579 MonFdset *mon_fdset;
2580 MonFdsetFd *mon_fdset_fd_dup;
2581
2582 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2583 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2584 if (mon_fdset_fd_dup->fd == dup_fd) {
2585 if (remove) {
2586 QLIST_REMOVE(mon_fdset_fd_dup, next);
2587 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2588 monitor_fdset_cleanup(mon_fdset);
2589 }
2590 }
2591 return mon_fdset->id;
2592 }
2593 }
2594 }
2595 return -1;
2596}
2597
2598int monitor_fdset_dup_fd_find(int dup_fd)
2599{
2600 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2601}
2602
2603int monitor_fdset_dup_fd_remove(int dup_fd)
2604{
2605 return monitor_fdset_dup_fd_find_remove(dup_fd, true);
2606}
2607
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002608int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2609{
2610 int fd;
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002611 Error *local_err = NULL;
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002612
2613 if (!qemu_isdigit(fdname[0]) && mon) {
2614
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002615 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002616 if (fd == -1) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002617 qerror_report_err(local_err);
2618 error_free(local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002619 return -1;
2620 }
2621 } else {
2622 fd = qemu_parse_fd(fdname);
2623 }
2624
2625 return fd;
2626}
2627
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002628/* Please update hmp-commands.hx when adding or changing commands */
Wayne Xia816f8922011-10-12 11:32:41 +08002629static mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002630 {
2631 .name = "version",
2632 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002633 .params = "",
2634 .help = "show the version of QEMU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002635 .mhandler.cmd = hmp_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002636 },
2637 {
2638 .name = "network",
2639 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002640 .params = "",
2641 .help = "show the network state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002642 .mhandler.cmd = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002643 },
2644 {
2645 .name = "chardev",
2646 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002647 .params = "",
2648 .help = "show the character devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002649 .mhandler.cmd = hmp_info_chardev,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002650 },
2651 {
2652 .name = "block",
Wenchao Xiae73fe2b2013-06-06 12:28:01 +08002653 .args_type = "verbose:-v,device:B?",
2654 .params = "[-v] [device]",
2655 .help = "show info of one block device or all block devices "
2656 "(and details of images with -v option)",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002657 .mhandler.cmd = hmp_info_block,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002658 },
2659 {
2660 .name = "blockstats",
2661 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002662 .params = "",
2663 .help = "show block device statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002664 .mhandler.cmd = hmp_info_blockstats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002665 },
2666 {
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002667 .name = "block-jobs",
2668 .args_type = "",
2669 .params = "",
2670 .help = "show progress of ongoing block device operations",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002671 .mhandler.cmd = hmp_info_block_jobs,
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002672 },
2673 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002674 .name = "registers",
2675 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002676 .params = "",
2677 .help = "show the cpu registers",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002678 .mhandler.cmd = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002679 },
2680 {
2681 .name = "cpus",
2682 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002683 .params = "",
2684 .help = "show infos for each CPU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002685 .mhandler.cmd = hmp_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002686 },
2687 {
2688 .name = "history",
2689 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002690 .params = "",
2691 .help = "show the command line history",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002692 .mhandler.cmd = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002693 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002694#if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2695 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002696 {
2697 .name = "irq",
2698 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002699 .params = "",
2700 .help = "show the interrupts statistics (if available)",
Jan Kiszka661f1922011-10-16 11:53:13 +02002701#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002702 .mhandler.cmd = sun4m_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002703#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002704 .mhandler.cmd = lm32_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002705#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002706 .mhandler.cmd = irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002707#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002708 },
2709 {
2710 .name = "pic",
2711 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002712 .params = "",
2713 .help = "show i8259 (PIC) state",
Jan Kiszka661f1922011-10-16 11:53:13 +02002714#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002715 .mhandler.cmd = sun4m_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002716#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002717 .mhandler.cmd = lm32_do_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002718#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002719 .mhandler.cmd = pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002720#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002721 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002722#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002723 {
2724 .name = "pci",
2725 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002726 .params = "",
2727 .help = "show PCI info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002728 .mhandler.cmd = hmp_info_pci,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002729 },
Scott Woodbebabbc2011-08-18 10:38:42 +00002730#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
Max Filippov692f7372012-01-07 20:02:40 +04002731 defined(TARGET_PPC) || defined(TARGET_XTENSA)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002732 {
2733 .name = "tlb",
2734 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002735 .params = "",
2736 .help = "show virtual to physical memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002737 .mhandler.cmd = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002738 },
aurel327c664e22009-03-03 06:12:22 +00002739#endif
2740#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002741 {
2742 .name = "mem",
2743 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002744 .params = "",
2745 .help = "show the active virtual memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002746 .mhandler.cmd = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002747 },
bellardb86bda52004-09-18 19:32:46 +00002748#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002749 {
Blue Swirl314e2982011-09-11 20:22:05 +00002750 .name = "mtree",
2751 .args_type = "",
2752 .params = "",
2753 .help = "show memory tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002754 .mhandler.cmd = do_info_mtree,
Blue Swirl314e2982011-09-11 20:22:05 +00002755 },
2756 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002757 .name = "jit",
2758 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002759 .params = "",
2760 .help = "show dynamic compiler info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002761 .mhandler.cmd = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002762 },
2763 {
2764 .name = "kvm",
2765 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002766 .params = "",
2767 .help = "show KVM information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002768 .mhandler.cmd = hmp_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002769 },
2770 {
2771 .name = "numa",
2772 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002773 .params = "",
2774 .help = "show NUMA information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002775 .mhandler.cmd = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002776 },
2777 {
2778 .name = "usb",
2779 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002780 .params = "",
2781 .help = "show guest USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002782 .mhandler.cmd = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002783 },
2784 {
2785 .name = "usbhost",
2786 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002787 .params = "",
2788 .help = "show host USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002789 .mhandler.cmd = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002790 },
2791 {
2792 .name = "profile",
2793 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002794 .params = "",
2795 .help = "show profiling information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002796 .mhandler.cmd = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002797 },
2798 {
2799 .name = "capture",
2800 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002801 .params = "",
2802 .help = "show capture information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002803 .mhandler.cmd = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002804 },
2805 {
2806 .name = "snapshots",
2807 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002808 .params = "",
2809 .help = "show the currently saved VM snapshots",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002810 .mhandler.cmd = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002811 },
2812 {
2813 .name = "status",
2814 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002815 .params = "",
2816 .help = "show the current VM status (running|paused)",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002817 .mhandler.cmd = hmp_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002818 },
2819 {
2820 .name = "pcmcia",
2821 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002822 .params = "",
2823 .help = "show guest PCMCIA status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002824 .mhandler.cmd = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002825 },
2826 {
2827 .name = "mice",
2828 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002829 .params = "",
2830 .help = "show which guest mouse is receiving events",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002831 .mhandler.cmd = hmp_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002832 },
2833 {
2834 .name = "vnc",
2835 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002836 .params = "",
2837 .help = "show the vnc server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002838 .mhandler.cmd = hmp_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002839 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002840#if defined(CONFIG_SPICE)
2841 {
2842 .name = "spice",
2843 .args_type = "",
2844 .params = "",
2845 .help = "show the spice server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002846 .mhandler.cmd = hmp_info_spice,
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002847 },
2848#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002849 {
2850 .name = "name",
2851 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002852 .params = "",
2853 .help = "show the current VM name",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002854 .mhandler.cmd = hmp_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002855 },
2856 {
2857 .name = "uuid",
2858 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002859 .params = "",
2860 .help = "show the current VM UUID",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002861 .mhandler.cmd = hmp_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002862 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002863 {
2864 .name = "cpustats",
2865 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002866 .params = "",
2867 .help = "show CPU statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002868 .mhandler.cmd = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002869 },
blueswir131a60e22007-10-26 18:42:59 +00002870#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002871 {
2872 .name = "usernet",
2873 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002874 .params = "",
2875 .help = "show user network stack connection states",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002876 .mhandler.cmd = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002877 },
blueswir131a60e22007-10-26 18:42:59 +00002878#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002879 {
2880 .name = "migrate",
2881 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002882 .params = "",
2883 .help = "show migration status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002884 .mhandler.cmd = hmp_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002885 },
2886 {
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002887 .name = "migrate_capabilities",
2888 .args_type = "",
2889 .params = "",
2890 .help = "show current migration capabilities",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002891 .mhandler.cmd = hmp_info_migrate_capabilities,
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002892 },
2893 {
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002894 .name = "migrate_cache_size",
2895 .args_type = "",
2896 .params = "",
2897 .help = "show current migration xbzrle cache size",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002898 .mhandler.cmd = hmp_info_migrate_cache_size,
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002899 },
2900 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002901 .name = "balloon",
2902 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002903 .params = "",
2904 .help = "show balloon information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002905 .mhandler.cmd = hmp_info_balloon,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002906 },
2907 {
2908 .name = "qtree",
2909 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002910 .params = "",
2911 .help = "show device tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002912 .mhandler.cmd = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002913 },
2914 {
2915 .name = "qdm",
2916 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002917 .params = "",
2918 .help = "show qdev device model list",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002919 .mhandler.cmd = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002920 },
2921 {
2922 .name = "roms",
2923 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002924 .params = "",
2925 .help = "show roms",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002926 .mhandler.cmd = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002927 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05302928 {
2929 .name = "trace-events",
2930 .args_type = "",
2931 .params = "",
2932 .help = "show available trace-events & their state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002933 .mhandler.cmd = do_trace_print_events,
Prerna Saxena22890ab2010-06-24 17:04:53 +05302934 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002935 {
Stefan Bergerd1a0cf72013-02-27 12:47:49 -05002936 .name = "tpm",
2937 .args_type = "",
2938 .params = "",
2939 .help = "show the TPM device",
2940 .mhandler.cmd = hmp_info_tpm,
2941 },
2942 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002943 .name = NULL,
2944 },
bellard9dc39cb2004-03-14 21:38:27 +00002945};
2946
Wenchao Xiaa13ced52013-01-14 14:06:28 +08002947/* mon_cmds and info_cmds would be sorted at runtime */
2948static mon_cmd_t mon_cmds[] = {
2949#include "hmp-commands.h"
2950 { NULL, NULL, },
2951};
2952
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002953static const mon_cmd_t qmp_cmds[] = {
Anthony Liguorie3193602011-09-02 12:34:47 -05002954#include "qmp-commands-old.h"
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002955 { /* NULL */ },
2956};
2957
bellard9307c4c2004-04-04 12:57:25 +00002958/*******************************************************************/
2959
2960static const char *pch;
Peter Maydell6ab7e542013-02-20 15:21:09 +00002961static sigjmp_buf expr_env;
bellard9307c4c2004-04-04 12:57:25 +00002962
bellard92a31b12005-02-10 22:00:52 +00002963#define MD_TLONG 0
2964#define MD_I32 1
2965
bellard9307c4c2004-04-04 12:57:25 +00002966typedef struct MonitorDef {
2967 const char *name;
2968 int offset;
blueswir18662d652008-10-02 18:32:44 +00002969 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002970 int type;
bellard9307c4c2004-04-04 12:57:25 +00002971} MonitorDef;
2972
bellard57206fd2004-04-25 18:54:52 +00002973#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002974static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002975{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002976 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002977 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002978}
2979#endif
2980
bellarda541f292004-04-12 20:39:29 +00002981#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002982static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002983{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002984 CPUArchState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002985 unsigned int u;
2986 int i;
2987
2988 u = 0;
2989 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002990 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002991
2992 return u;
2993}
2994
blueswir18662d652008-10-02 18:32:44 +00002995static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002996{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002997 CPUArchState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00002998 return env->msr;
bellarda541f292004-04-12 20:39:29 +00002999}
3000
blueswir18662d652008-10-02 18:32:44 +00003001static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00003002{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003003 CPUArchState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00003004 return env->xer;
bellarda541f292004-04-12 20:39:29 +00003005}
bellard9fddaa02004-05-21 12:59:32 +00003006
blueswir18662d652008-10-02 18:32:44 +00003007static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003008{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003009 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003010 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00003011}
3012
blueswir18662d652008-10-02 18:32:44 +00003013static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003014{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003015 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003016 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00003017}
3018
blueswir18662d652008-10-02 18:32:44 +00003019static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003020{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003021 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003022 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00003023}
bellarda541f292004-04-12 20:39:29 +00003024#endif
3025
bellarde95c8d52004-09-30 22:22:08 +00003026#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00003027#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00003028static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003029{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003030 CPUArchState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00003031
3032 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00003033}
bellard7b936c02005-10-30 17:05:13 +00003034#endif
bellarde95c8d52004-09-30 22:22:08 +00003035
blueswir18662d652008-10-02 18:32:44 +00003036static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003037{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003038 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003039 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00003040}
3041#endif
3042
blueswir18662d652008-10-02 18:32:44 +00003043static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00003044#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00003045
3046#define SEG(name, seg) \
Andreas Färbere59d1672012-02-16 00:40:47 +01003047 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
3048 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
3049 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00003050
Andreas Färbere59d1672012-02-16 00:40:47 +01003051 { "eax", offsetof(CPUX86State, regs[0]) },
3052 { "ecx", offsetof(CPUX86State, regs[1]) },
3053 { "edx", offsetof(CPUX86State, regs[2]) },
3054 { "ebx", offsetof(CPUX86State, regs[3]) },
3055 { "esp|sp", offsetof(CPUX86State, regs[4]) },
3056 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
3057 { "esi", offsetof(CPUX86State, regs[6]) },
3058 { "edi", offsetof(CPUX86State, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00003059#ifdef TARGET_X86_64
Andreas Färbere59d1672012-02-16 00:40:47 +01003060 { "r8", offsetof(CPUX86State, regs[8]) },
3061 { "r9", offsetof(CPUX86State, regs[9]) },
3062 { "r10", offsetof(CPUX86State, regs[10]) },
3063 { "r11", offsetof(CPUX86State, regs[11]) },
3064 { "r12", offsetof(CPUX86State, regs[12]) },
3065 { "r13", offsetof(CPUX86State, regs[13]) },
3066 { "r14", offsetof(CPUX86State, regs[14]) },
3067 { "r15", offsetof(CPUX86State, regs[15]) },
bellard92a31b12005-02-10 22:00:52 +00003068#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003069 { "eflags", offsetof(CPUX86State, eflags) },
3070 { "eip", offsetof(CPUX86State, eip) },
bellard57206fd2004-04-25 18:54:52 +00003071 SEG("cs", R_CS)
3072 SEG("ds", R_DS)
3073 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00003074 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00003075 SEG("fs", R_FS)
3076 SEG("gs", R_GS)
3077 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00003078#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00003079 /* General purpose registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003080 { "r0", offsetof(CPUPPCState, gpr[0]) },
3081 { "r1", offsetof(CPUPPCState, gpr[1]) },
3082 { "r2", offsetof(CPUPPCState, gpr[2]) },
3083 { "r3", offsetof(CPUPPCState, gpr[3]) },
3084 { "r4", offsetof(CPUPPCState, gpr[4]) },
3085 { "r5", offsetof(CPUPPCState, gpr[5]) },
3086 { "r6", offsetof(CPUPPCState, gpr[6]) },
3087 { "r7", offsetof(CPUPPCState, gpr[7]) },
3088 { "r8", offsetof(CPUPPCState, gpr[8]) },
3089 { "r9", offsetof(CPUPPCState, gpr[9]) },
3090 { "r10", offsetof(CPUPPCState, gpr[10]) },
3091 { "r11", offsetof(CPUPPCState, gpr[11]) },
3092 { "r12", offsetof(CPUPPCState, gpr[12]) },
3093 { "r13", offsetof(CPUPPCState, gpr[13]) },
3094 { "r14", offsetof(CPUPPCState, gpr[14]) },
3095 { "r15", offsetof(CPUPPCState, gpr[15]) },
3096 { "r16", offsetof(CPUPPCState, gpr[16]) },
3097 { "r17", offsetof(CPUPPCState, gpr[17]) },
3098 { "r18", offsetof(CPUPPCState, gpr[18]) },
3099 { "r19", offsetof(CPUPPCState, gpr[19]) },
3100 { "r20", offsetof(CPUPPCState, gpr[20]) },
3101 { "r21", offsetof(CPUPPCState, gpr[21]) },
3102 { "r22", offsetof(CPUPPCState, gpr[22]) },
3103 { "r23", offsetof(CPUPPCState, gpr[23]) },
3104 { "r24", offsetof(CPUPPCState, gpr[24]) },
3105 { "r25", offsetof(CPUPPCState, gpr[25]) },
3106 { "r26", offsetof(CPUPPCState, gpr[26]) },
3107 { "r27", offsetof(CPUPPCState, gpr[27]) },
3108 { "r28", offsetof(CPUPPCState, gpr[28]) },
3109 { "r29", offsetof(CPUPPCState, gpr[29]) },
3110 { "r30", offsetof(CPUPPCState, gpr[30]) },
3111 { "r31", offsetof(CPUPPCState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00003112 /* Floating point registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003113 { "f0", offsetof(CPUPPCState, fpr[0]) },
3114 { "f1", offsetof(CPUPPCState, fpr[1]) },
3115 { "f2", offsetof(CPUPPCState, fpr[2]) },
3116 { "f3", offsetof(CPUPPCState, fpr[3]) },
3117 { "f4", offsetof(CPUPPCState, fpr[4]) },
3118 { "f5", offsetof(CPUPPCState, fpr[5]) },
3119 { "f6", offsetof(CPUPPCState, fpr[6]) },
3120 { "f7", offsetof(CPUPPCState, fpr[7]) },
3121 { "f8", offsetof(CPUPPCState, fpr[8]) },
3122 { "f9", offsetof(CPUPPCState, fpr[9]) },
3123 { "f10", offsetof(CPUPPCState, fpr[10]) },
3124 { "f11", offsetof(CPUPPCState, fpr[11]) },
3125 { "f12", offsetof(CPUPPCState, fpr[12]) },
3126 { "f13", offsetof(CPUPPCState, fpr[13]) },
3127 { "f14", offsetof(CPUPPCState, fpr[14]) },
3128 { "f15", offsetof(CPUPPCState, fpr[15]) },
3129 { "f16", offsetof(CPUPPCState, fpr[16]) },
3130 { "f17", offsetof(CPUPPCState, fpr[17]) },
3131 { "f18", offsetof(CPUPPCState, fpr[18]) },
3132 { "f19", offsetof(CPUPPCState, fpr[19]) },
3133 { "f20", offsetof(CPUPPCState, fpr[20]) },
3134 { "f21", offsetof(CPUPPCState, fpr[21]) },
3135 { "f22", offsetof(CPUPPCState, fpr[22]) },
3136 { "f23", offsetof(CPUPPCState, fpr[23]) },
3137 { "f24", offsetof(CPUPPCState, fpr[24]) },
3138 { "f25", offsetof(CPUPPCState, fpr[25]) },
3139 { "f26", offsetof(CPUPPCState, fpr[26]) },
3140 { "f27", offsetof(CPUPPCState, fpr[27]) },
3141 { "f28", offsetof(CPUPPCState, fpr[28]) },
3142 { "f29", offsetof(CPUPPCState, fpr[29]) },
3143 { "f30", offsetof(CPUPPCState, fpr[30]) },
3144 { "f31", offsetof(CPUPPCState, fpr[31]) },
3145 { "fpscr", offsetof(CPUPPCState, fpscr) },
j_mayerff937db2007-09-19 05:49:13 +00003146 /* Next instruction pointer */
Andreas Färbere59d1672012-02-16 00:40:47 +01003147 { "nip|pc", offsetof(CPUPPCState, nip) },
3148 { "lr", offsetof(CPUPPCState, lr) },
3149 { "ctr", offsetof(CPUPPCState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00003150 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00003151 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00003152 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00003153 { "msr", 0, &monitor_get_msr, },
3154 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00003155 { "tbu", 0, &monitor_get_tbu, },
3156 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00003157 /* Segment registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003158 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
3159 { "sr0", offsetof(CPUPPCState, sr[0]) },
3160 { "sr1", offsetof(CPUPPCState, sr[1]) },
3161 { "sr2", offsetof(CPUPPCState, sr[2]) },
3162 { "sr3", offsetof(CPUPPCState, sr[3]) },
3163 { "sr4", offsetof(CPUPPCState, sr[4]) },
3164 { "sr5", offsetof(CPUPPCState, sr[5]) },
3165 { "sr6", offsetof(CPUPPCState, sr[6]) },
3166 { "sr7", offsetof(CPUPPCState, sr[7]) },
3167 { "sr8", offsetof(CPUPPCState, sr[8]) },
3168 { "sr9", offsetof(CPUPPCState, sr[9]) },
3169 { "sr10", offsetof(CPUPPCState, sr[10]) },
3170 { "sr11", offsetof(CPUPPCState, sr[11]) },
3171 { "sr12", offsetof(CPUPPCState, sr[12]) },
3172 { "sr13", offsetof(CPUPPCState, sr[13]) },
3173 { "sr14", offsetof(CPUPPCState, sr[14]) },
3174 { "sr15", offsetof(CPUPPCState, sr[15]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003175 /* Too lazy to put BATs... */
Andreas Färbere59d1672012-02-16 00:40:47 +01003176 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003177
Andreas Färbere59d1672012-02-16 00:40:47 +01003178 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3179 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
Tom Musta04f1f782013-09-25 17:41:13 +10003180 { "dar", offsetof(CPUPPCState, spr[SPR_DAR]) },
3181 { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR]) },
3182 { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR]) },
Andreas Färbere59d1672012-02-16 00:40:47 +01003183 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3184 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3185 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3186 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3187 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3188 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3189 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3190 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3191 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3192 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3193 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3194 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3195 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3196 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3197 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3198 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3199 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3200 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3201 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3202 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3203 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3204 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3205 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3206 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3207 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3208 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3209 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3210 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3211 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3212 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3213 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3214 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3215 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3216 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3217 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3218 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3219 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3220 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3221 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3222 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3223 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3224 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3225 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3226 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3227 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3228 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3229 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3230 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3231 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3232 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3233 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3234 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3235 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3236 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3237 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3238 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3239 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3240 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3241 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3242 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3243 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3244 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3245 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3246 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003247
bellarde95c8d52004-09-30 22:22:08 +00003248#elif defined(TARGET_SPARC)
Andreas Färbere59d1672012-02-16 00:40:47 +01003249 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3250 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3251 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3252 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3253 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3254 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3255 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3256 { "g7", offsetof(CPUSPARCState, gregs[7]) },
bellarde95c8d52004-09-30 22:22:08 +00003257 { "o0", 0, monitor_get_reg },
3258 { "o1", 1, monitor_get_reg },
3259 { "o2", 2, monitor_get_reg },
3260 { "o3", 3, monitor_get_reg },
3261 { "o4", 4, monitor_get_reg },
3262 { "o5", 5, monitor_get_reg },
3263 { "o6", 6, monitor_get_reg },
3264 { "o7", 7, monitor_get_reg },
3265 { "l0", 8, monitor_get_reg },
3266 { "l1", 9, monitor_get_reg },
3267 { "l2", 10, monitor_get_reg },
3268 { "l3", 11, monitor_get_reg },
3269 { "l4", 12, monitor_get_reg },
3270 { "l5", 13, monitor_get_reg },
3271 { "l6", 14, monitor_get_reg },
3272 { "l7", 15, monitor_get_reg },
3273 { "i0", 16, monitor_get_reg },
3274 { "i1", 17, monitor_get_reg },
3275 { "i2", 18, monitor_get_reg },
3276 { "i3", 19, monitor_get_reg },
3277 { "i4", 20, monitor_get_reg },
3278 { "i5", 21, monitor_get_reg },
3279 { "i6", 22, monitor_get_reg },
3280 { "i7", 23, monitor_get_reg },
Andreas Färbere59d1672012-02-16 00:40:47 +01003281 { "pc", offsetof(CPUSPARCState, pc) },
3282 { "npc", offsetof(CPUSPARCState, npc) },
3283 { "y", offsetof(CPUSPARCState, y) },
bellard7b936c02005-10-30 17:05:13 +00003284#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003285 { "psr", 0, &monitor_get_psr, },
Andreas Färbere59d1672012-02-16 00:40:47 +01003286 { "wim", offsetof(CPUSPARCState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003287#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003288 { "tbr", offsetof(CPUSPARCState, tbr) },
3289 { "fsr", offsetof(CPUSPARCState, fsr) },
3290 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3291 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3292 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3293 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3294 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3295 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3296 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3297 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3298 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3299 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3300 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3301 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3302 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3303 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3304 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3305 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3306 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3307 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3308 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3309 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3310 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3311 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3312 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3313 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3314 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3315 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3316 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3317 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3318 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3319 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3320 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3321 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
bellard7b936c02005-10-30 17:05:13 +00003322#ifdef TARGET_SPARC64
Andreas Färbere59d1672012-02-16 00:40:47 +01003323 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3324 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3325 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3326 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3327 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3328 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3329 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3330 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3331 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3332 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3333 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3334 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3335 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3336 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3337 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3338 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3339 { "asi", offsetof(CPUSPARCState, asi) },
3340 { "pstate", offsetof(CPUSPARCState, pstate) },
3341 { "cansave", offsetof(CPUSPARCState, cansave) },
3342 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3343 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3344 { "wstate", offsetof(CPUSPARCState, wstate) },
3345 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3346 { "fprs", offsetof(CPUSPARCState, fprs) },
bellard7b936c02005-10-30 17:05:13 +00003347#endif
bellard9307c4c2004-04-04 12:57:25 +00003348#endif
3349 { NULL },
3350};
3351
Stefan Weil9c3175c2013-08-22 21:30:09 +02003352static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
3353expr_error(Monitor *mon, const char *fmt, ...)
bellard9dc39cb2004-03-14 21:38:27 +00003354{
Fam Zheng277acfe2013-08-20 10:58:21 +08003355 va_list ap;
3356 va_start(ap, fmt);
3357 monitor_vprintf(mon, fmt, ap);
3358 monitor_printf(mon, "\n");
3359 va_end(ap);
Peter Maydell6ab7e542013-02-20 15:21:09 +00003360 siglongjmp(expr_env, 1);
bellard9307c4c2004-04-04 12:57:25 +00003361}
3362
Markus Armbruster09b94182010-01-20 13:07:30 +01003363/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003364static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003365{
blueswir18662d652008-10-02 18:32:44 +00003366 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003367 void *ptr;
3368
bellard9307c4c2004-04-04 12:57:25 +00003369 for(md = monitor_defs; md->name != NULL; md++) {
3370 if (compare_cmd(name, md->name)) {
3371 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003372 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003373 } else {
Andreas Färber9349b4f2012-03-14 01:38:32 +01003374 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003375 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003376 switch(md->type) {
3377 case MD_I32:
3378 *pval = *(int32_t *)ptr;
3379 break;
3380 case MD_TLONG:
3381 *pval = *(target_long *)ptr;
3382 break;
3383 default:
3384 *pval = 0;
3385 break;
3386 }
bellard9307c4c2004-04-04 12:57:25 +00003387 }
3388 return 0;
3389 }
3390 }
3391 return -1;
3392}
3393
3394static void next(void)
3395{
Blue Swirl660f11b2009-07-31 21:16:51 +00003396 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003397 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003398 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003399 pch++;
3400 }
3401}
3402
aliguori376253e2009-03-05 23:01:23 +00003403static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003404
aliguori376253e2009-03-05 23:01:23 +00003405static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003406{
blueswir1c2efc952007-09-25 17:28:42 +00003407 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003408 char *p;
bellard6a00d602005-11-21 23:25:50 +00003409 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003410
3411 switch(*pch) {
3412 case '+':
3413 next();
aliguori376253e2009-03-05 23:01:23 +00003414 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003415 break;
3416 case '-':
3417 next();
aliguori376253e2009-03-05 23:01:23 +00003418 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003419 break;
3420 case '~':
3421 next();
aliguori376253e2009-03-05 23:01:23 +00003422 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003423 break;
3424 case '(':
3425 next();
aliguori376253e2009-03-05 23:01:23 +00003426 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003427 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003428 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003429 }
3430 next();
3431 break;
bellard81d09122004-07-14 17:21:37 +00003432 case '\'':
3433 pch++;
3434 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003435 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003436 n = *pch;
3437 pch++;
3438 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003439 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003440 next();
3441 break;
bellard9307c4c2004-04-04 12:57:25 +00003442 case '$':
3443 {
3444 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003445 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003446
bellard9307c4c2004-04-04 12:57:25 +00003447 pch++;
3448 q = buf;
3449 while ((*pch >= 'a' && *pch <= 'z') ||
3450 (*pch >= 'A' && *pch <= 'Z') ||
3451 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003452 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003453 if ((q - buf) < sizeof(buf) - 1)
3454 *q++ = *pch;
3455 pch++;
3456 }
blueswir1cd390082008-11-16 13:53:32 +00003457 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003458 pch++;
3459 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003460 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003461 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003462 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003463 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003464 }
3465 break;
3466 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003467 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003468 n = 0;
3469 break;
3470 default:
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003471 errno = 0;
bellard4f4fbf72006-06-25 18:28:12 +00003472 n = strtoull(pch, &p, 0);
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003473 if (errno == ERANGE) {
3474 expr_error(mon, "number too large");
3475 }
bellard9307c4c2004-04-04 12:57:25 +00003476 if (pch == p) {
Fam Zheng277acfe2013-08-20 10:58:21 +08003477 expr_error(mon, "invalid char '%c' in expression", *p);
bellard9307c4c2004-04-04 12:57:25 +00003478 }
3479 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003480 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003481 pch++;
3482 break;
3483 }
3484 return n;
3485}
3486
3487
aliguori376253e2009-03-05 23:01:23 +00003488static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003489{
blueswir1c2efc952007-09-25 17:28:42 +00003490 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003491 int op;
ths3b46e622007-09-17 08:09:54 +00003492
aliguori376253e2009-03-05 23:01:23 +00003493 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003494 for(;;) {
3495 op = *pch;
3496 if (op != '*' && op != '/' && op != '%')
3497 break;
3498 next();
aliguori376253e2009-03-05 23:01:23 +00003499 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003500 switch(op) {
3501 default:
3502 case '*':
3503 val *= val2;
3504 break;
3505 case '/':
3506 case '%':
ths5fafdf22007-09-16 21:08:06 +00003507 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003508 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003509 if (op == '/')
3510 val /= val2;
3511 else
3512 val %= val2;
3513 break;
3514 }
3515 }
3516 return val;
3517}
3518
aliguori376253e2009-03-05 23:01:23 +00003519static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003520{
blueswir1c2efc952007-09-25 17:28:42 +00003521 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003522 int op;
bellard9307c4c2004-04-04 12:57:25 +00003523
aliguori376253e2009-03-05 23:01:23 +00003524 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003525 for(;;) {
3526 op = *pch;
3527 if (op != '&' && op != '|' && op != '^')
3528 break;
3529 next();
aliguori376253e2009-03-05 23:01:23 +00003530 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003531 switch(op) {
3532 default:
3533 case '&':
3534 val &= val2;
3535 break;
3536 case '|':
3537 val |= val2;
3538 break;
3539 case '^':
3540 val ^= val2;
3541 break;
3542 }
3543 }
3544 return val;
3545}
3546
aliguori376253e2009-03-05 23:01:23 +00003547static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003548{
blueswir1c2efc952007-09-25 17:28:42 +00003549 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003550 int op;
bellard9307c4c2004-04-04 12:57:25 +00003551
aliguori376253e2009-03-05 23:01:23 +00003552 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003553 for(;;) {
3554 op = *pch;
3555 if (op != '+' && op != '-')
3556 break;
3557 next();
aliguori376253e2009-03-05 23:01:23 +00003558 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003559 if (op == '+')
3560 val += val2;
3561 else
3562 val -= val2;
3563 }
3564 return val;
3565}
3566
aliguori376253e2009-03-05 23:01:23 +00003567static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003568{
3569 pch = *pp;
Peter Maydell6ab7e542013-02-20 15:21:09 +00003570 if (sigsetjmp(expr_env, 0)) {
bellard9307c4c2004-04-04 12:57:25 +00003571 *pp = pch;
3572 return -1;
3573 }
blueswir1cd390082008-11-16 13:53:32 +00003574 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003575 pch++;
aliguori376253e2009-03-05 23:01:23 +00003576 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003577 *pp = pch;
3578 return 0;
3579}
3580
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003581static int get_double(Monitor *mon, double *pval, const char **pp)
3582{
3583 const char *p = *pp;
3584 char *tailp;
3585 double d;
3586
3587 d = strtod(p, &tailp);
3588 if (tailp == p) {
3589 monitor_printf(mon, "Number expected\n");
3590 return -1;
3591 }
3592 if (d != d || d - d != 0) {
3593 /* NaN or infinity */
3594 monitor_printf(mon, "Bad number\n");
3595 return -1;
3596 }
3597 *pval = d;
3598 *pp = tailp;
3599 return 0;
3600}
3601
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003602/*
3603 * Store the command-name in cmdname, and return a pointer to
3604 * the remaining of the command string.
3605 */
3606static const char *get_command_name(const char *cmdline,
3607 char *cmdname, size_t nlen)
3608{
3609 size_t len;
3610 const char *p, *pstart;
3611
3612 p = cmdline;
3613 while (qemu_isspace(*p))
3614 p++;
3615 if (*p == '\0')
3616 return NULL;
3617 pstart = p;
3618 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3619 p++;
3620 len = p - pstart;
3621 if (len > nlen - 1)
3622 len = nlen - 1;
3623 memcpy(cmdname, pstart, len);
3624 cmdname[len] = '\0';
3625 return p;
3626}
3627
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003628/**
3629 * Read key of 'type' into 'key' and return the current
3630 * 'type' pointer.
3631 */
3632static char *key_get_info(const char *type, char **key)
3633{
3634 size_t len;
3635 char *p, *str;
3636
3637 if (*type == ',')
3638 type++;
3639
3640 p = strchr(type, ':');
3641 if (!p) {
3642 *key = NULL;
3643 return NULL;
3644 }
3645 len = p - type;
3646
Anthony Liguori7267c092011-08-20 22:09:37 -05003647 str = g_malloc(len + 1);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003648 memcpy(str, type, len);
3649 str[len] = '\0';
3650
3651 *key = str;
3652 return ++p;
3653}
3654
bellard9307c4c2004-04-04 12:57:25 +00003655static int default_fmt_format = 'x';
3656static int default_fmt_size = 4;
3657
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003658static int is_valid_option(const char *c, const char *typestr)
3659{
3660 char option[3];
3661
3662 option[0] = '-';
3663 option[1] = *c;
3664 option[2] = '\0';
3665
3666 typestr = strstr(typestr, option);
3667 return (typestr != NULL);
3668}
3669
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003670static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3671 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003672{
3673 const mon_cmd_t *cmd;
3674
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003675 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003676 if (compare_cmd(cmdname, cmd->name)) {
3677 return cmd;
3678 }
3679 }
3680
3681 return NULL;
3682}
3683
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003684static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3685{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003686 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003687}
3688
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003689/*
3690 * Parse @cmdline according to command table @table.
3691 * If @cmdline is blank, return NULL.
3692 * If it can't be parsed, report to @mon, and return NULL.
3693 * Else, insert command arguments into @qdict, and return the command.
Peter Maydell085d8132013-03-18 17:20:07 +00003694 * If a sub-command table exists, and if @cmdline contains an additional string
3695 * for a sub-command, this function will try to search the sub-command table.
3696 * If no additional string for a sub-command is present, this function will
3697 * return the command found in @table.
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003698 * Do not assume the returned command points into @table! It doesn't
3699 * when the command is a sub-command.
3700 */
Anthony Liguoric227f092009-10-01 16:12:16 -05003701static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003702 const char *cmdline,
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003703 int start,
3704 mon_cmd_t *table,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003705 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003706{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003707 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003708 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003709 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003710 char cmdname[256];
3711 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003712 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003713
3714#ifdef DEBUG
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003715 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
bellard9dc39cb2004-03-14 21:38:27 +00003716#endif
ths3b46e622007-09-17 08:09:54 +00003717
bellard9307c4c2004-04-04 12:57:25 +00003718 /* extract the command name */
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003719 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003720 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003721 return NULL;
ths3b46e622007-09-17 08:09:54 +00003722
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003723 cmd = search_dispatch_table(table, cmdname);
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003724 if (!cmd) {
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003725 monitor_printf(mon, "unknown command: '%.*s'\n",
3726 (int)(p - cmdline), cmdline);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003727 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003728 }
bellard9307c4c2004-04-04 12:57:25 +00003729
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003730 /* filter out following useless space */
3731 while (qemu_isspace(*p)) {
3732 p++;
3733 }
3734 /* search sub command */
3735 if (cmd->sub_table != NULL) {
3736 /* check if user set additional command */
3737 if (*p == '\0') {
3738 return cmd;
3739 }
3740 return monitor_parse_command(mon, cmdline, p - cmdline,
3741 cmd->sub_table, qdict);
3742 }
3743
bellard9307c4c2004-04-04 12:57:25 +00003744 /* parse the parameters */
3745 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003746 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003747 typestr = key_get_info(typestr, &key);
3748 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003749 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003750 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003751 typestr++;
3752 switch(c) {
3753 case 'F':
bellard81d09122004-07-14 17:21:37 +00003754 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003755 case 's':
3756 {
3757 int ret;
ths3b46e622007-09-17 08:09:54 +00003758
blueswir1cd390082008-11-16 13:53:32 +00003759 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003760 p++;
3761 if (*typestr == '?') {
3762 typestr++;
3763 if (*p == '\0') {
3764 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003765 break;
bellard9307c4c2004-04-04 12:57:25 +00003766 }
3767 }
3768 ret = get_str(buf, sizeof(buf), &p);
3769 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003770 switch(c) {
3771 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003772 monitor_printf(mon, "%s: filename expected\n",
3773 cmdname);
bellard81d09122004-07-14 17:21:37 +00003774 break;
3775 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003776 monitor_printf(mon, "%s: block device name expected\n",
3777 cmdname);
bellard81d09122004-07-14 17:21:37 +00003778 break;
3779 default:
aliguori376253e2009-03-05 23:01:23 +00003780 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003781 break;
3782 }
bellard9307c4c2004-04-04 12:57:25 +00003783 goto fail;
3784 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003785 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003786 }
3787 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003788 case 'O':
3789 {
3790 QemuOptsList *opts_list;
3791 QemuOpts *opts;
3792
3793 opts_list = qemu_find_opts(key);
3794 if (!opts_list || opts_list->desc->name) {
3795 goto bad_type;
3796 }
3797 while (qemu_isspace(*p)) {
3798 p++;
3799 }
3800 if (!*p)
3801 break;
3802 if (get_str(buf, sizeof(buf), &p) < 0) {
3803 goto fail;
3804 }
3805 opts = qemu_opts_parse(opts_list, buf, 1);
3806 if (!opts) {
3807 goto fail;
3808 }
3809 qemu_opts_to_qdict(opts, qdict);
3810 qemu_opts_del(opts);
3811 }
3812 break;
bellard9307c4c2004-04-04 12:57:25 +00003813 case '/':
3814 {
3815 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003816
blueswir1cd390082008-11-16 13:53:32 +00003817 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003818 p++;
3819 if (*p == '/') {
3820 /* format found */
3821 p++;
3822 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003823 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003824 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003825 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003826 count = count * 10 + (*p - '0');
3827 p++;
3828 }
3829 }
3830 size = -1;
3831 format = -1;
3832 for(;;) {
3833 switch(*p) {
3834 case 'o':
3835 case 'd':
3836 case 'u':
3837 case 'x':
3838 case 'i':
3839 case 'c':
3840 format = *p++;
3841 break;
3842 case 'b':
3843 size = 1;
3844 p++;
3845 break;
3846 case 'h':
3847 size = 2;
3848 p++;
3849 break;
3850 case 'w':
3851 size = 4;
3852 p++;
3853 break;
3854 case 'g':
3855 case 'L':
3856 size = 8;
3857 p++;
3858 break;
3859 default:
3860 goto next;
3861 }
3862 }
3863 next:
blueswir1cd390082008-11-16 13:53:32 +00003864 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003865 monitor_printf(mon, "invalid char in format: '%c'\n",
3866 *p);
bellard9307c4c2004-04-04 12:57:25 +00003867 goto fail;
3868 }
bellard9307c4c2004-04-04 12:57:25 +00003869 if (format < 0)
3870 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003871 if (format != 'i') {
3872 /* for 'i', not specifying a size gives -1 as size */
3873 if (size < 0)
3874 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003875 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003876 }
bellard9307c4c2004-04-04 12:57:25 +00003877 default_fmt_format = format;
3878 } else {
3879 count = 1;
3880 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003881 if (format != 'i') {
3882 size = default_fmt_size;
3883 } else {
3884 size = -1;
3885 }
bellard9307c4c2004-04-04 12:57:25 +00003886 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003887 qdict_put(qdict, "count", qint_from_int(count));
3888 qdict_put(qdict, "format", qint_from_int(format));
3889 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003890 }
3891 break;
3892 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003893 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003894 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003895 {
blueswir1c2efc952007-09-25 17:28:42 +00003896 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003897
blueswir1cd390082008-11-16 13:53:32 +00003898 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003899 p++;
bellard34405572004-06-08 00:55:58 +00003900 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003901 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003902 if (*p == '\0') {
3903 typestr++;
3904 break;
3905 }
bellard34405572004-06-08 00:55:58 +00003906 } else {
3907 if (*p == '.') {
3908 p++;
blueswir1cd390082008-11-16 13:53:32 +00003909 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003910 p++;
bellard34405572004-06-08 00:55:58 +00003911 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003912 typestr++;
3913 break;
bellard34405572004-06-08 00:55:58 +00003914 }
3915 }
bellard13224a82006-07-14 22:03:35 +00003916 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003917 }
aliguori376253e2009-03-05 23:01:23 +00003918 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003919 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003920 /* Check if 'i' is greater than 32-bit */
3921 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3922 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3923 monitor_printf(mon, "integer is for 32-bit values\n");
3924 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003925 } else if (c == 'M') {
Luiz Capitulino91162842012-04-26 17:34:30 -03003926 if (val < 0) {
3927 monitor_printf(mon, "enter a positive value\n");
3928 goto fail;
3929 }
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003930 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003931 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003932 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003933 }
3934 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003935 case 'o':
3936 {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +01003937 int64_t val;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003938 char *end;
3939
3940 while (qemu_isspace(*p)) {
3941 p++;
3942 }
3943 if (*typestr == '?') {
3944 typestr++;
3945 if (*p == '\0') {
3946 break;
3947 }
3948 }
3949 val = strtosz(p, &end);
3950 if (val < 0) {
3951 monitor_printf(mon, "invalid size\n");
3952 goto fail;
3953 }
3954 qdict_put(qdict, key, qint_from_int(val));
3955 p = end;
3956 }
3957 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003958 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003959 {
3960 double val;
3961
3962 while (qemu_isspace(*p))
3963 p++;
3964 if (*typestr == '?') {
3965 typestr++;
3966 if (*p == '\0') {
3967 break;
3968 }
3969 }
3970 if (get_double(mon, &val, &p) < 0) {
3971 goto fail;
3972 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003973 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003974 switch (*p) {
3975 case 'm':
3976 val /= 1e3; p += 2; break;
3977 case 'u':
3978 val /= 1e6; p += 2; break;
3979 case 'n':
3980 val /= 1e9; p += 2; break;
3981 }
3982 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003983 if (*p && !qemu_isspace(*p)) {
3984 monitor_printf(mon, "Unknown unit suffix\n");
3985 goto fail;
3986 }
3987 qdict_put(qdict, key, qfloat_from_double(val));
3988 }
3989 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003990 case 'b':
3991 {
3992 const char *beg;
3993 int val;
3994
3995 while (qemu_isspace(*p)) {
3996 p++;
3997 }
3998 beg = p;
3999 while (qemu_isgraph(*p)) {
4000 p++;
4001 }
4002 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4003 val = 1;
4004 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4005 val = 0;
4006 } else {
4007 monitor_printf(mon, "Expected 'on' or 'off'\n");
4008 goto fail;
4009 }
4010 qdict_put(qdict, key, qbool_from_int(val));
4011 }
4012 break;
bellard9307c4c2004-04-04 12:57:25 +00004013 case '-':
4014 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004015 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004016 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00004017 /* option */
ths3b46e622007-09-17 08:09:54 +00004018
bellard9307c4c2004-04-04 12:57:25 +00004019 c = *typestr++;
4020 if (c == '\0')
4021 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00004022 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004023 p++;
bellard9307c4c2004-04-04 12:57:25 +00004024 if (*p == '-') {
4025 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004026 if(c != *p) {
4027 if(!is_valid_option(p, typestr)) {
4028
4029 monitor_printf(mon, "%s: unsupported option -%c\n",
4030 cmdname, *p);
4031 goto fail;
4032 } else {
4033 skip_key = 1;
4034 }
bellard9307c4c2004-04-04 12:57:25 +00004035 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004036 if(skip_key) {
4037 p = tmp;
4038 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004039 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004040 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004041 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004042 }
bellard9307c4c2004-04-04 12:57:25 +00004043 }
bellard9307c4c2004-04-04 12:57:25 +00004044 }
4045 break;
Wenchao Xia129be002013-08-27 20:38:26 +08004046 case 'S':
4047 {
4048 /* package all remaining string */
4049 int len;
4050
4051 while (qemu_isspace(*p)) {
4052 p++;
4053 }
4054 if (*typestr == '?') {
4055 typestr++;
4056 if (*p == '\0') {
4057 /* no remaining string: NULL argument */
4058 break;
4059 }
4060 }
4061 len = strlen(p);
4062 if (len <= 0) {
4063 monitor_printf(mon, "%s: string expected\n",
4064 cmdname);
4065 break;
4066 }
4067 qdict_put(qdict, key, qstring_from_str(p));
4068 p += len;
4069 }
4070 break;
bellard9307c4c2004-04-04 12:57:25 +00004071 default:
4072 bad_type:
aliguori376253e2009-03-05 23:01:23 +00004073 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00004074 goto fail;
4075 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004076 g_free(key);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004077 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00004078 }
4079 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00004080 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004081 p++;
4082 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00004083 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4084 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00004085 goto fail;
4086 }
4087
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004088 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02004089
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004090fail:
Anthony Liguori7267c092011-08-20 22:09:37 -05004091 g_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004092 return NULL;
4093}
4094
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004095void monitor_set_error(Monitor *mon, QError *qerror)
4096{
4097 /* report only the first error */
4098 if (!mon->error) {
4099 mon->error = qerror;
4100 } else {
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004101 QDECREF(qerror);
4102 }
4103}
4104
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004105static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4106{
Luiz Capitulino6d441432010-11-22 16:35:09 -02004107 if (ret && !monitor_has_error(mon)) {
4108 /*
4109 * If it returns failure, it must have passed on error.
4110 *
4111 * Action: Report an internal error to the client if in QMP.
4112 */
4113 qerror_report(QERR_UNDEFINED_ERROR);
Luiz Capitulino6d441432010-11-22 16:35:09 -02004114 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004115}
4116
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004117static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004118{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004119 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05004120 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004121
4122 qdict = qdict_new();
4123
Wenchao Xia77172392013-08-27 20:38:20 +08004124 cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03004125 if (!cmd)
4126 goto out;
4127
Luiz Capitulino4903de02010-09-16 11:01:32 -03004128 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06004129 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03004130 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03004131 QObject *data = NULL;
4132
4133 /* XXX: ignores the error code */
4134 cmd->mhandler.cmd_new(mon, qdict, &data);
4135 assert(!monitor_has_error(mon));
4136 if (data) {
4137 cmd->user_print(mon, data);
4138 qobject_decref(data);
4139 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03004140 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03004141 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004142 }
4143
Luiz Capitulino13917be2009-10-07 13:41:54 -03004144out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004145 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00004146}
4147
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004148static void cmd_completion(Monitor *mon, const char *name, const char *list)
bellard81d09122004-07-14 17:21:37 +00004149{
4150 const char *p, *pstart;
4151 char cmd[128];
4152 int len;
4153
4154 p = list;
4155 for(;;) {
4156 pstart = p;
4157 p = strchr(p, '|');
4158 if (!p)
4159 p = pstart + strlen(pstart);
4160 len = p - pstart;
4161 if (len > sizeof(cmd) - 2)
4162 len = sizeof(cmd) - 2;
4163 memcpy(cmd, pstart, len);
4164 cmd[len] = '\0';
4165 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004166 readline_add_completion(mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00004167 }
4168 if (*p == '\0')
4169 break;
4170 p++;
4171 }
4172}
4173
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004174static void file_completion(Monitor *mon, const char *input)
bellard81d09122004-07-14 17:21:37 +00004175{
4176 DIR *ffs;
4177 struct dirent *d;
4178 char path[1024];
4179 char file[1024], file_prefix[1024];
4180 int input_path_len;
4181 const char *p;
4182
ths5fafdf22007-09-16 21:08:06 +00004183 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004184 if (!p) {
4185 input_path_len = 0;
4186 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004187 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004188 } else {
4189 input_path_len = p - input + 1;
4190 memcpy(path, input, input_path_len);
4191 if (input_path_len > sizeof(path) - 1)
4192 input_path_len = sizeof(path) - 1;
4193 path[input_path_len] = '\0';
4194 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4195 }
4196#ifdef DEBUG_COMPLETION
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004197 monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
aliguori376253e2009-03-05 23:01:23 +00004198 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004199#endif
4200 ffs = opendir(path);
4201 if (!ffs)
4202 return;
4203 for(;;) {
4204 struct stat sb;
4205 d = readdir(ffs);
4206 if (!d)
4207 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004208
4209 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4210 continue;
4211 }
4212
bellard81d09122004-07-14 17:21:37 +00004213 if (strstart(d->d_name, file_prefix, NULL)) {
4214 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004215 if (input_path_len < sizeof(file))
4216 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4217 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004218 /* stat the file to find out if it's a directory.
4219 * In that case add a slash to speed up typing long paths
4220 */
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004221 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
blueswir1363a37d2008-08-21 17:58:08 +00004222 pstrcat(file, sizeof(file), "/");
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004223 }
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004224 readline_add_completion(mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004225 }
4226 }
4227 closedir(ffs);
4228}
4229
Wenchao Xia599a9262013-08-27 20:38:15 +08004230typedef struct MonitorBlockComplete {
4231 Monitor *mon;
4232 const char *input;
4233} MonitorBlockComplete;
4234
aliguori51de9762009-03-05 23:00:43 +00004235static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004236{
aliguori51de9762009-03-05 23:00:43 +00004237 const char *name = bdrv_get_device_name(bs);
Wenchao Xia599a9262013-08-27 20:38:15 +08004238 MonitorBlockComplete *mbc = opaque;
4239 Monitor *mon = mbc->mon;
4240 const char *input = mbc->input;
bellard81d09122004-07-14 17:21:37 +00004241
4242 if (input[0] == '\0' ||
4243 !strncmp(name, (char *)input, strlen(input))) {
Wenchao Xia599a9262013-08-27 20:38:15 +08004244 readline_add_completion(mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004245 }
4246}
4247
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004248static const char *next_arg_type(const char *typestr)
4249{
4250 const char *p = strchr(typestr, ':');
4251 return (p != NULL ? ++p : typestr);
4252}
4253
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004254void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles992d3e62014-02-06 23:30:11 +01004255{
4256 GSList *list, *elt;
4257 size_t len;
4258
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004259 if (nb_args != 2) {
4260 return;
4261 }
4262
Hani Benhabiles992d3e62014-02-06 23:30:11 +01004263 len = strlen(str);
4264 readline_set_completion_index(rs, len);
4265 list = elt = object_class_get_list(TYPE_DEVICE, false);
4266 while (elt) {
4267 const char *name;
4268 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
4269 TYPE_DEVICE);
4270 name = object_class_get_name(OBJECT_CLASS(dc));
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004271
4272 if (!dc->cannot_instantiate_with_device_add_yet
4273 && !strncmp(name, str, len)) {
Hani Benhabiles992d3e62014-02-06 23:30:11 +01004274 readline_add_completion(rs, name);
4275 }
4276 elt = elt->next;
4277 }
4278 g_slist_free(list);
4279}
4280
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004281void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles1094fd32014-02-06 23:30:13 +01004282{
4283 GSList *list, *elt;
4284 size_t len;
4285
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004286 if (nb_args != 2) {
4287 return;
4288 }
4289
Hani Benhabiles1094fd32014-02-06 23:30:13 +01004290 len = strlen(str);
4291 readline_set_completion_index(rs, len);
4292 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
4293 while (elt) {
4294 const char *name;
4295
4296 name = object_class_get_name(OBJECT_CLASS(elt->data));
4297 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
4298 readline_add_completion(rs, name);
4299 }
4300 elt = elt->next;
4301 }
4302 g_slist_free(list);
4303}
4304
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004305static void device_del_bus_completion(ReadLineState *rs, BusState *bus,
4306 const char *str, size_t len)
Hani Benhabilesfca72d92014-02-06 23:30:10 +01004307{
4308 BusChild *kid;
4309
4310 QTAILQ_FOREACH(kid, &bus->children, sibling) {
4311 DeviceState *dev = kid->child;
4312 BusState *dev_child;
4313
4314 if (dev->id && !strncmp(str, dev->id, len)) {
4315 readline_add_completion(rs, dev->id);
4316 }
4317
4318 QLIST_FOREACH(dev_child, &dev->child_bus, sibling) {
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004319 device_del_bus_completion(rs, dev_child, str, len);
Hani Benhabilesfca72d92014-02-06 23:30:10 +01004320 }
4321 }
4322}
4323
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01004324void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
4325{
4326 size_t len;
4327
4328 if (nb_args != 2) {
4329 return;
4330 }
4331
4332 len = strlen(str);
4333 readline_set_completion_index(rs, len);
4334 device_del_bus_completion(rs, sysbus_get_default(), str, len);
4335}
4336
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004337void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabilesb48fa072014-02-06 23:30:12 +01004338{
4339 ObjectPropertyInfoList *list, *start;
4340 size_t len;
4341
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004342 if (nb_args != 2) {
4343 return;
4344 }
Hani Benhabilesb48fa072014-02-06 23:30:12 +01004345 len = strlen(str);
4346 readline_set_completion_index(rs, len);
4347
4348 start = list = qmp_qom_list("/objects", NULL);
4349 while (list) {
4350 ObjectPropertyInfo *info = list->value;
4351
4352 if (!strncmp(info->type, "child<", 5)
4353 && !strncmp(info->name, str, len)) {
4354 readline_add_completion(rs, info->name);
4355 }
4356 list = list->next;
4357 }
4358 qapi_free_ObjectPropertyInfoList(start);
4359}
4360
Wenchao Xiac35b6402013-08-27 20:38:24 +08004361static void monitor_find_completion_by_table(Monitor *mon,
4362 const mon_cmd_t *cmd_table,
4363 char **args,
4364 int nb_args)
bellard81d09122004-07-14 17:21:37 +00004365{
4366 const char *cmdname;
Wenchao Xiac35b6402013-08-27 20:38:24 +08004367 int i;
bellard81d09122004-07-14 17:21:37 +00004368 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004369 const mon_cmd_t *cmd;
Wenchao Xia599a9262013-08-27 20:38:15 +08004370 MonitorBlockComplete mbs;
bellard81d09122004-07-14 17:21:37 +00004371
bellard81d09122004-07-14 17:21:37 +00004372 if (nb_args <= 1) {
4373 /* command completion */
4374 if (nb_args == 0)
4375 cmdname = "";
4376 else
4377 cmdname = args[0];
Wenchao Xiad2674b22013-08-27 20:38:16 +08004378 readline_set_completion_index(mon->rs, strlen(cmdname));
Wenchao Xiac35b6402013-08-27 20:38:24 +08004379 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004380 cmd_completion(mon, cmdname, cmd->name);
bellard81d09122004-07-14 17:21:37 +00004381 }
4382 } else {
4383 /* find the command */
Wenchao Xiac35b6402013-08-27 20:38:24 +08004384 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004385 if (compare_cmd(args[0], cmd->name)) {
4386 break;
4387 }
bellard81d09122004-07-14 17:21:37 +00004388 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004389 if (!cmd->name) {
Wenchao Xiac35b6402013-08-27 20:38:24 +08004390 return;
Jan Kiszka03a63482010-06-16 00:38:33 +02004391 }
4392
Wenchao Xiad903a772013-08-27 20:38:25 +08004393 if (cmd->sub_table) {
4394 /* do the job again */
4395 return monitor_find_completion_by_table(mon, cmd->sub_table,
4396 &args[1], nb_args - 1);
4397 }
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004398 if (cmd->command_completion) {
4399 return cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4400 }
Wenchao Xiad903a772013-08-27 20:38:25 +08004401
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004402 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004403 for(i = 0; i < nb_args - 2; i++) {
4404 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004405 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004406 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004407 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004408 }
4409 }
4410 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004411 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004412 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004413 }
bellard81d09122004-07-14 17:21:37 +00004414 switch(*ptype) {
4415 case 'F':
4416 /* file completion */
Wenchao Xiad2674b22013-08-27 20:38:16 +08004417 readline_set_completion_index(mon->rs, strlen(str));
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004418 file_completion(mon, str);
bellard81d09122004-07-14 17:21:37 +00004419 break;
4420 case 'B':
4421 /* block device name completion */
Wenchao Xia599a9262013-08-27 20:38:15 +08004422 mbs.mon = mon;
4423 mbs.input = str;
4424 readline_set_completion_index(mon->rs, strlen(str));
4425 bdrv_iterate(block_completion_it, &mbs);
bellard81d09122004-07-14 17:21:37 +00004426 break;
bellard7fe48482004-10-09 18:08:01 +00004427 case 's':
Wenchao Xia129be002013-08-27 20:38:26 +08004428 case 'S':
Wenchao Xiad903a772013-08-27 20:38:25 +08004429 if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004430 char *sep = strrchr(str, '-');
4431 if (sep)
4432 str = sep + 1;
Wenchao Xiad2674b22013-08-27 20:38:16 +08004433 readline_set_completion_index(mon->rs, strlen(str));
Amos Kong1048c882012-08-31 10:56:25 +08004434 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004435 cmd_completion(mon, str, QKeyCode_lookup[i]);
bellard64866c32006-05-07 18:03:31 +00004436 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004437 } else if (!strcmp(cmd->name, "help|?")) {
Wenchao Xia7ca0e062013-08-27 20:38:27 +08004438 monitor_find_completion_by_table(mon, cmd_table,
4439 &args[1], nb_args - 1);
bellard7fe48482004-10-09 18:08:01 +00004440 }
4441 break;
bellard81d09122004-07-14 17:21:37 +00004442 default:
4443 break;
4444 }
4445 }
Wenchao Xiac35b6402013-08-27 20:38:24 +08004446}
4447
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004448static void monitor_find_completion(void *opaque,
Wenchao Xiac35b6402013-08-27 20:38:24 +08004449 const char *cmdline)
4450{
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004451 Monitor *mon = opaque;
Wenchao Xiac35b6402013-08-27 20:38:24 +08004452 char *args[MAX_ARGS];
4453 int nb_args, len;
4454
4455 /* 1. parse the cmdline */
4456 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4457 return;
4458 }
4459#ifdef DEBUG_COMPLETION
4460 for (i = 0; i < nb_args; i++) {
4461 monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4462 }
4463#endif
4464
4465 /* if the line ends with a space, it means we want to complete the
4466 next arg */
4467 len = strlen(cmdline);
4468 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4469 if (nb_args >= MAX_ARGS) {
4470 goto cleanup;
4471 }
4472 args[nb_args++] = g_strdup("");
4473 }
4474
4475 /* 2. auto complete according to args */
4476 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
Jan Kiszka03a63482010-06-16 00:38:33 +02004477
4478cleanup:
Wenchao Xiadcc70cd2013-08-27 20:38:22 +08004479 free_cmdline_args(args, nb_args);
bellard81d09122004-07-14 17:21:37 +00004480}
4481
aliguori731b0362009-03-05 23:01:42 +00004482static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004483{
aliguori731b0362009-03-05 23:01:42 +00004484 Monitor *mon = opaque;
4485
Jan Kiszkac62313b2009-12-04 14:05:29 +01004486 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004487}
4488
Luiz Capitulino09069b12010-02-04 18:10:06 -02004489static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4490{
4491 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4492 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4493}
4494
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004495/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004496 * Argument validation rules:
4497 *
4498 * 1. The argument must exist in cmd_args qdict
4499 * 2. The argument type must be the expected one
4500 *
4501 * Special case: If the argument doesn't exist in cmd_args and
4502 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4503 * checking is skipped for it.
4504 */
4505static int check_client_args_type(const QDict *client_args,
4506 const QDict *cmd_args, int flags)
4507{
4508 const QDictEntry *ent;
4509
4510 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4511 QObject *obj;
4512 QString *arg_type;
4513 const QObject *client_arg = qdict_entry_value(ent);
4514 const char *client_arg_name = qdict_entry_key(ent);
4515
4516 obj = qdict_get(cmd_args, client_arg_name);
4517 if (!obj) {
4518 if (flags & QMP_ACCEPT_UNKNOWNS) {
4519 /* handler accepts unknowns */
4520 continue;
4521 }
4522 /* client arg doesn't exist */
4523 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4524 return -1;
4525 }
4526
4527 arg_type = qobject_to_qstring(obj);
4528 assert(arg_type != NULL);
4529
4530 /* check if argument's type is correct */
4531 switch (qstring_get_str(arg_type)[0]) {
4532 case 'F':
4533 case 'B':
4534 case 's':
4535 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4536 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4537 "string");
4538 return -1;
4539 }
4540 break;
4541 case 'i':
4542 case 'l':
4543 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004544 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004545 if (qobject_type(client_arg) != QTYPE_QINT) {
4546 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4547 "int");
4548 return -1;
4549 }
4550 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004551 case 'T':
4552 if (qobject_type(client_arg) != QTYPE_QINT &&
4553 qobject_type(client_arg) != QTYPE_QFLOAT) {
4554 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4555 "number");
4556 return -1;
4557 }
4558 break;
4559 case 'b':
4560 case '-':
4561 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4562 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4563 "bool");
4564 return -1;
4565 }
4566 break;
4567 case 'O':
4568 assert(flags & QMP_ACCEPT_UNKNOWNS);
4569 break;
Paolo Bonzinib9f89782012-03-22 12:51:11 +01004570 case 'q':
4571 /* Any QObject can be passed. */
4572 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004573 case '/':
4574 case '.':
4575 /*
4576 * These types are not supported by QMP and thus are not
4577 * handled here. Fall through.
4578 */
4579 default:
4580 abort();
4581 }
4582 }
4583
4584 return 0;
4585}
4586
4587/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004588 * - Check if the client has passed all mandatory args
4589 * - Set special flags for argument validation
4590 */
4591static int check_mandatory_args(const QDict *cmd_args,
4592 const QDict *client_args, int *flags)
4593{
4594 const QDictEntry *ent;
4595
4596 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4597 const char *cmd_arg_name = qdict_entry_key(ent);
4598 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4599 assert(type != NULL);
4600
4601 if (qstring_get_str(type)[0] == 'O') {
4602 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4603 *flags |= QMP_ACCEPT_UNKNOWNS;
4604 } else if (qstring_get_str(type)[0] != '-' &&
4605 qstring_get_str(type)[1] != '?' &&
4606 !qdict_haskey(client_args, cmd_arg_name)) {
4607 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4608 return -1;
4609 }
4610 }
4611
4612 return 0;
4613}
4614
4615static QDict *qdict_from_args_type(const char *args_type)
4616{
4617 int i;
4618 QDict *qdict;
4619 QString *key, *type, *cur_qs;
4620
4621 assert(args_type != NULL);
4622
4623 qdict = qdict_new();
4624
4625 if (args_type == NULL || args_type[0] == '\0') {
4626 /* no args, empty qdict */
4627 goto out;
4628 }
4629
4630 key = qstring_new();
4631 type = qstring_new();
4632
4633 cur_qs = key;
4634
4635 for (i = 0;; i++) {
4636 switch (args_type[i]) {
4637 case ',':
4638 case '\0':
4639 qdict_put(qdict, qstring_get_str(key), type);
4640 QDECREF(key);
4641 if (args_type[i] == '\0') {
4642 goto out;
4643 }
4644 type = qstring_new(); /* qdict has ref */
4645 cur_qs = key = qstring_new();
4646 break;
4647 case ':':
4648 cur_qs = type;
4649 break;
4650 default:
4651 qstring_append_chr(cur_qs, args_type[i]);
4652 break;
4653 }
4654 }
4655
4656out:
4657 return qdict;
4658}
4659
4660/*
4661 * Client argument checking rules:
4662 *
4663 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004664 * 2. Each argument provided by the client must be expected
4665 * 3. Each argument provided by the client must have the type expected
4666 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004667 */
4668static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4669{
4670 int flags, err;
4671 QDict *cmd_args;
4672
4673 cmd_args = qdict_from_args_type(cmd->args_type);
4674
4675 flags = 0;
4676 err = check_mandatory_args(cmd_args, client_args, &flags);
4677 if (err) {
4678 goto out;
4679 }
4680
Luiz Capitulino4af91932010-06-22 11:44:05 -03004681 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004682
4683out:
4684 QDECREF(cmd_args);
4685 return err;
4686}
4687
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004688/*
4689 * Input object checking rules
4690 *
4691 * 1. Input object must be a dict
4692 * 2. The "execute" key must exist
4693 * 3. The "execute" key must be a string
4694 * 4. If the "arguments" key exists, it must be a dict
4695 * 5. If the "id" key exists, it can be anything (ie. json-value)
4696 * 6. Any argument not listed above is considered invalid
4697 */
4698static QDict *qmp_check_input_obj(QObject *input_obj)
4699{
4700 const QDictEntry *ent;
4701 int has_exec_key = 0;
4702 QDict *input_dict;
4703
4704 if (qobject_type(input_obj) != QTYPE_QDICT) {
4705 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4706 return NULL;
4707 }
4708
4709 input_dict = qobject_to_qdict(input_obj);
4710
4711 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4712 const char *arg_name = qdict_entry_key(ent);
4713 const QObject *arg_obj = qdict_entry_value(ent);
4714
4715 if (!strcmp(arg_name, "execute")) {
4716 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4717 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4718 "string");
4719 return NULL;
4720 }
4721 has_exec_key = 1;
4722 } else if (!strcmp(arg_name, "arguments")) {
4723 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4724 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4725 "object");
4726 return NULL;
4727 }
4728 } else if (!strcmp(arg_name, "id")) {
4729 /* FIXME: check duplicated IDs for async commands */
4730 } else {
4731 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4732 return NULL;
4733 }
4734 }
4735
4736 if (!has_exec_key) {
4737 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4738 return NULL;
4739 }
4740
4741 return input_dict;
4742}
4743
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004744static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4745 const QDict *params)
4746{
4747 int ret;
4748 QObject *data = NULL;
4749
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004750 ret = cmd->mhandler.cmd_new(mon, params, &data);
4751 handler_audit(mon, cmd, ret);
4752 monitor_protocol_emitter(mon, data);
4753 qobject_decref(data);
4754}
4755
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004756static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4757{
4758 int err;
4759 QObject *obj;
4760 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004761 const mon_cmd_t *cmd;
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004762 const char *cmd_name;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004763 Monitor *mon = cur_mon;
4764
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004765 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004766
4767 obj = json_parser_parse(tokens, NULL);
4768 if (!obj) {
4769 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004770 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004771 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004772 }
4773
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004774 input = qmp_check_input_obj(obj);
4775 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004776 qobject_decref(obj);
4777 goto err_out;
4778 }
4779
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004780 mon->mc->id = qdict_get(input, "id");
4781 qobject_incref(mon->mc->id);
4782
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004783 cmd_name = qdict_get_str(input, "execute");
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +01004784 trace_handle_qmp_command(mon, cmd_name);
Luiz Capitulino09069b12010-02-04 18:10:06 -02004785 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004786 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004787 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004788 }
4789
Anthony Liguorie3193602011-09-02 12:34:47 -05004790 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004791 if (!cmd) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004792 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004793 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004794 }
4795
4796 obj = qdict_get(input, "arguments");
4797 if (!obj) {
4798 args = qdict_new();
4799 } else {
4800 args = qobject_to_qdict(obj);
4801 QINCREF(args);
4802 }
4803
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004804 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004805 if (err < 0) {
4806 goto err_out;
4807 }
4808
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004809 if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004810 err = qmp_async_cmd_handler(mon, cmd, args);
4811 if (err) {
4812 /* emit the error response */
4813 goto err_out;
4814 }
Adam Litke940cc302010-01-25 12:18:44 -06004815 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004816 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004817 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004818
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004819 goto out;
4820
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004821err_out:
4822 monitor_protocol_emitter(mon, NULL);
4823out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004824 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004825 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004826}
4827
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004828/**
4829 * monitor_control_read(): Read and handle QMP input
4830 */
4831static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4832{
4833 Monitor *old_mon = cur_mon;
4834
4835 cur_mon = opaque;
4836
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004837 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004838
4839 cur_mon = old_mon;
4840}
4841
aliguori731b0362009-03-05 23:01:42 +00004842static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004843{
aliguori731b0362009-03-05 23:01:42 +00004844 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004845 int i;
aliguori376253e2009-03-05 23:01:23 +00004846
aliguori731b0362009-03-05 23:01:42 +00004847 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004848
aliguoricde76ee2009-03-05 23:01:51 +00004849 if (cur_mon->rs) {
4850 for (i = 0; i < size; i++)
4851 readline_handle_byte(cur_mon->rs, buf[i]);
4852 } else {
4853 if (size == 0 || buf[size - 1] != 0)
4854 monitor_printf(cur_mon, "corrupted command\n");
4855 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004856 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004857 }
aliguori731b0362009-03-05 23:01:42 +00004858
4859 cur_mon = old_mon;
4860}
aliguorid8f44602008-10-06 13:52:44 +00004861
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004862static void monitor_command_cb(void *opaque, const char *cmdline,
4863 void *readline_opaque)
bellard7e2515e2004-08-01 21:52:19 +00004864{
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004865 Monitor *mon = opaque;
4866
aliguori731b0362009-03-05 23:01:42 +00004867 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004868 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004869 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004870}
4871
aliguoricde76ee2009-03-05 23:01:51 +00004872int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004873{
aliguoricde76ee2009-03-05 23:01:51 +00004874 if (!mon->rs)
4875 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004876 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004877 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004878}
4879
aliguori376253e2009-03-05 23:01:23 +00004880void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004881{
aliguoricde76ee2009-03-05 23:01:51 +00004882 if (!mon->rs)
4883 return;
aliguori731b0362009-03-05 23:01:42 +00004884 if (--mon->suspend_cnt == 0)
4885 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004886}
4887
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004888static QObject *get_qmp_greeting(void)
4889{
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004890 QObject *ver = NULL;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004891
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004892 qmp_marshal_input_query_version(NULL, NULL, &ver);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004893 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4894}
4895
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004896/**
4897 * monitor_control_event(): Print QMP gretting
4898 */
4899static void monitor_control_event(void *opaque, int event)
4900{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004901 QObject *data;
4902 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004903
Luiz Capitulino47116d12010-02-08 17:01:30 -02004904 switch (event) {
4905 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004906 mon->mc->command_mode = 0;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004907 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004908 monitor_json_emitter(mon, data);
4909 qobject_decref(data);
Corey Bryantefb87c12012-08-14 16:43:48 -04004910 mon_refcount++;
Luiz Capitulino47116d12010-02-08 17:01:30 -02004911 break;
4912 case CHR_EVENT_CLOSED:
4913 json_message_parser_destroy(&mon->mc->parser);
Anthony Liguori58617a72012-08-23 08:03:21 -05004914 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Corey Bryantefb87c12012-08-14 16:43:48 -04004915 mon_refcount--;
4916 monitor_fdsets_cleanup();
Luiz Capitulino47116d12010-02-08 17:01:30 -02004917 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004918 }
4919}
4920
aliguori731b0362009-03-05 23:01:42 +00004921static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004922{
aliguori376253e2009-03-05 23:01:23 +00004923 Monitor *mon = opaque;
4924
aliguori2724b182009-03-05 23:01:47 +00004925 switch (event) {
4926 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004927 mon->mux_out = 0;
4928 if (mon->reset_seen) {
4929 readline_restart(mon->rs);
4930 monitor_resume(mon);
4931 monitor_flush(mon);
4932 } else {
4933 mon->suspend_cnt = 0;
4934 }
aliguori2724b182009-03-05 23:01:47 +00004935 break;
ths86e94de2007-01-05 22:01:59 +00004936
aliguori2724b182009-03-05 23:01:47 +00004937 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004938 if (mon->reset_seen) {
4939 if (mon->suspend_cnt == 0) {
4940 monitor_printf(mon, "\n");
4941 }
4942 monitor_flush(mon);
4943 monitor_suspend(mon);
4944 } else {
4945 mon->suspend_cnt++;
4946 }
4947 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004948 break;
4949
Amit Shahb6b8df52009-10-07 18:31:16 +05304950 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004951 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4952 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004953 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004954 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004955 }
4956 mon->reset_seen = 1;
Corey Bryantefb87c12012-08-14 16:43:48 -04004957 mon_refcount++;
4958 break;
4959
4960 case CHR_EVENT_CLOSED:
4961 mon_refcount--;
4962 monitor_fdsets_cleanup();
aliguori2724b182009-03-05 23:01:47 +00004963 break;
4964 }
ths86e94de2007-01-05 22:01:59 +00004965}
4966
Wayne Xia816f8922011-10-12 11:32:41 +08004967static int
4968compare_mon_cmd(const void *a, const void *b)
4969{
4970 return strcmp(((const mon_cmd_t *)a)->name,
4971 ((const mon_cmd_t *)b)->name);
4972}
4973
4974static void sortcmdlist(void)
4975{
4976 int array_num;
4977 int elem_size = sizeof(mon_cmd_t);
4978
4979 array_num = sizeof(mon_cmds)/elem_size-1;
4980 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4981
4982 array_num = sizeof(info_cmds)/elem_size-1;
4983 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4984}
4985
aliguori76655d62009-03-06 20:27:37 +00004986
4987/*
4988 * Local variables:
4989 * c-indent-level: 4
4990 * c-basic-offset: 4
4991 * tab-width: 8
4992 * End:
4993 */
4994
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004995/* These functions just adapt the readline interface in a typesafe way. We
4996 * could cast function pointers but that discards compiler checks.
4997 */
Stefan Weild5d15072014-01-25 18:18:23 +01004998static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4999 const char *fmt, ...)
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01005000{
5001 va_list ap;
5002 va_start(ap, fmt);
5003 monitor_vprintf(opaque, fmt, ap);
5004 va_end(ap);
5005}
5006
5007static void monitor_readline_flush(void *opaque)
5008{
5009 monitor_flush(opaque);
5010}
5011
aliguori731b0362009-03-05 23:01:42 +00005012void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00005013{
aliguori731b0362009-03-05 23:01:42 +00005014 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00005015 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00005016
5017 if (is_first_init) {
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +01005018 monitor_protocol_event_init();
Wenchao Xiad0383172013-08-27 20:38:18 +08005019 sortcmdlist();
ths20d8a3e2007-02-18 17:04:49 +00005020 is_first_init = 0;
5021 }
aliguori87127162009-03-05 23:01:29 +00005022
Wenchao Xiab01fe892013-08-27 20:38:19 +08005023 mon = g_malloc(sizeof(*mon));
5024 monitor_data_init(mon);
ths20d8a3e2007-02-18 17:04:49 +00005025
aliguori87127162009-03-05 23:01:29 +00005026 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00005027 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00005028 if (flags & MONITOR_USE_READLINE) {
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01005029 mon->rs = readline_init(monitor_readline_printf,
5030 monitor_readline_flush,
5031 mon,
5032 monitor_find_completion);
aliguoricde76ee2009-03-05 23:01:51 +00005033 monitor_read_command(mon, 0);
5034 }
aliguori87127162009-03-05 23:01:29 +00005035
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005036 if (monitor_ctrl_mode(mon)) {
Anthony Liguori7267c092011-08-20 22:09:37 -05005037 mon->mc = g_malloc0(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005038 /* Control mode requires special handlers */
5039 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
5040 monitor_control_event, mon);
Anthony Liguori15f31512011-08-15 11:17:35 -05005041 qemu_chr_fe_set_echo(chr, true);
Anthony Liguori26efaca2012-08-23 13:49:02 -05005042
5043 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02005044 } else {
5045 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
5046 monitor_event, mon);
5047 }
aliguori87127162009-03-05 23:01:29 +00005048
Blue Swirl72cf2d42009-09-12 07:36:22 +00005049 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01005050 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
5051 default_mon = mon;
bellard7e2515e2004-08-01 21:52:19 +00005052}
5053
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01005054static void bdrv_password_cb(void *opaque, const char *password,
5055 void *readline_opaque)
bellard7e2515e2004-08-01 21:52:19 +00005056{
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01005057 Monitor *mon = opaque;
5058 BlockDriverState *bs = readline_opaque;
aliguoribb5fc202009-03-05 23:01:15 +00005059 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00005060
aliguoribb5fc202009-03-05 23:01:15 +00005061 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00005062 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00005063 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00005064 }
aliguori731b0362009-03-05 23:01:42 +00005065 if (mon->password_completion_cb)
5066 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00005067
aliguori731b0362009-03-05 23:01:42 +00005068 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00005069}
aliguoric0f4ce72009-03-05 23:01:01 +00005070
Anthony Liguori7060b472011-09-02 12:34:50 -05005071ReadLineState *monitor_get_rs(Monitor *mon)
5072{
5073 return mon->rs;
5074}
5075
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005076int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
5077 BlockDriverCompletionFunc *completion_cb,
5078 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00005079{
aliguoricde76ee2009-03-05 23:01:51 +00005080 int err;
5081
aliguoribb5fc202009-03-05 23:01:15 +00005082 if (!bdrv_key_required(bs)) {
5083 if (completion_cb)
5084 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005085 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00005086 }
aliguoric0f4ce72009-03-05 23:01:01 +00005087
Luiz Capitulino94171e12009-12-07 21:37:00 +01005088 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino903a8812011-12-13 17:18:30 -02005089 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
5090 bdrv_get_encrypted_filename(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005091 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01005092 }
5093
aliguori376253e2009-03-05 23:01:23 +00005094 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
5095 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00005096
aliguori731b0362009-03-05 23:01:42 +00005097 mon->password_completion_cb = completion_cb;
5098 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00005099
aliguoricde76ee2009-03-05 23:01:51 +00005100 err = monitor_read_password(mon, bdrv_password_cb, bs);
5101
5102 if (err && completion_cb)
5103 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02005104
5105 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00005106}
Luiz Capitulinoe42e8182011-11-22 17:58:31 -02005107
5108int monitor_read_block_device_key(Monitor *mon, const char *device,
5109 BlockDriverCompletionFunc *completion_cb,
5110 void *opaque)
5111{
5112 BlockDriverState *bs;
5113
5114 bs = bdrv_find(device);
5115 if (!bs) {
5116 monitor_printf(mon, "Device not found %s\n", device);
5117 return -1;
5118 }
5119
5120 return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
5121}
Paolo Bonzini4d454572012-11-26 16:03:42 +01005122
5123QemuOptsList qemu_mon_opts = {
5124 .name = "mon",
5125 .implied_opt_name = "chardev",
5126 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
5127 .desc = {
5128 {
5129 .name = "mode",
5130 .type = QEMU_OPT_STRING,
5131 },{
5132 .name = "chardev",
5133 .type = QEMU_OPT_STRING,
5134 },{
5135 .name = "default",
5136 .type = QEMU_OPT_BOOL,
5137 },{
5138 .name = "pretty",
5139 .type = QEMU_OPT_BOOL,
5140 },
5141 { /* end of list */ }
5142 },
5143};