blob: 6284efe33e79e585cc815974813f088bdad8ecfd [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 */
Markus Armbrustere688df62018-02-01 12:18:31 +010024
Peter Maydelld38ea872016-01-29 17:50:05 +000025#include "qemu/osdep.h"
Philippe Mathieu-Daudé8ec338a2018-06-25 09:42:34 -030026#include "qemu/units.h"
blueswir1511d2b12009-03-07 15:32:56 +000027#include <dirent.h>
Paolo Bonzini33c11872016-03-15 16:58:45 +010028#include "cpu.h"
pbrook87ecb682007-11-17 17:14:51 +000029#include "hw/hw.h"
Paolo Bonzinib4a42f82013-02-04 11:37:52 +010030#include "monitor/qdev.h"
pbrook87ecb682007-11-17 17:14:51 +000031#include "hw/usb.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020032#include "hw/pci/pci.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010033#include "sysemu/watchdog.h"
Gerd Hoffmann45a50b12009-10-01 16:42:33 +020034#include "hw/loader.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010035#include "exec/gdbstub.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020036#include "net/net.h"
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000037#include "net/slirp.h"
Marc-André Lureau4d43a602017-01-26 18:26:44 +040038#include "chardev/char-fe.h"
Peter Xua5ed3522018-03-09 16:59:52 +080039#include "chardev/char-io.h"
Peter Xube933ff2018-03-26 14:38:56 +080040#include "chardev/char-mux.h"
Gerd Hoffmann75721502010-10-07 12:22:54 +020041#include "ui/qemu-spice.h"
Eduardo Habkoste35704b2015-02-08 16:51:16 -020042#include "sysemu/numa.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010043#include "monitor/monitor.h"
Marc-André Lureau213dcb02016-12-12 20:22:24 +030044#include "qemu/config-file.h"
Stefan Hajnoczi0150cd82013-11-14 11:54:15 +010045#include "qemu/readline.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010046#include "ui/console.h"
Gerd Hoffmannc751a742013-12-04 15:02:28 +010047#include "ui/input.h"
Max Reitzda27a002016-03-16 19:54:29 +010048#include "sysemu/block-backend.h"
pbrook87ecb682007-11-17 17:14:51 +000049#include "audio/audio.h"
Paolo Bonzini76cad712012-10-24 11:12:21 +020050#include "disas/disas.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010051#include "sysemu/balloon.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010052#include "qemu/timer.h"
Vincent Palatinb3946622017-01-10 11:59:55 +010053#include "sysemu/hw_accel.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010054#include "qemu/acl.h"
Paolo Bonzinibdee56f2013-04-02 18:28:41 +020055#include "sysemu/tpm.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010056#include "qapi/qmp/qdict.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010057#include "qapi/qmp/qerror.h"
Markus Armbruster15280c32018-02-01 12:18:36 +010058#include "qapi/qmp/qnum.h"
Markus Armbrusterfc81fa12018-02-01 12:18:40 +010059#include "qapi/qmp/qstring.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010060#include "qapi/qmp/qjson.h"
61#include "qapi/qmp/json-streamer.h"
62#include "qapi/qmp/json-parser.h"
Peter Xu02130312018-03-09 16:59:53 +080063#include "qapi/qmp/qlist.h"
Markus Armbrustera9c94272016-06-22 19:11:19 +020064#include "qom/object_interfaces.h"
Daniel P. Berrange0ab8ed12017-01-25 16:14:15 +000065#include "trace-root.h"
Lluís31965ae2011-08-31 20:31:24 +020066#include "trace/control.h"
Pavel Butsykinbf957282015-09-10 18:38:59 +030067#include "monitor/hmp-target.h"
Lluís6d8a7642011-08-31 20:30:43 +020068#ifdef CONFIG_TRACE_SIMPLE
Lluís31965ae2011-08-31 20:31:24 +020069#include "trace/simple.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053070#endif
Paolo Bonzini022c62c2012-12-17 18:19:49 +010071#include "exec/memory.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010072#include "exec/exec-all.h"
Paolo Bonzini03dd0242015-12-15 13:16:16 +010073#include "qemu/log.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010074#include "qemu/option.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050075#include "hmp.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010076#include "qemu/thread.h"
Hani Benhabilesb21631f2014-05-27 23:39:37 +010077#include "block/qapi.h"
Markus Armbrustereb815e22018-02-11 10:36:05 +010078#include "qapi/qapi-commands.h"
79#include "qapi/qapi-events.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010080#include "qapi/error.h"
Wenchao Xia43a14cf2014-06-18 08:43:31 +020081#include "qapi/qmp-event.h"
Markus Armbrustereb815e22018-02-11 10:36:05 +010082#include "qapi/qapi-introspect.h"
Alberto Garciadc599972016-03-10 13:55:26 +020083#include "sysemu/qtest.h"
Paolo Bonzinid2528bd2017-03-03 12:01:16 +010084#include "sysemu/cpus.h"
Peter Xua5ed3522018-03-09 16:59:52 +080085#include "sysemu/iothread.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020086#include "qemu/cutils.h"
ths6a5bd302007-12-03 17:05:38 +000087
Jason J. Hernea4538a52015-06-26 14:07:21 -040088#if defined(TARGET_S390X)
89#include "hw/s390x/storage-keys.h"
Claudio Imbrendaf860d492016-08-15 18:44:04 +020090#include "hw/s390x/storage-attributes.h"
Jason J. Hernea4538a52015-06-26 14:07:21 -040091#endif
92
bellard9307c4c2004-04-04 12:57:25 +000093/*
94 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000095 *
bellard9307c4c2004-04-04 12:57:25 +000096 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000097 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000098 * 's' string (accept optional quote)
Wenchao Xia129be002013-08-27 20:38:26 +080099 * 'S' it just appends the rest of the string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +0100100 * 'O' option string of the form NAME=VALUE,...
101 * parsed according to QemuOptsList given by its name
102 * Example: 'device:O' uses qemu_device_opts.
103 * Restriction: only lists with empty desc are supported
104 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +0000105 * 'i' 32 bit integer
106 * 'l' target long (32 or 64 bit)
Luiz Capitulino91162842012-04-26 17:34:30 -0300107 * 'M' Non-negative target long (32 or 64 bit), in user mode the
108 * value is multiplied by 2^20 (think Mebibyte)
Jes Sorensendbc0c672010-10-21 17:15:47 +0200109 * 'o' octets (aka bytes)
Kevin Wolf5e009842013-06-05 14:19:27 +0200110 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
111 * K, k suffix, which multiplies the value by 2^60 for suffixes E
112 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
113 * 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 +0100114 * 'T' double
115 * user mode accepts an optional ms, us, ns suffix,
116 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +0000117 * '/' optional gdb-like print format (like "/10x")
118 *
Luiz Capitulinofb466602009-08-28 15:27:27 -0300119 * '?' optional type (for all types, except '/')
120 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +0100121 * 'b' boolean
122 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -0300123 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +0000124 *
125 */
126
Anthony Liguoric227f092009-10-01 16:12:16 -0500127typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000128 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000129 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000130 const char *params;
131 const char *help;
Dr. David Alan Gilbertc3120f72018-06-20 16:39:41 +0100132 const char *flags; /* p=preconfig */
Marc-André Lureau2b9e3572016-09-12 13:19:06 +0400133 void (*cmd)(Monitor *mon, const QDict *qdict);
134 /* @sub_table is a list of 2nd level of commands. If it does not exist,
135 * cmd should be used. If it exists, sub_table[?].cmd should be
136 * used, and cmd of 1st level plays the role of help function.
Wenchao Xia5f3d3352013-01-14 14:06:27 +0800137 */
138 struct mon_cmd_t *sub_table;
Hani Benhabilesbfa40f72014-04-13 16:25:06 +0100139 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
Anthony Liguoric227f092009-10-01 16:12:16 -0500140} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000141
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100142/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500143typedef struct mon_fd_t mon_fd_t;
144struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100145 char *name;
146 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500147 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100148};
149
Corey Bryantba1c0482012-08-14 16:43:43 -0400150/* file descriptor associated with a file descriptor set */
151typedef struct MonFdsetFd MonFdsetFd;
152struct MonFdsetFd {
153 int fd;
154 bool removed;
155 char *opaque;
156 QLIST_ENTRY(MonFdsetFd) next;
157};
158
159/* file descriptor set containing fds passed via SCM_RIGHTS */
160typedef struct MonFdset MonFdset;
161struct MonFdset {
162 int64_t id;
163 QLIST_HEAD(, MonFdsetFd) fds;
Corey Bryantadb696f2012-08-14 16:43:47 -0400164 QLIST_HEAD(, MonFdsetFd) dup_fds;
Corey Bryantba1c0482012-08-14 16:43:43 -0400165 QLIST_ENTRY(MonFdset) next;
166};
167
Markus Armbruster74358f22015-03-06 19:35:59 +0100168typedef struct {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200169 JSONMessageParser parser;
Markus Armbrusterf994b252015-03-06 19:51:51 +0100170 /*
171 * When a client connects, we're in capabilities negotiation mode.
172 * When command qmp_capabilities succeeds, we go into command
173 * mode.
174 */
Markus Armbruster635db182017-03-03 13:32:27 +0100175 QmpCommandList *commands;
Peter Xu02130312018-03-09 16:59:53 +0800176 bool qmp_caps[QMP_CAPABILITY__MAX];
Peter Xu71da4662018-03-09 16:59:57 +0800177 /*
178 * Protects qmp request/response queue. Please take monitor_lock
179 * first when used together.
180 */
181 QemuMutex qmp_queue_lock;
182 /* Input queue that holds all the parsed QMP requests */
183 GQueue *qmp_requests;
Peter Xuabe3cd02018-03-09 17:00:02 +0800184 /* Output queue contains all the QMP responses in order */
185 GQueue *qmp_responses;
Markus Armbruster74358f22015-03-06 19:35:59 +0100186} MonitorQMP;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200187
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100188/*
189 * To prevent flooding clients, events can be throttled. The
190 * throttling is calculated globally, rather than per-Monitor
191 * instance.
192 */
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200193typedef struct MonitorQAPIEventState {
Markus Armbruster7de0be62015-10-15 17:08:35 +0200194 QAPIEvent event; /* Throttling state for this event type and... */
195 QDict *data; /* ... data, see qapi_event_throttle_equal() */
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100196 QEMUTimer *timer; /* Timer for handling delayed events */
Markus Armbruster688b4b72015-10-15 17:08:30 +0200197 QDict *qdict; /* Delayed event (if any) */
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200198} MonitorQAPIEventState;
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100199
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200200typedef struct {
201 int64_t rate; /* Minimum time (in ns) between two events */
202} MonitorQAPIEventConf;
203
aliguori87127162009-03-05 23:01:29 +0000204struct Monitor {
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +0300205 CharBackend chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200206 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000207 int flags;
Peter Xudf152fb2018-03-09 16:59:55 +0800208 int suspend_cnt; /* Needs to be accessed atomically */
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400209 bool skip_flush;
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +0200210 bool use_io_thread;
Peter Xud9f25282018-06-08 11:55:07 +0800211
212 /*
213 * State used only in the thread "owning" the monitor.
Markus Armbrustercab5ad82018-07-03 10:53:46 +0200214 * If @use_io_thread, this is @mon_iothread.
Peter Xud9f25282018-06-08 11:55:07 +0800215 * Else, it's the main thread.
216 * These members can be safely accessed without locks.
217 */
aliguori731b0362009-03-05 23:01:42 +0000218 ReadLineState *rs;
Peter Xud9f25282018-06-08 11:55:07 +0800219
Markus Armbruster74358f22015-03-06 19:35:59 +0100220 MonitorQMP qmp;
Greg Kurz751f8cf2017-10-17 10:16:22 +0200221 gchar *mon_cpu_path;
Markus Armbruster097310b2014-10-07 13:59:15 +0200222 BlockCompletionFunc *password_completion_cb;
aliguori731b0362009-03-05 23:01:42 +0000223 void *password_opaque;
Wenchao Xia77172392013-08-27 20:38:20 +0800224 mon_cmd_t *cmd_table;
Peter Xu238d9f32018-03-09 16:59:51 +0800225 QTAILQ_ENTRY(Monitor) entry;
Peter Xudc7cbcd2018-06-08 11:55:05 +0800226
227 /*
228 * The per-monitor lock. We can't access guest memory when holding
229 * the lock.
230 */
231 QemuMutex mon_lock;
232
233 /*
234 * Fields that are protected by the per-monitor lock.
235 */
Peter Xu9409fc02018-06-08 11:55:06 +0800236 QLIST_HEAD(, mon_fd_t) fds;
Peter Xudc7cbcd2018-06-08 11:55:05 +0800237 QString *outbuf;
238 guint out_watch;
239 /* Read under either BQL or mon_lock, written with BQL+mon_lock. */
240 int mux_out;
aliguori87127162009-03-05 23:01:29 +0000241};
242
Markus Armbrustercab5ad82018-07-03 10:53:46 +0200243IOThread *mon_iothread;
244
245/* Bottom half to dispatch the requests received from I/O thread */
246QEMUBH *qmp_dispatcher_bh;
247
248/* Bottom half to deliver the responses back to clients */
249QEMUBH *qmp_respond_bh;
Peter Xua5ed3522018-03-09 16:59:52 +0800250
Peter Xu6d2d5632018-03-26 14:38:55 +0800251struct QMPRequest {
252 /* Owner of the request */
253 Monitor *mon;
254 /* "id" field of the request */
255 QObject *id;
Markus Armbruster1cc37472018-07-03 10:53:44 +0200256 /*
257 * Request object to be handled or Error to be reported
258 * (exactly one of them is non-null)
259 */
Peter Xu6d2d5632018-03-26 14:38:55 +0800260 QObject *req;
Markus Armbruster1cc37472018-07-03 10:53:44 +0200261 Error *err;
Peter Xu6d2d5632018-03-26 14:38:55 +0800262 /*
263 * Whether we need to resume the monitor afterward. This flag is
264 * used to emulate the old QMP server behavior that the current
265 * command must be completed before execution of the next one.
266 */
267 bool need_resume;
268};
269typedef struct QMPRequest QMPRequest;
270
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300271/* QMP checker flags */
272#define QMP_ACCEPT_UNKNOWNS 1
273
Peter Xu095cb1b2018-06-08 11:55:08 +0800274/* Protects mon_list, monitor_qapi_event_state. */
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200275static QemuMutex monitor_lock;
Peter Xu095cb1b2018-06-08 11:55:08 +0800276static GHashTable *monitor_qapi_event_state;
Peter Xu238d9f32018-03-09 16:59:51 +0800277static QTAILQ_HEAD(mon_list, Monitor) mon_list;
Peter Xu095cb1b2018-06-08 11:55:08 +0800278
Peter Xu47451462018-06-08 11:55:11 +0800279/* Protects mon_fdsets */
280static QemuMutex mon_fdsets_lock;
Corey Bryantba1c0482012-08-14 16:43:43 -0400281static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
Peter Xu47451462018-06-08 11:55:11 +0800282
Corey Bryantefb87c12012-08-14 16:43:48 -0400283static int mon_refcount;
bellard7e2515e2004-08-01 21:52:19 +0000284
Wayne Xia816f8922011-10-12 11:32:41 +0800285static mon_cmd_t mon_cmds[];
286static mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000287
Markus Armbruster635db182017-03-03 13:32:27 +0100288QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
Markus Armbruster1527bad2017-03-03 13:32:25 +0100289
Markus Armbruster8631b602010-02-18 11:41:55 +0100290Monitor *cur_mon;
aliguori376253e2009-03-05 23:01:23 +0000291
Stefan Hajnoczic60bf332013-11-14 11:54:14 +0100292static void monitor_command_cb(void *opaque, const char *cmdline,
293 void *readline_opaque);
aliguori83ab7952008-08-19 14:44:22 +0000294
Markus Armbruster9f3982f2015-03-06 19:56:38 +0100295/**
296 * Is @mon a QMP monitor?
297 */
298static inline bool monitor_is_qmp(const Monitor *mon)
Luiz Capitulino418173c2009-11-26 22:58:51 -0200299{
300 return (mon->flags & MONITOR_USE_CONTROL);
301}
302
Markus Armbruster489653b2015-03-06 20:01:05 +0100303/**
Peter Xue3e977d2018-03-09 16:59:56 +0800304 * Whether @mon is using readline? Note: not all HMP monitors use
305 * readline, e.g., gdbserver has a non-interactive HMP monitor, so
306 * readline is not used there.
307 */
308static inline bool monitor_uses_readline(const Monitor *mon)
309{
310 return mon->flags & MONITOR_USE_READLINE;
311}
312
313static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
314{
315 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
316}
317
Peter Xu6e8c5f42018-06-08 11:55:09 +0800318/*
319 * Return the clock to use for recording an event's time.
320 * Beware: result is invalid before configure_accelerator().
321 */
322static inline QEMUClockType monitor_get_event_clock(void)
323{
324 /*
325 * This allows us to perform tests on the monitor queues to verify
326 * that the rate limits are enforced.
327 */
328 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
329}
330
Peter Xue3e977d2018-03-09 16:59:56 +0800331/**
Markus Armbruster489653b2015-03-06 20:01:05 +0100332 * Is the current monitor, if any, a QMP monitor?
333 */
334bool monitor_cur_is_qmp(void)
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100335{
Markus Armbruster9f3982f2015-03-06 19:56:38 +0100336 return cur_mon && monitor_is_qmp(cur_mon);
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100337}
338
Anthony Liguori7060b472011-09-02 12:34:50 -0500339void monitor_read_command(Monitor *mon, int show_prompt)
aliguori731b0362009-03-05 23:01:42 +0000340{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200341 if (!mon->rs)
342 return;
343
aliguori731b0362009-03-05 23:01:42 +0000344 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
345 if (show_prompt)
346 readline_show_prompt(mon->rs);
347}
bellard6a00d602005-11-21 23:25:50 +0000348
Anthony Liguori7060b472011-09-02 12:34:50 -0500349int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
350 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000351{
Markus Armbrusterbcf5d192015-03-12 17:26:46 +0100352 if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000353 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
354 /* prompt is printed on return from the command handler */
355 return 0;
356 } else {
357 monitor_printf(mon, "terminal does not support password prompting\n");
358 return -ENOTTY;
359 }
aliguoribb5fc202009-03-05 23:01:15 +0000360}
361
Peter Xu6d2d5632018-03-26 14:38:55 +0800362static void qmp_request_free(QMPRequest *req)
363{
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200364 qobject_unref(req->id);
365 qobject_unref(req->req);
Markus Armbruster1cc37472018-07-03 10:53:44 +0200366 error_free(req->err);
Peter Xu6d2d5632018-03-26 14:38:55 +0800367 g_free(req);
368}
369
370/* Must with the mon->qmp.qmp_queue_lock held */
371static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
372{
373 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
374 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
375 }
376}
377
378/* Must with the mon->qmp.qmp_queue_lock held */
379static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
380{
381 while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200382 qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
Peter Xu6d2d5632018-03-26 14:38:55 +0800383 }
384}
385
386static void monitor_qmp_cleanup_queues(Monitor *mon)
387{
388 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
389 monitor_qmp_cleanup_req_queue_locked(mon);
390 monitor_qmp_cleanup_resp_queue_locked(mon);
391 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
392}
393
394
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200395static void monitor_flush_locked(Monitor *mon);
396
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100397static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
398 void *opaque)
399{
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200400 Monitor *mon = opaque;
401
Peter Xudc7cbcd2018-06-08 11:55:05 +0800402 qemu_mutex_lock(&mon->mon_lock);
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200403 mon->out_watch = 0;
404 monitor_flush_locked(mon);
Peter Xudc7cbcd2018-06-08 11:55:05 +0800405 qemu_mutex_unlock(&mon->mon_lock);
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100406 return FALSE;
407}
408
Peter Xudc7cbcd2018-06-08 11:55:05 +0800409/* Called with mon->mon_lock held. */
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200410static void monitor_flush_locked(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000411{
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100412 int rc;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400413 size_t len;
414 const char *buf;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100415
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400416 if (mon->skip_flush) {
417 return;
418 }
419
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400420 buf = qstring_get_str(mon->outbuf);
421 len = qstring_get_length(mon->outbuf);
422
Paolo Bonzinia4cc73d2013-05-31 14:00:27 +0200423 if (len && !mon->mux_out) {
Marc-André Lureau5345fdb2016-10-22 12:52:55 +0300424 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
Stratos Psomadakis056f49f2014-01-27 12:30:15 +0200425 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
426 /* all flushed or error */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200427 qobject_unref(mon->outbuf);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400428 mon->outbuf = qstring_new();
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100429 return;
430 }
431 if (rc > 0) {
Eric Blake3b7c78c2016-05-17 16:00:15 -0600432 /* partial write */
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400433 QString *tmp = qstring_from_str(buf + rc);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200434 qobject_unref(mon->outbuf);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400435 mon->outbuf = tmp;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100436 }
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200437 if (mon->out_watch == 0) {
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +0300438 mon->out_watch =
Marc-André Lureau5345fdb2016-10-22 12:52:55 +0300439 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +0300440 monitor_unblocked, mon);
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200441 }
bellard7e2515e2004-08-01 21:52:19 +0000442 }
443}
444
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200445void monitor_flush(Monitor *mon)
446{
Peter Xudc7cbcd2018-06-08 11:55:05 +0800447 qemu_mutex_lock(&mon->mon_lock);
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200448 monitor_flush_locked(mon);
Peter Xudc7cbcd2018-06-08 11:55:05 +0800449 qemu_mutex_unlock(&mon->mon_lock);
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200450}
451
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400452/* flush at every end of line */
aliguori376253e2009-03-05 23:01:23 +0000453static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000454{
ths60fe76f2007-12-16 03:02:09 +0000455 char c;
aliguori731b0362009-03-05 23:01:42 +0000456
Peter Xudc7cbcd2018-06-08 11:55:05 +0800457 qemu_mutex_lock(&mon->mon_lock);
bellard7e2515e2004-08-01 21:52:19 +0000458 for(;;) {
459 c = *str++;
460 if (c == '\0')
461 break;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400462 if (c == '\n') {
463 qstring_append_chr(mon->outbuf, '\r');
464 }
465 qstring_append_chr(mon->outbuf, c);
466 if (c == '\n') {
Paolo Bonzini6cff3e82014-06-18 08:43:59 +0200467 monitor_flush_locked(mon);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400468 }
bellard7e2515e2004-08-01 21:52:19 +0000469 }
Peter Xudc7cbcd2018-06-08 11:55:05 +0800470 qemu_mutex_unlock(&mon->mon_lock);
bellard7e2515e2004-08-01 21:52:19 +0000471}
472
aliguori376253e2009-03-05 23:01:23 +0000473void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000474{
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400475 char *buf;
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200476
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200477 if (!mon)
478 return;
479
Markus Armbruster9f3982f2015-03-06 19:56:38 +0100480 if (monitor_is_qmp(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200481 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200482 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200483
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400484 buf = g_strdup_vprintf(fmt, ap);
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200485 monitor_puts(mon, buf);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400486 g_free(buf);
bellard7e2515e2004-08-01 21:52:19 +0000487}
488
aliguori376253e2009-03-05 23:01:23 +0000489void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000490{
491 va_list ap;
492 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000493 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000494 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000495}
496
Pavel Butsykincaf15312015-09-22 16:18:17 +0300497int monitor_fprintf(FILE *stream, const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000498{
499 va_list ap;
500 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000501 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000502 va_end(ap);
503 return 0;
504}
505
Peter Xuabe3cd02018-03-09 17:00:02 +0800506static void monitor_json_emitter_raw(Monitor *mon,
507 QObject *data)
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200508{
509 QString *json;
510
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200511 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
512 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200513 assert(json != NULL);
514
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200515 qstring_append_chr(json, '\n');
516 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200517
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200518 qobject_unref(json);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200519}
520
Peter Xuabe3cd02018-03-09 17:00:02 +0800521static void monitor_json_emitter(Monitor *mon, QObject *data)
522{
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +0200523 if (mon->use_io_thread) {
Peter Xuabe3cd02018-03-09 17:00:02 +0800524 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +0200525 * If using I/O thread, we need to queue the item so that I/O
Peter Xuabe3cd02018-03-09 17:00:02 +0800526 * thread will do the rest for us. Take refcount so that
527 * caller won't free the data (which will be finally freed in
528 * responder thread).
529 */
Peter Xuabe3cd02018-03-09 17:00:02 +0800530 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
Marc-André Lureauf5a74a52018-04-19 17:01:44 +0200531 g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
Peter Xuabe3cd02018-03-09 17:00:02 +0800532 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
Markus Armbrustercab5ad82018-07-03 10:53:46 +0200533 qemu_bh_schedule(qmp_respond_bh);
Peter Xuabe3cd02018-03-09 17:00:02 +0800534 } else {
535 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +0200536 * If not using monitor I/O thread, then we are in main thread.
Peter Xuabe3cd02018-03-09 17:00:02 +0800537 * Do the emission right away.
538 */
539 monitor_json_emitter_raw(mon, data);
540 }
541}
542
543struct QMPResponse {
544 Monitor *mon;
545 QObject *data;
546};
547typedef struct QMPResponse QMPResponse;
548
Peter Xuc73a8432018-06-20 15:32:19 +0800549static QObject *monitor_qmp_response_pop_one(Monitor *mon)
550{
551 QObject *data;
552
553 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
554 data = g_queue_pop_head(mon->qmp.qmp_responses);
555 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
556
557 return data;
558}
559
560static void monitor_qmp_response_flush(Monitor *mon)
561{
562 QObject *data;
563
564 while ((data = monitor_qmp_response_pop_one(mon))) {
565 monitor_json_emitter_raw(mon, data);
566 qobject_unref(data);
567 }
568}
569
Peter Xuabe3cd02018-03-09 17:00:02 +0800570/*
Peter Xu40687eb2018-06-20 15:32:18 +0800571 * Pop a QMPResponse from any monitor's response queue into @response.
572 * Return false if all the queues are empty; else true.
Peter Xuabe3cd02018-03-09 17:00:02 +0800573 */
Peter Xu40687eb2018-06-20 15:32:18 +0800574static bool monitor_qmp_response_pop_any(QMPResponse *response)
Peter Xuabe3cd02018-03-09 17:00:02 +0800575{
576 Monitor *mon;
577 QObject *data = NULL;
578
579 qemu_mutex_lock(&monitor_lock);
580 QTAILQ_FOREACH(mon, &mon_list, entry) {
Peter Xuc73a8432018-06-20 15:32:19 +0800581 data = monitor_qmp_response_pop_one(mon);
Peter Xuabe3cd02018-03-09 17:00:02 +0800582 if (data) {
Peter Xu40687eb2018-06-20 15:32:18 +0800583 response->mon = mon;
584 response->data = data;
Peter Xuabe3cd02018-03-09 17:00:02 +0800585 break;
586 }
587 }
588 qemu_mutex_unlock(&monitor_lock);
Peter Xu40687eb2018-06-20 15:32:18 +0800589 return data != NULL;
Peter Xuabe3cd02018-03-09 17:00:02 +0800590}
591
592static void monitor_qmp_bh_responder(void *opaque)
593{
594 QMPResponse response;
595
Peter Xu40687eb2018-06-20 15:32:18 +0800596 while (monitor_qmp_response_pop_any(&response)) {
Peter Xuabe3cd02018-03-09 17:00:02 +0800597 monitor_json_emitter_raw(response.mon, response.data);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200598 qobject_unref(response.data);
Peter Xuabe3cd02018-03-09 17:00:02 +0800599 }
600}
601
Eric Blake7fb1cf12015-11-18 01:52:57 -0700602static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200603 /* Limit guest-triggerable events to 1 per second */
604 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
605 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
606 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
607 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
608 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
609 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
610};
611
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100612/*
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200613 * Emits the event to every monitor instance, @event is only used for trace
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200614 * Called with monitor_lock held.
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100615 */
Markus Armbruster688b4b72015-10-15 17:08:30 +0200616static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100617{
618 Monitor *mon;
619
Markus Armbruster688b4b72015-10-15 17:08:30 +0200620 trace_monitor_protocol_event_emit(event, qdict);
Peter Xu238d9f32018-03-09 16:59:51 +0800621 QTAILQ_FOREACH(mon, &mon_list, entry) {
Markus Armbruster635db182017-03-03 13:32:27 +0100622 if (monitor_is_qmp(mon)
623 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
Markus Armbruster688b4b72015-10-15 17:08:30 +0200624 monitor_json_emitter(mon, QOBJECT(qdict));
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100625 }
626 }
627}
628
Markus Armbrustera24712a2015-10-15 17:08:34 +0200629static void monitor_qapi_event_handler(void *opaque);
630
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100631/*
632 * Queue a new event for emission to Monitor instances,
633 * applying any rate limiting if required.
634 */
635static void
Markus Armbruster688b4b72015-10-15 17:08:30 +0200636monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100637{
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200638 MonitorQAPIEventConf *evconf;
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200639 MonitorQAPIEventState *evstate;
Markus Armbruster93f8f982015-10-15 17:08:31 +0200640
Eric Blake7fb1cf12015-11-18 01:52:57 -0700641 assert(event < QAPI_EVENT__MAX);
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200642 evconf = &monitor_qapi_event_conf[event];
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200643 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100644
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200645 qemu_mutex_lock(&monitor_lock);
Markus Armbruster93f8f982015-10-15 17:08:31 +0200646
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200647 if (!evconf->rate) {
Markus Armbruster93f8f982015-10-15 17:08:31 +0200648 /* Unthrottled event */
Markus Armbruster688b4b72015-10-15 17:08:30 +0200649 monitor_qapi_event_emit(event, qdict);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100650 } else {
Max Reitz7dc847e2018-02-24 16:40:29 +0100651 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
Markus Armbruster7de0be62015-10-15 17:08:35 +0200652 MonitorQAPIEventState key = { .event = event, .data = data };
Markus Armbrustera24712a2015-10-15 17:08:34 +0200653
654 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
655 assert(!evstate || timer_pending(evstate->timer));
656
657 if (evstate) {
Markus Armbruster93f8f982015-10-15 17:08:31 +0200658 /*
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200659 * Timer is pending for (at least) evconf->rate ns after
Markus Armbruster93f8f982015-10-15 17:08:31 +0200660 * last send. Store event for sending when timer fires,
661 * replacing a prior stored event if any.
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100662 */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200663 qobject_unref(evstate->qdict);
Marc-André Lureauf5a74a52018-04-19 17:01:44 +0200664 evstate->qdict = qobject_ref(qdict);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100665 } else {
Markus Armbruster93f8f982015-10-15 17:08:31 +0200666 /*
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200667 * Last send was (at least) evconf->rate ns ago.
Markus Armbruster93f8f982015-10-15 17:08:31 +0200668 * Send immediately, and arm the timer to call
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200669 * monitor_qapi_event_handler() in evconf->rate ns. Any
Markus Armbruster93f8f982015-10-15 17:08:31 +0200670 * events arriving before then will be delayed until then.
671 */
Peter Xu6e8c5f42018-06-08 11:55:09 +0800672 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
Markus Armbruster93f8f982015-10-15 17:08:31 +0200673
Markus Armbruster688b4b72015-10-15 17:08:30 +0200674 monitor_qapi_event_emit(event, qdict);
Markus Armbrustera24712a2015-10-15 17:08:34 +0200675
676 evstate = g_new(MonitorQAPIEventState, 1);
677 evstate->event = event;
Marc-André Lureauf5a74a52018-04-19 17:01:44 +0200678 evstate->data = qobject_ref(data);
Markus Armbrustera24712a2015-10-15 17:08:34 +0200679 evstate->qdict = NULL;
Peter Xu6e8c5f42018-06-08 11:55:09 +0800680 evstate->timer = timer_new_ns(monitor_get_event_clock(),
Markus Armbrustera24712a2015-10-15 17:08:34 +0200681 monitor_qapi_event_handler,
682 evstate);
683 g_hash_table_add(monitor_qapi_event_state, evstate);
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200684 timer_mod_ns(evstate->timer, now + evconf->rate);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100685 }
686 }
Markus Armbruster93f8f982015-10-15 17:08:31 +0200687
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200688 qemu_mutex_unlock(&monitor_lock);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100689}
690
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100691/*
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200692 * This function runs evconf->rate ns after sending a throttled
Markus Armbruster93f8f982015-10-15 17:08:31 +0200693 * event.
694 * If another event has since been stored, send it.
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100695 */
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200696static void monitor_qapi_event_handler(void *opaque)
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100697{
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200698 MonitorQAPIEventState *evstate = opaque;
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200699 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100700
Markus Armbruster93f8f982015-10-15 17:08:31 +0200701 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200702 qemu_mutex_lock(&monitor_lock);
Markus Armbruster93f8f982015-10-15 17:08:31 +0200703
Markus Armbruster688b4b72015-10-15 17:08:30 +0200704 if (evstate->qdict) {
Peter Xu6e8c5f42018-06-08 11:55:09 +0800705 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
Markus Armbruster93f8f982015-10-15 17:08:31 +0200706
Markus Armbruster688b4b72015-10-15 17:08:30 +0200707 monitor_qapi_event_emit(evstate->event, evstate->qdict);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200708 qobject_unref(evstate->qdict);
Markus Armbruster688b4b72015-10-15 17:08:30 +0200709 evstate->qdict = NULL;
Markus Armbrusterb9b03ab2015-10-15 17:08:33 +0200710 timer_mod_ns(evstate->timer, now + evconf->rate);
Markus Armbrustera24712a2015-10-15 17:08:34 +0200711 } else {
712 g_hash_table_remove(monitor_qapi_event_state, evstate);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200713 qobject_unref(evstate->data);
Markus Armbrustera24712a2015-10-15 17:08:34 +0200714 timer_free(evstate->timer);
715 g_free(evstate);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100716 }
Markus Armbruster93f8f982015-10-15 17:08:31 +0200717
Paolo Bonzinid622cb52014-06-18 08:44:00 +0200718 qemu_mutex_unlock(&monitor_lock);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100719}
720
Markus Armbrustera24712a2015-10-15 17:08:34 +0200721static unsigned int qapi_event_throttle_hash(const void *key)
722{
723 const MonitorQAPIEventState *evstate = key;
Markus Armbruster7de0be62015-10-15 17:08:35 +0200724 unsigned int hash = evstate->event * 255;
Markus Armbrustera24712a2015-10-15 17:08:34 +0200725
Markus Armbruster7de0be62015-10-15 17:08:35 +0200726 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
727 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
728 }
729
Alberto Garcia6d425eb2016-03-10 13:55:25 +0200730 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
731 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
732 }
733
Markus Armbruster7de0be62015-10-15 17:08:35 +0200734 return hash;
Markus Armbrustera24712a2015-10-15 17:08:34 +0200735}
736
737static gboolean qapi_event_throttle_equal(const void *a, const void *b)
738{
739 const MonitorQAPIEventState *eva = a;
740 const MonitorQAPIEventState *evb = b;
741
Markus Armbruster7de0be62015-10-15 17:08:35 +0200742 if (eva->event != evb->event) {
743 return FALSE;
744 }
745
746 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
747 return !strcmp(qdict_get_str(eva->data, "id"),
748 qdict_get_str(evb->data, "id"));
749 }
750
Alberto Garcia6d425eb2016-03-10 13:55:25 +0200751 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
752 return !strcmp(qdict_get_str(eva->data, "node-name"),
753 qdict_get_str(evb->data, "node-name"));
754 }
755
Markus Armbruster7de0be62015-10-15 17:08:35 +0200756 return TRUE;
Markus Armbrustera24712a2015-10-15 17:08:34 +0200757}
758
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200759static void monitor_qapi_event_init(void)
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100760{
Markus Armbrustera24712a2015-10-15 17:08:34 +0200761 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
762 qapi_event_throttle_equal);
Wenchao Xia43a14cf2014-06-18 08:43:31 +0200763 qmp_event_set_func_emit(monitor_qapi_event_queue);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200764}
765
Markus Armbruster7ef6cf62015-03-06 19:12:36 +0100766static void handle_hmp_command(Monitor *mon, const char *cmdline);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200767
Peter Xua5ed3522018-03-09 16:59:52 +0800768static void monitor_data_init(Monitor *mon, bool skip_flush,
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +0200769 bool use_io_thread)
Wenchao Xiab01fe892013-08-27 20:38:19 +0800770{
771 memset(mon, 0, sizeof(Monitor));
Peter Xudc7cbcd2018-06-08 11:55:05 +0800772 qemu_mutex_init(&mon->mon_lock);
Peter Xu71da4662018-03-09 16:59:57 +0800773 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
Wenchao Xiab01fe892013-08-27 20:38:19 +0800774 mon->outbuf = qstring_new();
Wenchao Xia77172392013-08-27 20:38:20 +0800775 /* Use *mon_cmds by default. */
776 mon->cmd_table = mon_cmds;
Peter Xu88a95d12018-03-09 16:59:48 +0800777 mon->skip_flush = skip_flush;
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +0200778 mon->use_io_thread = use_io_thread;
Peter Xu71da4662018-03-09 16:59:57 +0800779 mon->qmp.qmp_requests = g_queue_new();
Peter Xuabe3cd02018-03-09 17:00:02 +0800780 mon->qmp.qmp_responses = g_queue_new();
Wenchao Xiab01fe892013-08-27 20:38:19 +0800781}
782
783static void monitor_data_destroy(Monitor *mon)
784{
Greg Kurz751f8cf2017-10-17 10:16:22 +0200785 g_free(mon->mon_cpu_path);
Marc-André Lureau1ce26102017-01-27 00:49:13 +0400786 qemu_chr_fe_deinit(&mon->chr, false);
Marc-André Lureau2ef45712016-08-01 15:23:42 +0400787 if (monitor_is_qmp(mon)) {
788 json_message_parser_destroy(&mon->qmp.parser);
789 }
Marc-André Lureaue5dc1a62018-01-04 17:05:15 +0100790 readline_free(mon->rs);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200791 qobject_unref(mon->outbuf);
Peter Xudc7cbcd2018-06-08 11:55:05 +0800792 qemu_mutex_destroy(&mon->mon_lock);
Peter Xu71da4662018-03-09 16:59:57 +0800793 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
Peter Xu6d2d5632018-03-26 14:38:55 +0800794 monitor_qmp_cleanup_req_queue_locked(mon);
795 monitor_qmp_cleanup_resp_queue_locked(mon);
Peter Xu71da4662018-03-09 16:59:57 +0800796 g_queue_free(mon->qmp.qmp_requests);
Peter Xuabe3cd02018-03-09 17:00:02 +0800797 g_queue_free(mon->qmp.qmp_responses);
Wenchao Xiab01fe892013-08-27 20:38:19 +0800798}
799
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200800char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
801 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200802{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200803 char *output = NULL;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200804 Monitor *old_mon, hmp;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200805
Peter Xua5ed3522018-03-09 16:59:52 +0800806 monitor_data_init(&hmp, true, false);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200807
808 old_mon = cur_mon;
809 cur_mon = &hmp;
810
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200811 if (has_cpu_index) {
812 int ret = monitor_set_cpu(cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200813 if (ret < 0) {
814 cur_mon = old_mon;
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100815 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
816 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200817 goto out;
818 }
819 }
820
Markus Armbruster7ef6cf62015-03-06 19:12:36 +0100821 handle_hmp_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200822 cur_mon = old_mon;
823
Peter Xudc7cbcd2018-06-08 11:55:05 +0800824 qemu_mutex_lock(&hmp.mon_lock);
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400825 if (qstring_get_length(hmp.outbuf) > 0) {
826 output = g_strdup(qstring_get_str(hmp.outbuf));
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200827 } else {
828 output = g_strdup("");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200829 }
Peter Xudc7cbcd2018-06-08 11:55:05 +0800830 qemu_mutex_unlock(&hmp.mon_lock);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200831
832out:
Wenchao Xiab01fe892013-08-27 20:38:19 +0800833 monitor_data_destroy(&hmp);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200834 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200835}
836
bellard9dc39cb2004-03-14 21:38:27 +0000837static int compare_cmd(const char *name, const char *list)
838{
839 const char *p, *pstart;
840 int len;
841 len = strlen(name);
842 p = list;
843 for(;;) {
844 pstart = p;
Keno Fischer5c99fa32018-06-29 12:32:10 +0200845 p = qemu_strchrnul(p, '|');
bellard9dc39cb2004-03-14 21:38:27 +0000846 if ((p - pstart) == len && !memcmp(pstart, name, len))
847 return 1;
848 if (*p == '\0')
849 break;
850 p++;
851 }
852 return 0;
853}
854
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800855static int get_str(char *buf, int buf_size, const char **pp)
856{
857 const char *p;
858 char *q;
859 int c;
860
861 q = buf;
862 p = *pp;
863 while (qemu_isspace(*p)) {
864 p++;
865 }
866 if (*p == '\0') {
867 fail:
868 *q = '\0';
869 *pp = p;
870 return -1;
871 }
872 if (*p == '\"') {
873 p++;
874 while (*p != '\0' && *p != '\"') {
875 if (*p == '\\') {
876 p++;
877 c = *p++;
878 switch (c) {
879 case 'n':
880 c = '\n';
881 break;
882 case 'r':
883 c = '\r';
884 break;
885 case '\\':
886 case '\'':
887 case '\"':
888 break;
889 default:
Peter Maydell71baf782015-08-19 16:20:19 +0100890 printf("unsupported escape code: '\\%c'\n", c);
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800891 goto fail;
892 }
893 if ((q - buf) < buf_size - 1) {
894 *q++ = c;
895 }
896 } else {
897 if ((q - buf) < buf_size - 1) {
898 *q++ = *p;
899 }
900 p++;
901 }
902 }
903 if (*p != '\"') {
Peter Maydell71baf782015-08-19 16:20:19 +0100904 printf("unterminated string\n");
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800905 goto fail;
906 }
907 p++;
908 } else {
909 while (*p != '\0' && !qemu_isspace(*p)) {
910 if ((q - buf) < buf_size - 1) {
911 *q++ = *p;
912 }
913 p++;
914 }
915 }
916 *q = '\0';
917 *pp = p;
918 return 0;
919}
920
921#define MAX_ARGS 16
922
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800923static void free_cmdline_args(char **args, int nb_args)
924{
925 int i;
926
927 assert(nb_args <= MAX_ARGS);
928
929 for (i = 0; i < nb_args; i++) {
930 g_free(args[i]);
931 }
932
933}
934
935/*
936 * Parse the command line to get valid args.
937 * @cmdline: command line to be parsed.
938 * @pnb_args: location to store the number of args, must NOT be NULL.
939 * @args: location to store the args, which should be freed by caller, must
940 * NOT be NULL.
941 *
942 * Returns 0 on success, negative on failure.
943 *
944 * NOTE: this parser is an approximate form of the real command parser. Number
945 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
946 * return with failure.
947 */
948static int parse_cmdline(const char *cmdline,
949 int *pnb_args, char **args)
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800950{
951 const char *p;
952 int nb_args, ret;
953 char buf[1024];
954
955 p = cmdline;
956 nb_args = 0;
957 for (;;) {
958 while (qemu_isspace(*p)) {
959 p++;
960 }
961 if (*p == '\0') {
962 break;
963 }
964 if (nb_args >= MAX_ARGS) {
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800965 goto fail;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800966 }
967 ret = get_str(buf, sizeof(buf), &p);
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800968 if (ret < 0) {
969 goto fail;
970 }
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800971 args[nb_args] = g_strdup(buf);
972 nb_args++;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800973 }
974 *pnb_args = nb_args;
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800975 return 0;
976
977 fail:
978 free_cmdline_args(args, nb_args);
979 return -1;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800980}
981
Dr. David Alan Gilbertc3120f72018-06-20 16:39:41 +0100982/*
983 * Returns true if the command can be executed in preconfig mode
984 * i.e. it has the 'p' flag.
985 */
986static bool cmd_can_preconfig(const mon_cmd_t *cmd)
987{
988 if (!cmd->flags) {
989 return false;
990 }
991
992 return strchr(cmd->flags, 'p');
993}
994
Wenchao Xia66855492013-08-27 20:38:23 +0800995static void help_cmd_dump_one(Monitor *mon,
996 const mon_cmd_t *cmd,
997 char **prefix_args,
998 int prefix_args_nb)
999{
1000 int i;
1001
Dr. David Alan Gilbert31785f12018-06-20 16:39:42 +01001002 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
1003 return;
1004 }
1005
Wenchao Xia66855492013-08-27 20:38:23 +08001006 for (i = 0; i < prefix_args_nb; i++) {
1007 monitor_printf(mon, "%s ", prefix_args[i]);
1008 }
1009 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
1010}
1011
1012/* @args[@arg_index] is the valid command need to find in @cmds */
Anthony Liguoric227f092009-10-01 16:12:16 -05001013static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
Wenchao Xia66855492013-08-27 20:38:23 +08001014 char **args, int nb_args, int arg_index)
bellard9dc39cb2004-03-14 21:38:27 +00001015{
Anthony Liguoric227f092009-10-01 16:12:16 -05001016 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +00001017
Wenchao Xia66855492013-08-27 20:38:23 +08001018 /* No valid arg need to compare with, dump all in *cmds */
1019 if (arg_index >= nb_args) {
1020 for (cmd = cmds; cmd->name != NULL; cmd++) {
1021 help_cmd_dump_one(mon, cmd, args, arg_index);
1022 }
1023 return;
1024 }
1025
1026 /* Find one entry to dump */
1027 for (cmd = cmds; cmd->name != NULL; cmd++) {
Dr. David Alan Gilbert31785f12018-06-20 16:39:42 +01001028 if (compare_cmd(args[arg_index], cmd->name) &&
1029 ((!runstate_check(RUN_STATE_PRECONFIG) ||
1030 cmd_can_preconfig(cmd)))) {
Wenchao Xia66855492013-08-27 20:38:23 +08001031 if (cmd->sub_table) {
1032 /* continue with next arg */
1033 help_cmd_dump(mon, cmd->sub_table,
1034 args, nb_args, arg_index + 1);
1035 } else {
1036 help_cmd_dump_one(mon, cmd, args, arg_index);
1037 }
1038 break;
1039 }
bellard9dc39cb2004-03-14 21:38:27 +00001040 }
1041}
1042
aliguori376253e2009-03-05 23:01:23 +00001043static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +00001044{
Wenchao Xia66855492013-08-27 20:38:23 +08001045 char *args[MAX_ARGS];
1046 int nb_args = 0;
1047
1048 /* 1. parse user input */
1049 if (name) {
1050 /* special case for log, directly dump and return */
1051 if (!strcmp(name, "log")) {
Peter Maydell38dad9e2013-02-11 16:41:25 +00001052 const QEMULogItem *item;
aliguori376253e2009-03-05 23:01:23 +00001053 monitor_printf(mon, "Log items (comma separated):\n");
1054 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
Peter Maydell38dad9e2013-02-11 16:41:25 +00001055 for (item = qemu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +00001056 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +00001057 }
Wenchao Xia66855492013-08-27 20:38:23 +08001058 return;
1059 }
1060
1061 if (parse_cmdline(name, &nb_args, args) < 0) {
1062 return;
bellardf193c792004-03-21 17:06:25 +00001063 }
bellard9dc39cb2004-03-14 21:38:27 +00001064 }
Wenchao Xia66855492013-08-27 20:38:23 +08001065
1066 /* 2. dump the contents according to parsed args */
1067 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1068
1069 free_cmdline_args(args, nb_args);
bellard9dc39cb2004-03-14 21:38:27 +00001070}
1071
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001072static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -03001073{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001074 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -03001075}
1076
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001077static void hmp_trace_event(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +05301078{
1079 const char *tp_name = qdict_get_str(qdict, "name");
1080 bool new_state = qdict_get_bool(qdict, "option");
Lluís Vilanova77e2b172016-07-11 12:53:57 +02001081 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1082 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
Lluís Vilanova14101d02014-08-25 13:20:03 +02001083 Error *local_err = NULL;
Blue Swirlf871d682010-10-13 19:14:29 +00001084
Lluís Vilanova77e2b172016-07-11 12:53:57 +02001085 if (vcpu < 0) {
1086 monitor_printf(mon, "argument vcpu must be positive");
1087 return;
1088 }
1089
1090 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
Lluís Vilanova14101d02014-08-25 13:20:03 +02001091 if (local_err) {
Markus Armbruster091e38b2015-02-10 15:15:43 +01001092 error_report_err(local_err);
Blue Swirlf871d682010-10-13 19:14:29 +00001093 }
Prerna Saxena22890ab2010-06-24 17:04:53 +05301094}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +01001095
Michael Rothc45a8162011-10-02 08:44:37 -05001096#ifdef CONFIG_TRACE_SIMPLE
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001097static void hmp_trace_file(Monitor *mon, const QDict *qdict)
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +01001098{
1099 const char *op = qdict_get_try_str(qdict, "op");
1100 const char *arg = qdict_get_try_str(qdict, "arg");
1101
1102 if (!op) {
1103 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1104 } else if (!strcmp(op, "on")) {
1105 st_set_trace_file_enabled(true);
1106 } else if (!strcmp(op, "off")) {
1107 st_set_trace_file_enabled(false);
1108 } else if (!strcmp(op, "flush")) {
1109 st_flush_trace_buffer();
1110 } else if (!strcmp(op, "set")) {
1111 if (arg) {
1112 st_set_trace_file(arg);
1113 }
1114 } else {
1115 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1116 help_cmd(mon, "trace-file");
1117 }
1118}
Prerna Saxena22890ab2010-06-24 17:04:53 +05301119#endif
1120
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001121static void hmp_info_help(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +00001122{
Luiz Capitulino13c74252009-10-07 13:41:55 -03001123 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +00001124}
1125
Marc-André Lureau9e812b62016-09-12 13:19:05 +04001126static void query_commands_cb(QmpCommand *cmd, void *opaque)
bellard9bc9d1c2004-10-10 15:15:51 +00001127{
Marc-André Lureau9e812b62016-09-12 13:19:05 +04001128 CommandInfoList *info, **list = opaque;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001129
Marc-André Lureau9e812b62016-09-12 13:19:05 +04001130 if (!cmd->enabled) {
1131 return;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001132 }
1133
Marc-André Lureau9e812b62016-09-12 13:19:05 +04001134 info = g_malloc0(sizeof(*info));
1135 info->value = g_malloc0(sizeof(*info->value));
1136 info->value->name = g_strdup(cmd->name);
1137 info->next = *list;
1138 *list = info;
1139}
1140
1141CommandInfoList *qmp_query_commands(Error **errp)
1142{
1143 CommandInfoList *list = NULL;
1144
Markus Armbruster635db182017-03-03 13:32:27 +01001145 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
Marc-André Lureau9e812b62016-09-12 13:19:05 +04001146
1147 return list;
thsa36e69d2007-12-02 05:18:19 +00001148}
1149
Daniel P. Berrange48608532012-05-21 17:59:51 +01001150EventInfoList *qmp_query_events(Error **errp)
1151{
1152 EventInfoList *info, *ev_list = NULL;
Wenchao Xia75175172014-06-18 08:43:54 +02001153 QAPIEvent e;
Daniel P. Berrange48608532012-05-21 17:59:51 +01001154
Eric Blake7fb1cf12015-11-18 01:52:57 -07001155 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02001156 const char *event_name = QAPIEvent_str(e);
Daniel P. Berrange48608532012-05-21 17:59:51 +01001157 assert(event_name != NULL);
1158 info = g_malloc0(sizeof(*info));
1159 info->value = g_malloc0(sizeof(*info->value));
1160 info->value->name = g_strdup(event_name);
1161
1162 info->next = ev_list;
1163 ev_list = info;
1164 }
1165
1166 return ev_list;
1167}
1168
Markus Armbruster39a18152015-09-16 13:06:28 +02001169/*
1170 * Minor hack: generated marshalling suppressed for this command
1171 * ('gen': false in the schema) so we can parse the JSON string
1172 * directly into QObject instead of first parsing it with
1173 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1174 * to QObject with generated output marshallers, every time. Instead,
Daniel P. Berrangeb3db2112016-09-30 15:45:27 +01001175 * we do it in test-qobject-input-visitor.c, just to make sure
Markus Armbrusterfb0bc832018-02-26 13:48:58 -06001176 * qapi-gen.py's output actually conforms to the schema.
Markus Armbruster39a18152015-09-16 13:06:28 +02001177 */
1178static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1179 Error **errp)
1180{
Marc-André Lureau7d0f9822018-03-05 18:29:51 +01001181 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
Markus Armbruster39a18152015-09-16 13:06:28 +02001182}
1183
Marc-André Lureau5032a162016-09-12 13:19:02 +04001184/*
Marc-André Lureau5032a162016-09-12 13:19:02 +04001185 * We used to define commands in qmp-commands.hx in addition to the
1186 * QAPI schema. This permitted defining some of them only in certain
1187 * configurations. query-commands has always reflected that (good,
1188 * because it lets QMP clients figure out what's actually available),
1189 * while query-qmp-schema never did (not so good). This function is a
1190 * hack to keep the configuration-specific commands defined exactly as
1191 * before, even though qmp-commands.hx is gone.
1192 *
1193 * FIXME Educate the QAPI schema on configuration-specific commands,
1194 * and drop this hack.
1195 */
1196static void qmp_unregister_commands_hack(void)
1197{
1198#ifndef CONFIG_SPICE
Markus Armbruster1527bad2017-03-03 13:32:25 +01001199 qmp_unregister_command(&qmp_commands, "query-spice");
Marc-André Lureau5032a162016-09-12 13:19:02 +04001200#endif
Markus Armbruster38bb54f2017-04-27 15:00:53 +02001201#ifndef CONFIG_REPLICATION
1202 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1203 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1204 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1205#endif
Marc-André Lureau5032a162016-09-12 13:19:02 +04001206#ifndef TARGET_I386
Markus Armbruster1527bad2017-03-03 13:32:25 +01001207 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
Brijesh Singh08a161f2018-03-08 06:48:42 -06001208 qmp_unregister_command(&qmp_commands, "query-sev");
Brijesh Singh1b6a0342018-03-08 06:48:56 -06001209 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
Brijesh Singh31dd67f2018-03-08 06:48:59 -06001210 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
Marc-André Lureau5032a162016-09-12 13:19:02 +04001211#endif
1212#ifndef TARGET_S390X
Markus Armbruster1527bad2017-03-03 13:32:25 +01001213 qmp_unregister_command(&qmp_commands, "dump-skeys");
Marc-André Lureau5032a162016-09-12 13:19:02 +04001214#endif
1215#ifndef TARGET_ARM
Markus Armbruster1527bad2017-03-03 13:32:25 +01001216 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
Marc-André Lureau5032a162016-09-12 13:19:02 +04001217#endif
Eduardo Habkostf99fd7c2017-02-22 16:00:28 -03001218#if !defined(TARGET_S390X) && !defined(TARGET_I386)
Markus Armbruster1527bad2017-03-03 13:32:25 +01001219 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
Eduardo Habkostf99fd7c2017-02-22 16:00:28 -03001220#endif
1221#if !defined(TARGET_S390X)
Markus Armbruster1527bad2017-03-03 13:32:25 +01001222 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1223 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
Eduardo Habkost728b1422016-10-05 16:49:01 -03001224#endif
1225#if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1226 && !defined(TARGET_S390X)
Markus Armbruster1527bad2017-03-03 13:32:25 +01001227 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
Eduardo Habkost728b1422016-10-05 16:49:01 -03001228#endif
Marc-André Lureau5032a162016-09-12 13:19:02 +04001229}
1230
Peter Xu6adf08d2018-03-09 16:59:50 +08001231static void monitor_init_qmp_commands(void)
Marc-André Lureauedcfaef2016-09-12 13:19:00 +04001232{
Markus Armbruster635db182017-03-03 13:32:27 +01001233 /*
1234 * Two command lists:
1235 * - qmp_commands contains all QMP commands
1236 * - qmp_cap_negotiation_commands contains just
1237 * "qmp_capabilities", to enforce capability negotiation
1238 */
1239
Markus Armbruster1527bad2017-03-03 13:32:25 +01001240 qmp_init_marshal(&qmp_commands);
Markus Armbruster05875682017-03-03 13:32:24 +01001241
Markus Armbruster1527bad2017-03-03 13:32:25 +01001242 qmp_register_command(&qmp_commands, "query-qmp-schema",
Igor Mammedovd6fe3d02018-05-11 18:51:43 +02001243 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
Markus Armbruster1527bad2017-03-03 13:32:25 +01001244 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
Marc-André Lureauedcfaef2016-09-12 13:19:00 +04001245 QCO_NO_OPTIONS);
Markus Armbruster1527bad2017-03-03 13:32:25 +01001246 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
Marc-André Lureauedcfaef2016-09-12 13:19:00 +04001247 QCO_NO_OPTIONS);
Marc-André Lureau5032a162016-09-12 13:19:02 +04001248
Markus Armbruster05875682017-03-03 13:32:24 +01001249 qmp_unregister_commands_hack();
Markus Armbruster635db182017-03-03 13:32:27 +01001250
1251 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1252 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
Igor Mammedovd6fe3d02018-05-11 18:51:43 +02001253 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
Markus Armbruster635db182017-03-03 13:32:27 +01001254}
1255
Peter Xu71da4662018-03-09 16:59:57 +08001256static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
1257{
1258 return mon->qmp.qmp_caps[cap];
1259}
1260
1261static bool qmp_oob_enabled(Monitor *mon)
1262{
1263 return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
1264}
1265
Peter Xu02130312018-03-09 16:59:53 +08001266static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
1267 Error **errp)
Markus Armbruster635db182017-03-03 13:32:27 +01001268{
Peter Xu02130312018-03-09 16:59:53 +08001269 for (; list; list = list->next) {
1270 assert(list->value < QMP_CAPABILITY__MAX);
1271 switch (list->value) {
1272 case QMP_CAPABILITY_OOB:
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02001273 if (!mon->use_io_thread) {
Peter Xu02130312018-03-09 16:59:53 +08001274 /*
Markus Armbrusterc0698212018-07-03 10:53:27 +02001275 * Out-of-band only works with monitors that are
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02001276 * running on dedicated I/O thread.
Peter Xu02130312018-03-09 16:59:53 +08001277 */
1278 error_setg(errp, "This monitor does not support "
Markus Armbrusterc0698212018-07-03 10:53:27 +02001279 "out-of-band (OOB)");
Peter Xu02130312018-03-09 16:59:53 +08001280 return;
1281 }
1282 break;
1283 default:
1284 break;
1285 }
1286 }
1287}
1288
1289/* This function should only be called after capabilities are checked. */
1290static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
1291{
1292 for (; list; list = list->next) {
1293 mon->qmp.qmp_caps[list->value] = true;
1294 }
1295}
1296
1297void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1298 Error **errp)
1299{
1300 Error *local_err = NULL;
1301
Markus Armbruster635db182017-03-03 13:32:27 +01001302 if (cur_mon->qmp.commands == &qmp_commands) {
1303 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1304 "Capabilities negotiation is already complete, command "
1305 "ignored");
1306 return;
1307 }
1308
Peter Xu02130312018-03-09 16:59:53 +08001309 /* Enable QMP capabilities provided by the client if applicable. */
1310 if (has_enable) {
1311 qmp_caps_check(cur_mon, enable, &local_err);
1312 if (local_err) {
1313 /*
1314 * Failed check on any of the capabilities will fail the
1315 * entire command (and thus not apply any of the other
1316 * capabilities that were also requested).
1317 */
1318 error_propagate(errp, local_err);
1319 return;
1320 }
1321 qmp_caps_apply(cur_mon, enable);
1322 }
1323
Markus Armbruster635db182017-03-03 13:32:27 +01001324 cur_mon->qmp.commands = &qmp_commands;
Marc-André Lureauedcfaef2016-09-12 13:19:00 +04001325}
1326
Peter Xud9f25282018-06-08 11:55:07 +08001327/* Set the current CPU defined by the user. Callers must hold BQL. */
Luiz Capitulinob025c8b2011-10-06 14:02:57 -03001328int monitor_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +00001329{
Andreas Färber55e5c282012-12-17 06:18:02 +01001330 CPUState *cpu;
bellard6a00d602005-11-21 23:25:50 +00001331
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001332 cpu = qemu_get_cpu(cpu_index);
1333 if (cpu == NULL) {
1334 return -1;
bellard6a00d602005-11-21 23:25:50 +00001335 }
Greg Kurz751f8cf2017-10-17 10:16:22 +02001336 g_free(cur_mon->mon_cpu_path);
1337 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001338 return 0;
bellard6a00d602005-11-21 23:25:50 +00001339}
1340
Peter Xud9f25282018-06-08 11:55:07 +08001341/* Callers must hold BQL. */
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +01001342static CPUState *mon_get_cpu_sync(bool synchronize)
bellard6a00d602005-11-21 23:25:50 +00001343{
Greg Kurz751f8cf2017-10-17 10:16:22 +02001344 CPUState *cpu;
1345
1346 if (cur_mon->mon_cpu_path) {
1347 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1348 TYPE_CPU, NULL);
1349 if (!cpu) {
1350 g_free(cur_mon->mon_cpu_path);
1351 cur_mon->mon_cpu_path = NULL;
1352 }
1353 }
1354 if (!cur_mon->mon_cpu_path) {
Thomas Huth854e67f2017-01-13 13:12:35 +01001355 if (!first_cpu) {
1356 return NULL;
1357 }
David Gibson27a83f82016-09-21 15:29:26 +10001358 monitor_set_cpu(first_cpu->cpu_index);
Greg Kurz751f8cf2017-10-17 10:16:22 +02001359 cpu = first_cpu;
bellard6a00d602005-11-21 23:25:50 +00001360 }
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +01001361 if (synchronize) {
1362 cpu_synchronize_state(cpu);
1363 }
Greg Kurz751f8cf2017-10-17 10:16:22 +02001364 return cpu;
Peter Crosthwaite5bcda5f2015-05-24 14:20:40 -07001365}
1366
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +01001367CPUState *mon_get_cpu(void)
1368{
1369 return mon_get_cpu_sync(true);
1370}
1371
Pavel Butsykinbf957282015-09-10 18:38:59 +03001372CPUArchState *mon_get_cpu_env(void)
Peter Crosthwaite5bcda5f2015-05-24 14:20:40 -07001373{
Thomas Huth854e67f2017-01-13 13:12:35 +01001374 CPUState *cs = mon_get_cpu();
1375
1376 return cs ? cs->env_ptr : NULL;
bellard6a00d602005-11-21 23:25:50 +00001377}
1378
Luiz Capitulino99b77962011-10-24 10:53:44 -02001379int monitor_get_cpu_index(void)
1380{
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +01001381 CPUState *cs = mon_get_cpu_sync(false);
Thomas Huth854e67f2017-01-13 13:12:35 +01001382
1383 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
Luiz Capitulino99b77962011-10-24 10:53:44 -02001384}
1385
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001386static void hmp_info_registers(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001387{
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +10001388 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1389 CPUState *cs;
Thomas Huth854e67f2017-01-13 13:12:35 +01001390
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +10001391 if (all_cpus) {
1392 CPU_FOREACH(cs) {
1393 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1394 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1395 }
1396 } else {
1397 cs = mon_get_cpu();
1398
1399 if (!cs) {
1400 monitor_printf(mon, "No CPU available\n");
1401 return;
1402 }
1403
1404 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
Thomas Huth854e67f2017-01-13 13:12:35 +01001405 }
bellard9307c4c2004-04-04 12:57:25 +00001406}
1407
Paolo Bonzinif0d14a92012-09-17 13:42:41 +02001408#ifdef CONFIG_TCG
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001409static void hmp_info_jit(Monitor *mon, const QDict *qdict)
bellarde3db7222005-01-26 22:00:47 +00001410{
Thomas Huthb7da97e2017-04-26 06:11:47 +02001411 if (!tcg_enabled()) {
1412 error_report("JIT information is only available with accel=tcg");
1413 return;
1414 }
1415
aliguori376253e2009-03-05 23:01:23 +00001416 dump_exec_info((FILE *)mon, monitor_fprintf);
Sebastian Tanase27498be2014-07-25 11:56:33 +02001417 dump_drift_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +00001418}
1419
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001420static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
Max Filippov246ae242014-11-02 11:04:18 +03001421{
1422 dump_opcount_info((FILE *)mon, monitor_fprintf);
1423}
Paolo Bonzinif0d14a92012-09-17 13:42:41 +02001424#endif
Max Filippov246ae242014-11-02 11:04:18 +03001425
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001426static void hmp_info_history(Monitor *mon, const QDict *qdict)
bellardaa455482004-04-04 13:07:25 +00001427{
1428 int i;
bellard7e2515e2004-08-01 21:52:19 +00001429 const char *str;
ths3b46e622007-09-17 08:09:54 +00001430
aliguoricde76ee2009-03-05 23:01:51 +00001431 if (!mon->rs)
1432 return;
bellard7e2515e2004-08-01 21:52:19 +00001433 i = 0;
1434 for(;;) {
aliguori731b0362009-03-05 23:01:42 +00001435 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +00001436 if (!str)
1437 break;
aliguori376253e2009-03-05 23:01:23 +00001438 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +00001439 i++;
bellardaa455482004-04-04 13:07:25 +00001440 }
1441}
1442
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001443static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
j_mayer76a66252007-03-07 08:32:30 +00001444{
Thomas Huth854e67f2017-01-13 13:12:35 +01001445 CPUState *cs = mon_get_cpu();
1446
1447 if (!cs) {
1448 monitor_printf(mon, "No CPU available\n");
1449 return;
1450 }
1451 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +00001452}
j_mayer76a66252007-03-07 08:32:30 +00001453
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001454static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +05301455{
Lluís Vilanovabd712112016-07-11 12:53:51 +02001456 const char *name = qdict_get_try_str(qdict, "name");
Lluís Vilanova77e2b172016-07-11 12:53:57 +02001457 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1458 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
Lluís Vilanovabd712112016-07-11 12:53:51 +02001459 TraceEventInfoList *events;
Lluís Vilanova14101d02014-08-25 13:20:03 +02001460 TraceEventInfoList *elem;
Lluís Vilanovabd712112016-07-11 12:53:51 +02001461 Error *local_err = NULL;
1462
1463 if (name == NULL) {
1464 name = "*";
1465 }
Lluís Vilanova77e2b172016-07-11 12:53:57 +02001466 if (vcpu < 0) {
1467 monitor_printf(mon, "argument vcpu must be positive");
1468 return;
1469 }
Lluís Vilanovabd712112016-07-11 12:53:51 +02001470
Lluís Vilanova77e2b172016-07-11 12:53:57 +02001471 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
Lluís Vilanovabd712112016-07-11 12:53:51 +02001472 if (local_err) {
1473 error_report_err(local_err);
1474 return;
1475 }
Lluís Vilanova14101d02014-08-25 13:20:03 +02001476
1477 for (elem = events; elem != NULL; elem = elem->next) {
1478 monitor_printf(mon, "%s : state %u\n",
1479 elem->value->name,
1480 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1481 }
1482 qapi_free_TraceEventInfoList(events);
Prerna Saxena22890ab2010-06-24 17:04:53 +05301483}
Prerna Saxena22890ab2010-06-24 17:04:53 +05301484
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001485void qmp_client_migrate_info(const char *protocol, const char *hostname,
1486 bool has_port, int64_t port,
1487 bool has_tls_port, int64_t tls_port,
1488 bool has_cert_subject, const char *cert_subject,
1489 Error **errp)
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001490{
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001491 if (strcmp(protocol, "spice") == 0) {
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001492 if (!qemu_using_spice(errp)) {
1493 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001494 }
1495
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001496 if (!has_port && !has_tls_port) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001497 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001498 return;
Yonit Halperin6ec5dae2012-03-18 09:42:39 +02001499 }
1500
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001501 if (qemu_spice_migrate_info(hostname,
1502 has_port ? port : -1,
1503 has_tls_port ? tls_port : -1,
1504 cert_subject)) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001505 error_setg(errp, QERR_UNDEFINED_ERROR);
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001506 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001507 }
Markus Armbrusterb8a185b2015-03-05 17:29:02 +01001508 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001509 }
1510
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001511 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001512}
1513
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001514static void hmp_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001515{
Markus Armbrusterdaa76aa2016-06-15 19:27:16 +02001516 Error *err = NULL;
1517
1518 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1519 if (err) {
1520 error_report_err(err);
1521 }
pbrooke735b912007-06-30 13:53:24 +00001522}
1523
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001524static void hmp_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001525{
1526 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001527 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001528
bellard9307c4c2004-04-04 12:57:25 +00001529 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001530 mask = 0;
1531 } else {
Peter Maydell4fde1eb2013-02-11 16:41:22 +00001532 mask = qemu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001533 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001534 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001535 return;
1536 }
1537 }
Peter Maydell24537a02013-02-11 16:41:23 +00001538 qemu_set_log(mask);
bellardf193c792004-03-21 17:06:25 +00001539}
1540
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001541static void hmp_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001542{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001543 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001544 if (!option || !strcmp(option, "on")) {
1545 singlestep = 1;
1546 } else if (!strcmp(option, "off")) {
1547 singlestep = 0;
1548 } else {
1549 monitor_printf(mon, "unexpected option %s\n", option);
1550 }
1551}
1552
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001553static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001554{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001555 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001556 if (!device)
1557 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1558 if (gdbserver_start(device) < 0) {
1559 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1560 device);
1561 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001562 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001563 } else {
aliguori59030a82009-04-05 18:43:41 +00001564 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1565 device);
bellard8a7ddc32004-03-31 19:00:16 +00001566 }
1567}
1568
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001569static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001570{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001571 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001572 if (select_watchdog_action(action) == -1) {
1573 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1574 }
1575}
1576
aliguori376253e2009-03-05 23:01:23 +00001577static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001578{
aliguori376253e2009-03-05 23:01:23 +00001579 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001580 switch(c) {
1581 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001582 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001583 break;
1584 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001585 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001586 break;
1587 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001588 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001589 break;
1590 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001591 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001592 break;
1593 default:
1594 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001595 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001596 } else {
aliguori376253e2009-03-05 23:01:23 +00001597 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001598 }
1599 break;
1600 }
aliguori376253e2009-03-05 23:01:23 +00001601 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001602}
1603
aliguori376253e2009-03-05 23:01:23 +00001604static void memory_dump(Monitor *mon, int count, int format, int wsize,
Avi Kivitya8170e52012-10-23 12:30:10 +02001605 hwaddr addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001606{
Blue Swirl23842aa2010-01-12 20:27:43 +00001607 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001608 uint8_t buf[16];
1609 uint64_t v;
Thomas Huth854e67f2017-01-13 13:12:35 +01001610 CPUState *cs = mon_get_cpu();
1611
1612 if (!cs && (format == 'i' || !is_physical)) {
1613 monitor_printf(mon, "Can not dump without CPU\n");
1614 return;
1615 }
bellard9307c4c2004-04-04 12:57:25 +00001616
1617 if (format == 'i') {
Richard Henderson1d484742017-09-14 08:38:35 -07001618 monitor_disas(mon, cs, addr, count, is_physical);
bellard9307c4c2004-04-04 12:57:25 +00001619 return;
1620 }
1621
1622 len = wsize * count;
1623 if (wsize == 1)
1624 line_size = 8;
1625 else
1626 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001627 max_digits = 0;
1628
1629 switch(format) {
1630 case 'o':
Marc-André Lureau69db8df2017-06-22 13:04:16 +02001631 max_digits = DIV_ROUND_UP(wsize * 8, 3);
bellard9307c4c2004-04-04 12:57:25 +00001632 break;
1633 default:
1634 case 'x':
1635 max_digits = (wsize * 8) / 4;
1636 break;
1637 case 'u':
1638 case 'd':
Marc-André Lureau69db8df2017-06-22 13:04:16 +02001639 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
bellard9307c4c2004-04-04 12:57:25 +00001640 break;
1641 case 'c':
1642 wsize = 1;
1643 break;
1644 }
1645
1646 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001647 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001648 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001649 else
aliguori376253e2009-03-05 23:01:23 +00001650 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001651 l = len;
1652 if (l > line_size)
1653 l = line_size;
1654 if (is_physical) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001655 cpu_physical_memory_read(addr, buf, l);
bellard9307c4c2004-04-04 12:57:25 +00001656 } else {
Thomas Huth854e67f2017-01-13 13:12:35 +01001657 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001658 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001659 break;
1660 }
bellard9307c4c2004-04-04 12:57:25 +00001661 }
ths5fafdf22007-09-16 21:08:06 +00001662 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001663 while (i < l) {
1664 switch(wsize) {
1665 default:
1666 case 1:
Peter Maydell24e60302015-01-20 15:19:32 +00001667 v = ldub_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001668 break;
1669 case 2:
Peter Maydell24e60302015-01-20 15:19:32 +00001670 v = lduw_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001671 break;
1672 case 4:
Peter Maydell24e60302015-01-20 15:19:32 +00001673 v = (uint32_t)ldl_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001674 break;
1675 case 8:
Peter Maydell24e60302015-01-20 15:19:32 +00001676 v = ldq_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001677 break;
1678 }
aliguori376253e2009-03-05 23:01:23 +00001679 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001680 switch(format) {
1681 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001682 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001683 break;
1684 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001685 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001686 break;
1687 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001688 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001689 break;
1690 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001691 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001692 break;
1693 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001694 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001695 break;
1696 }
1697 i += wsize;
1698 }
aliguori376253e2009-03-05 23:01:23 +00001699 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001700 addr += l;
1701 len -= l;
1702 }
1703}
1704
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001705static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001706{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001707 int count = qdict_get_int(qdict, "count");
1708 int format = qdict_get_int(qdict, "format");
1709 int size = qdict_get_int(qdict, "size");
1710 target_long addr = qdict_get_int(qdict, "addr");
1711
aliguori376253e2009-03-05 23:01:23 +00001712 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001713}
1714
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001715static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001716{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001717 int count = qdict_get_int(qdict, "count");
1718 int format = qdict_get_int(qdict, "format");
1719 int size = qdict_get_int(qdict, "size");
Avi Kivitya8170e52012-10-23 12:30:10 +02001720 hwaddr addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001721
aliguori376253e2009-03-05 23:01:23 +00001722 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001723}
1724
Paolo Bonzinie9628442017-04-20 15:30:58 +02001725static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1726{
1727 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1728 addr, 1);
1729
1730 if (!mrs.mr) {
1731 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1732 return NULL;
1733 }
1734
1735 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1736 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1737 memory_region_unref(mrs.mr);
1738 return NULL;
1739 }
1740
1741 *p_mr = mrs.mr;
1742 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1743}
1744
1745static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1746{
1747 hwaddr addr = qdict_get_int(qdict, "addr");
1748 Error *local_err = NULL;
1749 MemoryRegion *mr = NULL;
1750 void *ptr;
1751
1752 ptr = gpa2hva(&mr, addr, &local_err);
1753 if (local_err) {
1754 error_report_err(local_err);
1755 return;
1756 }
1757
1758 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1759 " (%s) is %p\n",
1760 addr, mr->name, ptr);
1761
1762 memory_region_unref(mr);
1763}
1764
1765#ifdef CONFIG_LINUX
1766static uint64_t vtop(void *ptr, Error **errp)
1767{
1768 uint64_t pinfo;
1769 uint64_t ret = -1;
1770 uintptr_t addr = (uintptr_t) ptr;
1771 uintptr_t pagesize = getpagesize();
1772 off_t offset = addr / pagesize * sizeof(pinfo);
1773 int fd;
1774
1775 fd = open("/proc/self/pagemap", O_RDONLY);
1776 if (fd == -1) {
1777 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1778 return -1;
1779 }
1780
1781 /* Force copy-on-write if necessary. */
1782 atomic_add((uint8_t *)ptr, 0);
1783
1784 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1785 error_setg_errno(errp, errno, "Cannot read pagemap");
1786 goto out;
1787 }
1788 if ((pinfo & (1ull << 63)) == 0) {
1789 error_setg(errp, "Page not present");
1790 goto out;
1791 }
1792 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1793
1794out:
1795 close(fd);
1796 return ret;
1797}
1798
1799static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1800{
1801 hwaddr addr = qdict_get_int(qdict, "addr");
1802 Error *local_err = NULL;
1803 MemoryRegion *mr = NULL;
1804 void *ptr;
1805 uint64_t physaddr;
1806
1807 ptr = gpa2hva(&mr, addr, &local_err);
1808 if (local_err) {
1809 error_report_err(local_err);
1810 return;
1811 }
1812
1813 physaddr = vtop(ptr, &local_err);
1814 if (local_err) {
1815 error_report_err(local_err);
1816 } else {
1817 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1818 " (%s) is 0x%" PRIx64 "\n",
1819 addr, mr->name, (uint64_t) physaddr);
1820 }
1821
1822 memory_region_unref(mr);
1823}
1824#endif
1825
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001826static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001827{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001828 int format = qdict_get_int(qdict, "format");
Avi Kivitya8170e52012-10-23 12:30:10 +02001829 hwaddr val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001830
bellard9307c4c2004-04-04 12:57:25 +00001831 switch(format) {
1832 case 'o':
Avi Kivitya8170e52012-10-23 12:30:10 +02001833 monitor_printf(mon, "%#" HWADDR_PRIo, val);
bellard9307c4c2004-04-04 12:57:25 +00001834 break;
1835 case 'x':
Avi Kivitya8170e52012-10-23 12:30:10 +02001836 monitor_printf(mon, "%#" HWADDR_PRIx, val);
bellard9307c4c2004-04-04 12:57:25 +00001837 break;
1838 case 'u':
Avi Kivitya8170e52012-10-23 12:30:10 +02001839 monitor_printf(mon, "%" HWADDR_PRIu, val);
bellard9307c4c2004-04-04 12:57:25 +00001840 break;
1841 default:
1842 case 'd':
Avi Kivitya8170e52012-10-23 12:30:10 +02001843 monitor_printf(mon, "%" HWADDR_PRId, val);
bellard9307c4c2004-04-04 12:57:25 +00001844 break;
1845 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001846 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001847 break;
1848 }
aliguori376253e2009-03-05 23:01:23 +00001849 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001850}
1851
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001852static void hmp_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001853{
1854 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +00001855 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001856 uint32_t start = qdict_get_int(qdict, "start");
1857 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001858
1859 sum = 0;
1860 for(addr = start; addr < (start + size); addr++) {
Peter Maydell42874d32015-04-26 16:49:24 +01001861 uint8_t val = address_space_ldub(&address_space_memory, addr,
1862 MEMTXATTRS_UNSPECIFIED, NULL);
bellarde4cf1ad2005-06-04 20:15:57 +00001863 /* BSD sum algorithm ('sum' Unix command) */
1864 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001865 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +00001866 }
aliguori376253e2009-03-05 23:01:23 +00001867 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001868}
1869
bellard13224a82006-07-14 22:03:35 +00001870static int mouse_button_state;
1871
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001872static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001873{
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001874 int dx, dy, dz, button;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001875 const char *dx_str = qdict_get_str(qdict, "dx_str");
1876 const char *dy_str = qdict_get_str(qdict, "dy_str");
1877 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001878
bellard13224a82006-07-14 22:03:35 +00001879 dx = strtol(dx_str, NULL, 0);
1880 dy = strtol(dy_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001881 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1882 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1883
1884 if (dz_str) {
bellard13224a82006-07-14 22:03:35 +00001885 dz = strtol(dz_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001886 if (dz != 0) {
Gerd Hoffmannf22d0af2016-01-12 12:14:12 +01001887 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001888 qemu_input_queue_btn(NULL, button, true);
1889 qemu_input_event_sync();
1890 qemu_input_queue_btn(NULL, button, false);
1891 }
1892 }
1893 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +00001894}
1895
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001896static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001897{
Eric Blake7fb1cf12015-11-18 01:52:57 -07001898 static uint32_t bmap[INPUT_BUTTON__MAX] = {
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001899 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1900 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1901 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1902 };
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001903 int button_state = qdict_get_int(qdict, "button_state");
Gerd Hoffmannc751a742013-12-04 15:02:28 +01001904
1905 if (mouse_button_state == button_state) {
1906 return;
1907 }
1908 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1909 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +00001910 mouse_button_state = button_state;
bellard13224a82006-07-14 22:03:35 +00001911}
1912
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001913static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001914{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001915 int size = qdict_get_int(qdict, "size");
1916 int addr = qdict_get_int(qdict, "addr");
1917 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001918 uint32_t val;
1919 int suffix;
1920
1921 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001922 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001923 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001924 addr++;
1925 }
1926 addr &= 0xffff;
1927
1928 switch(size) {
1929 default:
1930 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001931 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001932 suffix = 'b';
1933 break;
1934 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001935 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001936 suffix = 'w';
1937 break;
1938 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001939 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001940 suffix = 'l';
1941 break;
1942 }
aliguori376253e2009-03-05 23:01:23 +00001943 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1944 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001945}
bellarda3a91a32004-06-04 11:06:21 +00001946
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001947static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001948{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001949 int size = qdict_get_int(qdict, "size");
1950 int addr = qdict_get_int(qdict, "addr");
1951 int val = qdict_get_int(qdict, "val");
1952
Jan Kiszkaf1147842009-07-14 10:20:11 +02001953 addr &= IOPORTS_MASK;
1954
1955 switch (size) {
1956 default:
1957 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001958 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001959 break;
1960 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001961 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001962 break;
1963 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001964 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001965 break;
1966 }
1967}
1968
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01001969static void hmp_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001970{
Gongleif1839932014-12-03 18:20:58 +00001971 Error *local_err = NULL;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001972 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001973
Gongleif1839932014-12-03 18:20:58 +00001974 qemu_boot_set(bootdevice, &local_err);
1975 if (local_err) {
Markus Armbruster193227f2015-12-18 16:35:06 +01001976 error_report_err(local_err);
aurel320ecdffb2008-05-04 20:11:34 +00001977 } else {
Gongleif1839932014-12-03 18:20:58 +00001978 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
aurel320ecdffb2008-05-04 20:11:34 +00001979 }
1980}
1981
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001982static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
Blue Swirl314e2982011-09-11 20:22:05 +00001983{
Peter Xu57bb40c2017-01-16 16:40:05 +08001984 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
Alexey Kardashevskiy5e8fd942017-09-21 18:51:06 +10001985 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
Alexey Kardashevskiyfc051ae2018-06-04 13:25:11 +10001986 bool owner = qdict_get_try_bool(qdict, "owner", false);
Peter Xu57bb40c2017-01-16 16:40:05 +08001987
Alexey Kardashevskiyfc051ae2018-06-04 13:25:11 +10001988 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree,
1989 owner);
Blue Swirl314e2982011-09-11 20:22:05 +00001990}
1991
Markus Armbruster1ce6be22015-02-06 14:18:24 +01001992static void hmp_info_numa(Monitor *mon, const QDict *qdict)
aliguori030ea372009-04-21 22:30:47 +00001993{
aliguorib28b6232009-04-22 20:20:29 +00001994 int i;
Vadim Galitsyn31959e82017-08-29 17:30:20 +02001995 NumaNodeMem *node_mem;
Igor Mammedovf75cd442017-05-30 18:23:59 +02001996 CpuInfoList *cpu_list, *cpu;
aliguori030ea372009-04-21 22:30:47 +00001997
Igor Mammedovf75cd442017-05-30 18:23:59 +02001998 cpu_list = qmp_query_cpus(&error_abort);
Vadim Galitsyn31959e82017-08-29 17:30:20 +02001999 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
2000
zhanghailiang5b009e42014-11-04 19:49:30 +08002001 query_numa_node_mem(node_mem);
aliguori030ea372009-04-21 22:30:47 +00002002 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2003 for (i = 0; i < nb_numa_nodes; i++) {
2004 monitor_printf(mon, "node %d cpus:", i);
Igor Mammedovf75cd442017-05-30 18:23:59 +02002005 for (cpu = cpu_list; cpu; cpu = cpu->next) {
2006 if (cpu->value->has_props && cpu->value->props->has_node_id &&
2007 cpu->value->props->node_id == i) {
2008 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
aliguori030ea372009-04-21 22:30:47 +00002009 }
2010 }
2011 monitor_printf(mon, "\n");
2012 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
Vadim Galitsyn31959e82017-08-29 17:30:20 +02002013 node_mem[i].node_mem >> 20);
2014 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
2015 node_mem[i].node_plugged_mem >> 20);
aliguori030ea372009-04-21 22:30:47 +00002016 }
Igor Mammedovf75cd442017-05-30 18:23:59 +02002017 qapi_free_CpuInfoList(cpu_list);
zhanghailiang5b009e42014-11-04 19:49:30 +08002018 g_free(node_mem);
aliguori030ea372009-04-21 22:30:47 +00002019}
2020
bellard5f1ce942006-02-08 22:40:15 +00002021#ifdef CONFIG_PROFILER
2022
Alexey Kardashevskiy89d5cbd2015-03-16 14:57:38 +11002023int64_t tcg_time;
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002024int64_t dev_time;
2025
Markus Armbruster1ce6be22015-02-06 14:18:24 +01002026static void hmp_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002027{
aliguori376253e2009-03-05 23:01:23 +00002028 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Rutuja Shah73bcb242016-03-21 21:32:30 +05302029 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
aliguori376253e2009-03-05 23:01:23 +00002030 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Rutuja Shah73bcb242016-03-21 21:32:30 +05302031 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
Alexey Kardashevskiy89d5cbd2015-03-16 14:57:38 +11002032 tcg_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002033 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002034}
2035#else
Markus Armbruster1ce6be22015-02-06 14:18:24 +01002036static void hmp_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002037{
aliguori376253e2009-03-05 23:01:23 +00002038 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002039}
2040#endif
2041
bellardec36b692006-07-16 18:57:03 +00002042/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002043static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002044
Markus Armbruster1ce6be22015-02-06 14:18:24 +01002045static void hmp_info_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002046{
2047 int i;
2048 CaptureState *s;
2049
2050 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002051 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002052 s->ops.info (s->opaque);
2053 }
2054}
2055
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002056static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002057{
2058 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002059 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002060 CaptureState *s;
2061
2062 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2063 if (i == n) {
2064 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002065 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -05002066 g_free (s);
bellardec36b692006-07-16 18:57:03 +00002067 return;
2068 }
2069 }
2070}
2071
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002072static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002073{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002074 const char *path = qdict_get_str(qdict, "path");
2075 int has_freq = qdict_haskey(qdict, "freq");
2076 int freq = qdict_get_try_int(qdict, "freq", -1);
2077 int has_bits = qdict_haskey(qdict, "bits");
2078 int bits = qdict_get_try_int(qdict, "bits", -1);
2079 int has_channels = qdict_haskey(qdict, "nchannels");
2080 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002081 CaptureState *s;
2082
Anthony Liguori7267c092011-08-20 22:09:37 -05002083 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002084
2085 freq = has_freq ? freq : 44100;
2086 bits = has_bits ? bits : 16;
2087 nchannels = has_channels ? nchannels : 2;
2088
2089 if (wav_start_capture (s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002090 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05002091 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002092 return;
bellardec36b692006-07-16 18:57:03 +00002093 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002094 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002095}
bellardec36b692006-07-16 18:57:03 +00002096
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002097static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002098{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002099 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002100
aliguori76655d62009-03-06 20:27:37 +00002101 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002102 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002103 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002104 return acl;
2105}
aliguori76655d62009-03-06 20:27:37 +00002106
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002107static void hmp_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002108{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002109 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002110 qemu_acl *acl = find_acl(mon, aclname);
2111 qemu_acl_entry *entry;
2112 int i = 0;
2113
2114 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002115 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002116 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002117 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002118 i++;
2119 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002120 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002121 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002122 }
2123}
2124
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002125static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002126{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002127 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002128 qemu_acl *acl = find_acl(mon, aclname);
2129
2130 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002131 qemu_acl_reset(acl);
2132 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002133 }
2134}
aliguori76655d62009-03-06 20:27:37 +00002135
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002136static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002137{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002138 const char *aclname = qdict_get_str(qdict, "aclname");
2139 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002140 qemu_acl *acl = find_acl(mon, aclname);
2141
2142 if (acl) {
2143 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002144 acl->defaultDeny = 0;
2145 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002146 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002147 acl->defaultDeny = 1;
2148 monitor_printf(mon, "acl: policy set to 'deny'\n");
2149 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002150 monitor_printf(mon, "acl: unknown policy '%s', "
2151 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002152 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002153 }
2154}
aliguori76655d62009-03-06 20:27:37 +00002155
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002156static void hmp_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002157{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002158 const char *aclname = qdict_get_str(qdict, "aclname");
2159 const char *match = qdict_get_str(qdict, "match");
2160 const char *policy = qdict_get_str(qdict, "policy");
2161 int has_index = qdict_haskey(qdict, "index");
2162 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002163 qemu_acl *acl = find_acl(mon, aclname);
2164 int deny, ret;
2165
2166 if (acl) {
2167 if (strcmp(policy, "allow") == 0) {
2168 deny = 0;
2169 } else if (strcmp(policy, "deny") == 0) {
2170 deny = 1;
2171 } else {
2172 monitor_printf(mon, "acl: unknown policy '%s', "
2173 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002174 return;
2175 }
aliguori28a76be2009-03-06 20:27:40 +00002176 if (has_index)
2177 ret = qemu_acl_insert(acl, deny, match, index);
2178 else
2179 ret = qemu_acl_append(acl, deny, match);
2180 if (ret < 0)
2181 monitor_printf(mon, "acl: unable to add acl entry\n");
2182 else
2183 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002184 }
2185}
aliguori76655d62009-03-06 20:27:37 +00002186
Markus Armbruster3e5a50d2015-02-06 13:55:43 +01002187static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002188{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002189 const char *aclname = qdict_get_str(qdict, "aclname");
2190 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002191 qemu_acl *acl = find_acl(mon, aclname);
2192 int ret;
aliguori76655d62009-03-06 20:27:37 +00002193
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002194 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002195 ret = qemu_acl_remove(acl, match);
2196 if (ret < 0)
2197 monitor_printf(mon, "acl: no matching acl entry\n");
2198 else
2199 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002200 }
2201}
2202
Corey Bryant208c9d12012-06-22 14:36:09 -04002203void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002204{
Anthony Liguoric227f092009-10-01 16:12:16 -05002205 mon_fd_t *monfd;
Peter Xu9409fc02018-06-08 11:55:06 +08002206 int fd, tmp_fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002207
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03002208 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002209 if (fd == -1) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002210 error_setg(errp, QERR_FD_NOT_SUPPLIED);
Corey Bryant208c9d12012-06-22 14:36:09 -04002211 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002212 }
2213
2214 if (qemu_isdigit(fdname[0])) {
Stefan Hajnoczi0b9f0e22014-04-24 13:58:18 +02002215 close(fd);
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002216 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2217 "a name not starting with a digit");
Corey Bryant208c9d12012-06-22 14:36:09 -04002218 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002219 }
2220
Peter Xu9409fc02018-06-08 11:55:06 +08002221 qemu_mutex_lock(&cur_mon->mon_lock);
Corey Bryant208c9d12012-06-22 14:36:09 -04002222 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002223 if (strcmp(monfd->name, fdname) != 0) {
2224 continue;
2225 }
2226
Peter Xu9409fc02018-06-08 11:55:06 +08002227 tmp_fd = monfd->fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002228 monfd->fd = fd;
Peter Xu9409fc02018-06-08 11:55:06 +08002229 qemu_mutex_unlock(&cur_mon->mon_lock);
2230 /* Make sure close() is out of critical section */
2231 close(tmp_fd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002232 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002233 }
2234
Anthony Liguori7267c092011-08-20 22:09:37 -05002235 monfd = g_malloc0(sizeof(mon_fd_t));
2236 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002237 monfd->fd = fd;
2238
Corey Bryant208c9d12012-06-22 14:36:09 -04002239 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Peter Xu9409fc02018-06-08 11:55:06 +08002240 qemu_mutex_unlock(&cur_mon->mon_lock);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002241}
2242
Corey Bryant208c9d12012-06-22 14:36:09 -04002243void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002244{
Anthony Liguoric227f092009-10-01 16:12:16 -05002245 mon_fd_t *monfd;
Peter Xu9409fc02018-06-08 11:55:06 +08002246 int tmp_fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002247
Peter Xu9409fc02018-06-08 11:55:06 +08002248 qemu_mutex_lock(&cur_mon->mon_lock);
Corey Bryant208c9d12012-06-22 14:36:09 -04002249 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002250 if (strcmp(monfd->name, fdname) != 0) {
2251 continue;
2252 }
2253
Blue Swirl72cf2d42009-09-12 07:36:22 +00002254 QLIST_REMOVE(monfd, next);
Peter Xu9409fc02018-06-08 11:55:06 +08002255 tmp_fd = monfd->fd;
Anthony Liguori7267c092011-08-20 22:09:37 -05002256 g_free(monfd->name);
2257 g_free(monfd);
Peter Xu9409fc02018-06-08 11:55:06 +08002258 qemu_mutex_unlock(&cur_mon->mon_lock);
2259 /* Make sure close() is out of critical section */
2260 close(tmp_fd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002261 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002262 }
2263
Peter Xu9409fc02018-06-08 11:55:06 +08002264 qemu_mutex_unlock(&cur_mon->mon_lock);
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002265 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002266}
2267
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002268int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01002269{
Anthony Liguoric227f092009-10-01 16:12:16 -05002270 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002271
Peter Xu9409fc02018-06-08 11:55:06 +08002272 qemu_mutex_lock(&mon->mon_lock);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002273 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002274 int fd;
2275
2276 if (strcmp(monfd->name, fdname) != 0) {
2277 continue;
2278 }
2279
2280 fd = monfd->fd;
2281
2282 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002283 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05002284 g_free(monfd->name);
2285 g_free(monfd);
Peter Xu9409fc02018-06-08 11:55:06 +08002286 qemu_mutex_unlock(&mon->mon_lock);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002287
2288 return fd;
2289 }
2290
Peter Xu9409fc02018-06-08 11:55:06 +08002291 qemu_mutex_unlock(&mon->mon_lock);
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002292 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002293 return -1;
2294}
2295
Corey Bryantba1c0482012-08-14 16:43:43 -04002296static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2297{
2298 MonFdsetFd *mon_fdset_fd;
2299 MonFdsetFd *mon_fdset_fd_next;
2300
2301 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantebe52b52012-10-18 15:19:33 -04002302 if ((mon_fdset_fd->removed ||
2303 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2304 runstate_is_running()) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002305 close(mon_fdset_fd->fd);
2306 g_free(mon_fdset_fd->opaque);
2307 QLIST_REMOVE(mon_fdset_fd, next);
2308 g_free(mon_fdset_fd);
2309 }
2310 }
2311
Corey Bryantadb696f2012-08-14 16:43:47 -04002312 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002313 QLIST_REMOVE(mon_fdset, next);
2314 g_free(mon_fdset);
2315 }
2316}
2317
Corey Bryantefb87c12012-08-14 16:43:48 -04002318static void monitor_fdsets_cleanup(void)
2319{
2320 MonFdset *mon_fdset;
2321 MonFdset *mon_fdset_next;
2322
Peter Xu47451462018-06-08 11:55:11 +08002323 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantefb87c12012-08-14 16:43:48 -04002324 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2325 monitor_fdset_cleanup(mon_fdset);
2326 }
Peter Xu47451462018-06-08 11:55:11 +08002327 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantefb87c12012-08-14 16:43:48 -04002328}
2329
Corey Bryantba1c0482012-08-14 16:43:43 -04002330AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2331 const char *opaque, Error **errp)
2332{
2333 int fd;
2334 Monitor *mon = cur_mon;
Corey Bryantba1c0482012-08-14 16:43:43 -04002335 AddfdInfo *fdinfo;
2336
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03002337 fd = qemu_chr_fe_get_msgfd(&mon->chr);
Corey Bryantba1c0482012-08-14 16:43:43 -04002338 if (fd == -1) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002339 error_setg(errp, QERR_FD_NOT_SUPPLIED);
Corey Bryantba1c0482012-08-14 16:43:43 -04002340 goto error;
2341 }
2342
Corey Bryante446f702012-10-18 15:19:32 -04002343 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2344 has_opaque, opaque, errp);
2345 if (fdinfo) {
2346 return fdinfo;
Corey Bryant9ac54af2012-10-18 15:19:31 -04002347 }
2348
Corey Bryantba1c0482012-08-14 16:43:43 -04002349error:
2350 if (fd != -1) {
2351 close(fd);
2352 }
2353 return NULL;
2354}
2355
2356void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2357{
2358 MonFdset *mon_fdset;
2359 MonFdsetFd *mon_fdset_fd;
2360 char fd_str[60];
2361
Peter Xu47451462018-06-08 11:55:11 +08002362 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04002363 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2364 if (mon_fdset->id != fdset_id) {
2365 continue;
2366 }
2367 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2368 if (has_fd) {
2369 if (mon_fdset_fd->fd != fd) {
2370 continue;
2371 }
2372 mon_fdset_fd->removed = true;
2373 break;
2374 } else {
2375 mon_fdset_fd->removed = true;
2376 }
2377 }
2378 if (has_fd && !mon_fdset_fd) {
2379 goto error;
2380 }
2381 monitor_fdset_cleanup(mon_fdset);
Peter Xu47451462018-06-08 11:55:11 +08002382 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04002383 return;
2384 }
2385
2386error:
Peter Xu47451462018-06-08 11:55:11 +08002387 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04002388 if (has_fd) {
2389 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2390 fdset_id, fd);
2391 } else {
2392 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2393 }
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002394 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
Corey Bryantba1c0482012-08-14 16:43:43 -04002395}
2396
2397FdsetInfoList *qmp_query_fdsets(Error **errp)
2398{
2399 MonFdset *mon_fdset;
2400 MonFdsetFd *mon_fdset_fd;
2401 FdsetInfoList *fdset_list = NULL;
2402
Peter Xu47451462018-06-08 11:55:11 +08002403 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04002404 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2405 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2406 FdsetFdInfoList *fdsetfd_list = NULL;
2407
2408 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2409 fdset_info->value->fdset_id = mon_fdset->id;
2410
2411 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2412 FdsetFdInfoList *fdsetfd_info;
2413
2414 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2415 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2416 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2417 if (mon_fdset_fd->opaque) {
2418 fdsetfd_info->value->has_opaque = true;
2419 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2420 } else {
2421 fdsetfd_info->value->has_opaque = false;
2422 }
2423
2424 fdsetfd_info->next = fdsetfd_list;
2425 fdsetfd_list = fdsetfd_info;
2426 }
2427
2428 fdset_info->value->fds = fdsetfd_list;
2429
2430 fdset_info->next = fdset_list;
2431 fdset_list = fdset_info;
2432 }
Peter Xu47451462018-06-08 11:55:11 +08002433 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04002434
2435 return fdset_list;
2436}
2437
Corey Bryante446f702012-10-18 15:19:32 -04002438AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2439 bool has_opaque, const char *opaque,
2440 Error **errp)
2441{
2442 MonFdset *mon_fdset = NULL;
2443 MonFdsetFd *mon_fdset_fd;
2444 AddfdInfo *fdinfo;
2445
Peter Xu47451462018-06-08 11:55:11 +08002446 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryante446f702012-10-18 15:19:32 -04002447 if (has_fdset_id) {
2448 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2449 /* Break if match found or match impossible due to ordering by ID */
2450 if (fdset_id <= mon_fdset->id) {
2451 if (fdset_id < mon_fdset->id) {
2452 mon_fdset = NULL;
2453 }
2454 break;
2455 }
2456 }
2457 }
2458
2459 if (mon_fdset == NULL) {
2460 int64_t fdset_id_prev = -1;
2461 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2462
2463 if (has_fdset_id) {
2464 if (fdset_id < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01002465 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2466 "a non-negative value");
Peter Xu47451462018-06-08 11:55:11 +08002467 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryante446f702012-10-18 15:19:32 -04002468 return NULL;
2469 }
2470 /* Use specified fdset ID */
2471 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2472 mon_fdset_cur = mon_fdset;
2473 if (fdset_id < mon_fdset_cur->id) {
2474 break;
2475 }
2476 }
2477 } else {
2478 /* Use first available fdset ID */
2479 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2480 mon_fdset_cur = mon_fdset;
2481 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2482 fdset_id_prev = mon_fdset_cur->id;
2483 continue;
2484 }
2485 break;
2486 }
2487 }
2488
2489 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2490 if (has_fdset_id) {
2491 mon_fdset->id = fdset_id;
2492 } else {
2493 mon_fdset->id = fdset_id_prev + 1;
2494 }
2495
2496 /* The fdset list is ordered by fdset ID */
2497 if (!mon_fdset_cur) {
2498 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2499 } else if (mon_fdset->id < mon_fdset_cur->id) {
2500 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2501 } else {
2502 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2503 }
2504 }
2505
2506 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2507 mon_fdset_fd->fd = fd;
2508 mon_fdset_fd->removed = false;
2509 if (has_opaque) {
2510 mon_fdset_fd->opaque = g_strdup(opaque);
2511 }
2512 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2513
2514 fdinfo = g_malloc0(sizeof(*fdinfo));
2515 fdinfo->fdset_id = mon_fdset->id;
2516 fdinfo->fd = mon_fdset_fd->fd;
2517
Peter Xu47451462018-06-08 11:55:11 +08002518 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryante446f702012-10-18 15:19:32 -04002519 return fdinfo;
2520}
2521
Corey Bryantadb696f2012-08-14 16:43:47 -04002522int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2523{
Peter Xu47451462018-06-08 11:55:11 +08002524#ifdef _WIN32
2525 return -ENOENT;
2526#else
Corey Bryantadb696f2012-08-14 16:43:47 -04002527 MonFdset *mon_fdset;
2528 MonFdsetFd *mon_fdset_fd;
2529 int mon_fd_flags;
Peter Xu47451462018-06-08 11:55:11 +08002530 int ret;
Corey Bryantadb696f2012-08-14 16:43:47 -04002531
Peter Xu47451462018-06-08 11:55:11 +08002532 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002533 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2534 if (mon_fdset->id != fdset_id) {
2535 continue;
2536 }
2537 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2538 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2539 if (mon_fd_flags == -1) {
Peter Xu47451462018-06-08 11:55:11 +08002540 ret = -errno;
2541 goto out;
Corey Bryantadb696f2012-08-14 16:43:47 -04002542 }
2543
2544 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
Peter Xu47451462018-06-08 11:55:11 +08002545 ret = mon_fdset_fd->fd;
2546 goto out;
Corey Bryantadb696f2012-08-14 16:43:47 -04002547 }
2548 }
Peter Xu47451462018-06-08 11:55:11 +08002549 ret = -EACCES;
2550 goto out;
Corey Bryantadb696f2012-08-14 16:43:47 -04002551 }
Peter Xu47451462018-06-08 11:55:11 +08002552 ret = -ENOENT;
Corey Bryantadb696f2012-08-14 16:43:47 -04002553
Peter Xu47451462018-06-08 11:55:11 +08002554out:
2555 qemu_mutex_unlock(&mon_fdsets_lock);
2556 return ret;
2557#endif
Corey Bryantadb696f2012-08-14 16:43:47 -04002558}
2559
2560int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2561{
2562 MonFdset *mon_fdset;
2563 MonFdsetFd *mon_fdset_fd_dup;
2564
Peter Xu47451462018-06-08 11:55:11 +08002565 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002566 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2567 if (mon_fdset->id != fdset_id) {
2568 continue;
2569 }
2570 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2571 if (mon_fdset_fd_dup->fd == dup_fd) {
Peter Xu47451462018-06-08 11:55:11 +08002572 goto err;
Corey Bryantadb696f2012-08-14 16:43:47 -04002573 }
2574 }
2575 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2576 mon_fdset_fd_dup->fd = dup_fd;
2577 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
Peter Xu47451462018-06-08 11:55:11 +08002578 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002579 return 0;
2580 }
Peter Xu47451462018-06-08 11:55:11 +08002581
2582err:
2583 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002584 return -1;
2585}
2586
2587static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2588{
2589 MonFdset *mon_fdset;
2590 MonFdsetFd *mon_fdset_fd_dup;
2591
Peter Xu47451462018-06-08 11:55:11 +08002592 qemu_mutex_lock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002593 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2594 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2595 if (mon_fdset_fd_dup->fd == dup_fd) {
2596 if (remove) {
2597 QLIST_REMOVE(mon_fdset_fd_dup, next);
2598 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2599 monitor_fdset_cleanup(mon_fdset);
2600 }
Peter Xu47451462018-06-08 11:55:11 +08002601 goto err;
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02002602 } else {
Peter Xu47451462018-06-08 11:55:11 +08002603 qemu_mutex_unlock(&mon_fdsets_lock);
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02002604 return mon_fdset->id;
Corey Bryantadb696f2012-08-14 16:43:47 -04002605 }
Corey Bryantadb696f2012-08-14 16:43:47 -04002606 }
2607 }
2608 }
Peter Xu47451462018-06-08 11:55:11 +08002609
2610err:
2611 qemu_mutex_unlock(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04002612 return -1;
2613}
2614
2615int monitor_fdset_dup_fd_find(int dup_fd)
2616{
2617 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2618}
2619
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02002620void monitor_fdset_dup_fd_remove(int dup_fd)
Corey Bryantadb696f2012-08-14 16:43:47 -04002621{
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02002622 monitor_fdset_dup_fd_find_remove(dup_fd, true);
Corey Bryantadb696f2012-08-14 16:43:47 -04002623}
2624
Markus Armbruster1677f4c2015-02-09 14:03:19 +01002625int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
Laszlo Ersek59063662014-04-10 10:24:31 +02002626{
2627 int fd;
2628 Error *local_err = NULL;
2629
2630 if (!qemu_isdigit(fdname[0]) && mon) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002631 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002632 } else {
2633 fd = qemu_parse_fd(fdname);
Laszlo Ersek59063662014-04-10 10:24:31 +02002634 if (fd == -1) {
2635 error_setg(&local_err, "Invalid file descriptor number '%s'",
2636 fdname);
2637 }
2638 }
2639 if (local_err) {
2640 error_propagate(errp, local_err);
2641 assert(fd == -1);
2642 } else {
2643 assert(fd != -1);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002644 }
2645
2646 return fd;
2647}
2648
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002649/* Please update hmp-commands.hx when adding or changing commands */
Wayne Xia816f8922011-10-12 11:32:41 +08002650static mon_cmd_t info_cmds[] = {
Pavel Butsykinda76ee72015-09-10 18:38:58 +03002651#include "hmp-commands-info.h"
2652 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00002653};
2654
Wenchao Xiaa13ced52013-01-14 14:06:28 +08002655/* mon_cmds and info_cmds would be sorted at runtime */
2656static mon_cmd_t mon_cmds[] = {
2657#include "hmp-commands.h"
2658 { NULL, NULL, },
2659};
2660
bellard9307c4c2004-04-04 12:57:25 +00002661/*******************************************************************/
2662
2663static const char *pch;
Peter Maydell6ab7e542013-02-20 15:21:09 +00002664static sigjmp_buf expr_env;
bellard9307c4c2004-04-04 12:57:25 +00002665
bellard9307c4c2004-04-04 12:57:25 +00002666
Stefan Weil9c3175c2013-08-22 21:30:09 +02002667static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2668expr_error(Monitor *mon, const char *fmt, ...)
bellard9dc39cb2004-03-14 21:38:27 +00002669{
Fam Zheng277acfe2013-08-20 10:58:21 +08002670 va_list ap;
2671 va_start(ap, fmt);
2672 monitor_vprintf(mon, fmt, ap);
2673 monitor_printf(mon, "\n");
2674 va_end(ap);
Peter Maydell6ab7e542013-02-20 15:21:09 +00002675 siglongjmp(expr_env, 1);
bellard9307c4c2004-04-04 12:57:25 +00002676}
2677
Markus Armbruster09b94182010-01-20 13:07:30 +01002678/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00002679static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00002680{
Pavel Butsykinbf957282015-09-10 18:38:59 +03002681 const MonitorDef *md = target_monitor_defs();
Thomas Huth854e67f2017-01-13 13:12:35 +01002682 CPUState *cs = mon_get_cpu();
bellard92a31b12005-02-10 22:00:52 +00002683 void *ptr;
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11002684 uint64_t tmp = 0;
2685 int ret;
bellard92a31b12005-02-10 22:00:52 +00002686
Thomas Huth854e67f2017-01-13 13:12:35 +01002687 if (cs == NULL || md == NULL) {
Pavel Butsykinbf957282015-09-10 18:38:59 +03002688 return -1;
2689 }
2690
2691 for(; md->name != NULL; md++) {
bellard9307c4c2004-04-04 12:57:25 +00002692 if (compare_cmd(name, md->name)) {
2693 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00002694 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00002695 } else {
Peter Crosthwaite5bcda5f2015-05-24 14:20:40 -07002696 CPUArchState *env = mon_get_cpu_env();
bellard6a00d602005-11-21 23:25:50 +00002697 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00002698 switch(md->type) {
2699 case MD_I32:
2700 *pval = *(int32_t *)ptr;
2701 break;
2702 case MD_TLONG:
2703 *pval = *(target_long *)ptr;
2704 break;
2705 default:
2706 *pval = 0;
2707 break;
2708 }
bellard9307c4c2004-04-04 12:57:25 +00002709 }
2710 return 0;
2711 }
2712 }
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11002713
Thomas Huth854e67f2017-01-13 13:12:35 +01002714 ret = target_get_monitor_def(cs, name, &tmp);
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11002715 if (!ret) {
2716 *pval = (target_long) tmp;
2717 }
2718
2719 return ret;
bellard9307c4c2004-04-04 12:57:25 +00002720}
2721
2722static void next(void)
2723{
Blue Swirl660f11b2009-07-31 21:16:51 +00002724 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00002725 pch++;
blueswir1cd390082008-11-16 13:53:32 +00002726 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00002727 pch++;
2728 }
2729}
2730
aliguori376253e2009-03-05 23:01:23 +00002731static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00002732
aliguori376253e2009-03-05 23:01:23 +00002733static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00002734{
blueswir1c2efc952007-09-25 17:28:42 +00002735 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00002736 char *p;
bellard6a00d602005-11-21 23:25:50 +00002737 int ret;
bellard9307c4c2004-04-04 12:57:25 +00002738
2739 switch(*pch) {
2740 case '+':
2741 next();
aliguori376253e2009-03-05 23:01:23 +00002742 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00002743 break;
2744 case '-':
2745 next();
aliguori376253e2009-03-05 23:01:23 +00002746 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00002747 break;
2748 case '~':
2749 next();
aliguori376253e2009-03-05 23:01:23 +00002750 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00002751 break;
2752 case '(':
2753 next();
aliguori376253e2009-03-05 23:01:23 +00002754 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00002755 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00002756 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00002757 }
2758 next();
2759 break;
bellard81d09122004-07-14 17:21:37 +00002760 case '\'':
2761 pch++;
2762 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00002763 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00002764 n = *pch;
2765 pch++;
2766 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00002767 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00002768 next();
2769 break;
bellard9307c4c2004-04-04 12:57:25 +00002770 case '$':
2771 {
2772 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00002773 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00002774
bellard9307c4c2004-04-04 12:57:25 +00002775 pch++;
2776 q = buf;
2777 while ((*pch >= 'a' && *pch <= 'z') ||
2778 (*pch >= 'A' && *pch <= 'Z') ||
2779 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00002780 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00002781 if ((q - buf) < sizeof(buf) - 1)
2782 *q++ = *pch;
2783 pch++;
2784 }
blueswir1cd390082008-11-16 13:53:32 +00002785 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00002786 pch++;
2787 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00002788 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01002789 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00002790 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00002791 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00002792 }
2793 break;
2794 case '\0':
aliguori376253e2009-03-05 23:01:23 +00002795 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00002796 n = 0;
2797 break;
2798 default:
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03002799 errno = 0;
bellard4f4fbf72006-06-25 18:28:12 +00002800 n = strtoull(pch, &p, 0);
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03002801 if (errno == ERANGE) {
2802 expr_error(mon, "number too large");
2803 }
bellard9307c4c2004-04-04 12:57:25 +00002804 if (pch == p) {
Fam Zheng277acfe2013-08-20 10:58:21 +08002805 expr_error(mon, "invalid char '%c' in expression", *p);
bellard9307c4c2004-04-04 12:57:25 +00002806 }
2807 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00002808 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00002809 pch++;
2810 break;
2811 }
2812 return n;
2813}
2814
2815
aliguori376253e2009-03-05 23:01:23 +00002816static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00002817{
blueswir1c2efc952007-09-25 17:28:42 +00002818 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00002819 int op;
ths3b46e622007-09-17 08:09:54 +00002820
aliguori376253e2009-03-05 23:01:23 +00002821 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00002822 for(;;) {
2823 op = *pch;
2824 if (op != '*' && op != '/' && op != '%')
2825 break;
2826 next();
aliguori376253e2009-03-05 23:01:23 +00002827 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00002828 switch(op) {
2829 default:
2830 case '*':
2831 val *= val2;
2832 break;
2833 case '/':
2834 case '%':
ths5fafdf22007-09-16 21:08:06 +00002835 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00002836 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00002837 if (op == '/')
2838 val /= val2;
2839 else
2840 val %= val2;
2841 break;
2842 }
2843 }
2844 return val;
2845}
2846
aliguori376253e2009-03-05 23:01:23 +00002847static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00002848{
blueswir1c2efc952007-09-25 17:28:42 +00002849 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00002850 int op;
bellard9307c4c2004-04-04 12:57:25 +00002851
aliguori376253e2009-03-05 23:01:23 +00002852 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00002853 for(;;) {
2854 op = *pch;
2855 if (op != '&' && op != '|' && op != '^')
2856 break;
2857 next();
aliguori376253e2009-03-05 23:01:23 +00002858 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00002859 switch(op) {
2860 default:
2861 case '&':
2862 val &= val2;
2863 break;
2864 case '|':
2865 val |= val2;
2866 break;
2867 case '^':
2868 val ^= val2;
2869 break;
2870 }
2871 }
2872 return val;
2873}
2874
aliguori376253e2009-03-05 23:01:23 +00002875static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00002876{
blueswir1c2efc952007-09-25 17:28:42 +00002877 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00002878 int op;
bellard9307c4c2004-04-04 12:57:25 +00002879
aliguori376253e2009-03-05 23:01:23 +00002880 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00002881 for(;;) {
2882 op = *pch;
2883 if (op != '+' && op != '-')
2884 break;
2885 next();
aliguori376253e2009-03-05 23:01:23 +00002886 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00002887 if (op == '+')
2888 val += val2;
2889 else
2890 val -= val2;
2891 }
2892 return val;
2893}
2894
aliguori376253e2009-03-05 23:01:23 +00002895static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00002896{
2897 pch = *pp;
Peter Maydell6ab7e542013-02-20 15:21:09 +00002898 if (sigsetjmp(expr_env, 0)) {
bellard9307c4c2004-04-04 12:57:25 +00002899 *pp = pch;
2900 return -1;
2901 }
blueswir1cd390082008-11-16 13:53:32 +00002902 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00002903 pch++;
aliguori376253e2009-03-05 23:01:23 +00002904 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00002905 *pp = pch;
2906 return 0;
2907}
2908
Markus Armbruster3350a4d2010-01-25 14:23:03 +01002909static int get_double(Monitor *mon, double *pval, const char **pp)
2910{
2911 const char *p = *pp;
2912 char *tailp;
2913 double d;
2914
2915 d = strtod(p, &tailp);
2916 if (tailp == p) {
2917 monitor_printf(mon, "Number expected\n");
2918 return -1;
2919 }
2920 if (d != d || d - d != 0) {
2921 /* NaN or infinity */
2922 monitor_printf(mon, "Bad number\n");
2923 return -1;
2924 }
2925 *pval = d;
2926 *pp = tailp;
2927 return 0;
2928}
2929
Luiz Capitulino4590fd82009-06-09 18:21:30 -03002930/*
2931 * Store the command-name in cmdname, and return a pointer to
2932 * the remaining of the command string.
2933 */
2934static const char *get_command_name(const char *cmdline,
2935 char *cmdname, size_t nlen)
2936{
2937 size_t len;
2938 const char *p, *pstart;
2939
2940 p = cmdline;
2941 while (qemu_isspace(*p))
2942 p++;
2943 if (*p == '\0')
2944 return NULL;
2945 pstart = p;
2946 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2947 p++;
2948 len = p - pstart;
2949 if (len > nlen - 1)
2950 len = nlen - 1;
2951 memcpy(cmdname, pstart, len);
2952 cmdname[len] = '\0';
2953 return p;
2954}
2955
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03002956/**
2957 * Read key of 'type' into 'key' and return the current
2958 * 'type' pointer.
2959 */
2960static char *key_get_info(const char *type, char **key)
2961{
2962 size_t len;
2963 char *p, *str;
2964
2965 if (*type == ',')
2966 type++;
2967
2968 p = strchr(type, ':');
2969 if (!p) {
2970 *key = NULL;
2971 return NULL;
2972 }
2973 len = p - type;
2974
Anthony Liguori7267c092011-08-20 22:09:37 -05002975 str = g_malloc(len + 1);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03002976 memcpy(str, type, len);
2977 str[len] = '\0';
2978
2979 *key = str;
2980 return ++p;
2981}
2982
bellard9307c4c2004-04-04 12:57:25 +00002983static int default_fmt_format = 'x';
2984static int default_fmt_size = 4;
2985
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02002986static int is_valid_option(const char *c, const char *typestr)
2987{
2988 char option[3];
2989
2990 option[0] = '-';
2991 option[1] = *c;
2992 option[2] = '\0';
2993
2994 typestr = strstr(typestr, option);
2995 return (typestr != NULL);
2996}
2997
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03002998static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2999 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003000{
3001 const mon_cmd_t *cmd;
3002
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003003 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003004 if (compare_cmd(cmdname, cmd->name)) {
3005 return cmd;
3006 }
3007 }
3008
3009 return NULL;
3010}
3011
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003012/*
Bandan Dasae502122015-06-03 18:38:08 -04003013 * Parse command name from @cmdp according to command table @table.
3014 * If blank, return NULL.
3015 * Else, if no valid command can be found, report to @mon, and return
3016 * NULL.
3017 * Else, change @cmdp to point right behind the name, and return its
3018 * command table entry.
3019 * Do not assume the return value points into @table! It doesn't when
3020 * the command is found in a sub-command table.
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003021 */
Anthony Liguoric227f092009-10-01 16:12:16 -05003022static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Dr. David Alan Gilbert250b8192017-08-17 11:42:16 +01003023 const char *cmdp_start,
Bandan Dasae502122015-06-03 18:38:08 -04003024 const char **cmdp,
3025 mon_cmd_t *table)
bellard9307c4c2004-04-04 12:57:25 +00003026{
Bandan Dasae502122015-06-03 18:38:08 -04003027 const char *p;
Anthony Liguoric227f092009-10-01 16:12:16 -05003028 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003029 char cmdname[256];
bellard9dc39cb2004-03-14 21:38:27 +00003030
bellard9307c4c2004-04-04 12:57:25 +00003031 /* extract the command name */
Bandan Dasae502122015-06-03 18:38:08 -04003032 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003033 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003034 return NULL;
ths3b46e622007-09-17 08:09:54 +00003035
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003036 cmd = search_dispatch_table(table, cmdname);
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003037 if (!cmd) {
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003038 monitor_printf(mon, "unknown command: '%.*s'\n",
Dr. David Alan Gilbert250b8192017-08-17 11:42:16 +01003039 (int)(p - cmdp_start), cmdp_start);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003040 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003041 }
Dr. David Alan Gilbertc3120f72018-06-20 16:39:41 +01003042 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
3043 monitor_printf(mon, "Command '%.*s' not available with -preconfig "
3044 "until after exit_preconfig.\n",
3045 (int)(p - cmdp_start), cmdp_start);
3046 return NULL;
3047 }
bellard9307c4c2004-04-04 12:57:25 +00003048
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003049 /* filter out following useless space */
3050 while (qemu_isspace(*p)) {
3051 p++;
3052 }
Bandan Dasae502122015-06-03 18:38:08 -04003053
3054 *cmdp = p;
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003055 /* search sub command */
Bandan Dasae502122015-06-03 18:38:08 -04003056 if (cmd->sub_table != NULL && *p != '\0') {
Dr. David Alan Gilbert250b8192017-08-17 11:42:16 +01003057 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003058 }
3059
Bandan Dasae502122015-06-03 18:38:08 -04003060 return cmd;
3061}
3062
3063/*
3064 * Parse arguments for @cmd.
3065 * If it can't be parsed, report to @mon, and return NULL.
3066 * Else, insert command arguments into a QDict, and return it.
3067 * Note: On success, caller has to free the QDict structure.
3068 */
3069
3070static QDict *monitor_parse_arguments(Monitor *mon,
3071 const char **endp,
3072 const mon_cmd_t *cmd)
3073{
3074 const char *typestr;
3075 char *key;
3076 int c;
3077 const char *p = *endp;
3078 char buf[1024];
3079 QDict *qdict = qdict_new();
3080
bellard9307c4c2004-04-04 12:57:25 +00003081 /* parse the parameters */
3082 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003083 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003084 typestr = key_get_info(typestr, &key);
3085 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003086 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003087 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003088 typestr++;
3089 switch(c) {
3090 case 'F':
bellard81d09122004-07-14 17:21:37 +00003091 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003092 case 's':
3093 {
3094 int ret;
ths3b46e622007-09-17 08:09:54 +00003095
blueswir1cd390082008-11-16 13:53:32 +00003096 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003097 p++;
3098 if (*typestr == '?') {
3099 typestr++;
3100 if (*p == '\0') {
3101 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003102 break;
bellard9307c4c2004-04-04 12:57:25 +00003103 }
3104 }
3105 ret = get_str(buf, sizeof(buf), &p);
3106 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003107 switch(c) {
3108 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003109 monitor_printf(mon, "%s: filename expected\n",
Bandan Dasae502122015-06-03 18:38:08 -04003110 cmd->name);
bellard81d09122004-07-14 17:21:37 +00003111 break;
3112 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003113 monitor_printf(mon, "%s: block device name expected\n",
Bandan Dasae502122015-06-03 18:38:08 -04003114 cmd->name);
bellard81d09122004-07-14 17:21:37 +00003115 break;
3116 default:
Bandan Dasae502122015-06-03 18:38:08 -04003117 monitor_printf(mon, "%s: string expected\n", cmd->name);
bellard81d09122004-07-14 17:21:37 +00003118 break;
3119 }
bellard9307c4c2004-04-04 12:57:25 +00003120 goto fail;
3121 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003122 qdict_put_str(qdict, key, buf);
bellard9307c4c2004-04-04 12:57:25 +00003123 }
3124 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003125 case 'O':
3126 {
3127 QemuOptsList *opts_list;
3128 QemuOpts *opts;
3129
3130 opts_list = qemu_find_opts(key);
3131 if (!opts_list || opts_list->desc->name) {
3132 goto bad_type;
3133 }
3134 while (qemu_isspace(*p)) {
3135 p++;
3136 }
3137 if (!*p)
3138 break;
3139 if (get_str(buf, sizeof(buf), &p) < 0) {
3140 goto fail;
3141 }
Markus Armbruster70b94332015-02-13 12:50:26 +01003142 opts = qemu_opts_parse_noisily(opts_list, buf, true);
Markus Armbruster361127d2010-02-10 20:24:35 +01003143 if (!opts) {
3144 goto fail;
3145 }
3146 qemu_opts_to_qdict(opts, qdict);
3147 qemu_opts_del(opts);
3148 }
3149 break;
bellard9307c4c2004-04-04 12:57:25 +00003150 case '/':
3151 {
3152 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003153
blueswir1cd390082008-11-16 13:53:32 +00003154 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003155 p++;
3156 if (*p == '/') {
3157 /* format found */
3158 p++;
3159 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003160 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003161 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003162 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003163 count = count * 10 + (*p - '0');
3164 p++;
3165 }
3166 }
3167 size = -1;
3168 format = -1;
3169 for(;;) {
3170 switch(*p) {
3171 case 'o':
3172 case 'd':
3173 case 'u':
3174 case 'x':
3175 case 'i':
3176 case 'c':
3177 format = *p++;
3178 break;
3179 case 'b':
3180 size = 1;
3181 p++;
3182 break;
3183 case 'h':
3184 size = 2;
3185 p++;
3186 break;
3187 case 'w':
3188 size = 4;
3189 p++;
3190 break;
3191 case 'g':
3192 case 'L':
3193 size = 8;
3194 p++;
3195 break;
3196 default:
3197 goto next;
3198 }
3199 }
3200 next:
blueswir1cd390082008-11-16 13:53:32 +00003201 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003202 monitor_printf(mon, "invalid char in format: '%c'\n",
3203 *p);
bellard9307c4c2004-04-04 12:57:25 +00003204 goto fail;
3205 }
bellard9307c4c2004-04-04 12:57:25 +00003206 if (format < 0)
3207 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003208 if (format != 'i') {
3209 /* for 'i', not specifying a size gives -1 as size */
3210 if (size < 0)
3211 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003212 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003213 }
bellard9307c4c2004-04-04 12:57:25 +00003214 default_fmt_format = format;
3215 } else {
3216 count = 1;
3217 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003218 if (format != 'i') {
3219 size = default_fmt_size;
3220 } else {
3221 size = -1;
3222 }
bellard9307c4c2004-04-04 12:57:25 +00003223 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003224 qdict_put_int(qdict, "count", count);
3225 qdict_put_int(qdict, "format", format);
3226 qdict_put_int(qdict, "size", size);
bellard9307c4c2004-04-04 12:57:25 +00003227 }
3228 break;
3229 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003230 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003231 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003232 {
blueswir1c2efc952007-09-25 17:28:42 +00003233 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003234
blueswir1cd390082008-11-16 13:53:32 +00003235 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003236 p++;
bellard34405572004-06-08 00:55:58 +00003237 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003238 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003239 if (*p == '\0') {
3240 typestr++;
3241 break;
3242 }
bellard34405572004-06-08 00:55:58 +00003243 } else {
3244 if (*p == '.') {
3245 p++;
blueswir1cd390082008-11-16 13:53:32 +00003246 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003247 p++;
bellard34405572004-06-08 00:55:58 +00003248 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003249 typestr++;
3250 break;
bellard34405572004-06-08 00:55:58 +00003251 }
3252 }
bellard13224a82006-07-14 22:03:35 +00003253 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003254 }
aliguori376253e2009-03-05 23:01:23 +00003255 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003256 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003257 /* Check if 'i' is greater than 32-bit */
3258 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
Bandan Dasae502122015-06-03 18:38:08 -04003259 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003260 monitor_printf(mon, "integer is for 32-bit values\n");
3261 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003262 } else if (c == 'M') {
Luiz Capitulino91162842012-04-26 17:34:30 -03003263 if (val < 0) {
3264 monitor_printf(mon, "enter a positive value\n");
3265 goto fail;
3266 }
Philippe Mathieu-Daudé8ec338a2018-06-25 09:42:34 -03003267 val *= MiB;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003268 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003269 qdict_put_int(qdict, key, val);
bellard9307c4c2004-04-04 12:57:25 +00003270 }
3271 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003272 case 'o':
3273 {
Markus Armbrusterf17fd4f2017-02-21 21:14:06 +01003274 int ret;
Markus Armbrusterf46bfdb2017-02-21 21:14:07 +01003275 uint64_t val;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003276 char *end;
3277
3278 while (qemu_isspace(*p)) {
3279 p++;
3280 }
3281 if (*typestr == '?') {
3282 typestr++;
3283 if (*p == '\0') {
3284 break;
3285 }
3286 }
Markus Armbrusterf17fd4f2017-02-21 21:14:06 +01003287 ret = qemu_strtosz_MiB(p, &end, &val);
Markus Armbrusterf46bfdb2017-02-21 21:14:07 +01003288 if (ret < 0 || val > INT64_MAX) {
Jes Sorensendbc0c672010-10-21 17:15:47 +02003289 monitor_printf(mon, "invalid size\n");
3290 goto fail;
3291 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003292 qdict_put_int(qdict, key, val);
Jes Sorensendbc0c672010-10-21 17:15:47 +02003293 p = end;
3294 }
3295 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003296 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003297 {
3298 double val;
3299
3300 while (qemu_isspace(*p))
3301 p++;
3302 if (*typestr == '?') {
3303 typestr++;
3304 if (*p == '\0') {
3305 break;
3306 }
3307 }
3308 if (get_double(mon, &val, &p) < 0) {
3309 goto fail;
3310 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003311 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003312 switch (*p) {
3313 case 'm':
3314 val /= 1e3; p += 2; break;
3315 case 'u':
3316 val /= 1e6; p += 2; break;
3317 case 'n':
3318 val /= 1e9; p += 2; break;
3319 }
3320 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003321 if (*p && !qemu_isspace(*p)) {
3322 monitor_printf(mon, "Unknown unit suffix\n");
3323 goto fail;
3324 }
Marc-André Lureau01b2ffc2017-06-07 20:35:58 +04003325 qdict_put(qdict, key, qnum_from_double(val));
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003326 }
3327 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003328 case 'b':
3329 {
3330 const char *beg;
Eric Blakefc48ffc2015-05-15 16:24:59 -06003331 bool val;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003332
3333 while (qemu_isspace(*p)) {
3334 p++;
3335 }
3336 beg = p;
3337 while (qemu_isgraph(*p)) {
3338 p++;
3339 }
3340 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
Eric Blakefc48ffc2015-05-15 16:24:59 -06003341 val = true;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003342 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
Eric Blakefc48ffc2015-05-15 16:24:59 -06003343 val = false;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003344 } else {
3345 monitor_printf(mon, "Expected 'on' or 'off'\n");
3346 goto fail;
3347 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003348 qdict_put_bool(qdict, key, val);
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003349 }
3350 break;
bellard9307c4c2004-04-04 12:57:25 +00003351 case '-':
3352 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003353 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003354 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00003355 /* option */
ths3b46e622007-09-17 08:09:54 +00003356
bellard9307c4c2004-04-04 12:57:25 +00003357 c = *typestr++;
3358 if (c == '\0')
3359 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00003360 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003361 p++;
bellard9307c4c2004-04-04 12:57:25 +00003362 if (*p == '-') {
3363 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003364 if(c != *p) {
3365 if(!is_valid_option(p, typestr)) {
3366
3367 monitor_printf(mon, "%s: unsupported option -%c\n",
Bandan Dasae502122015-06-03 18:38:08 -04003368 cmd->name, *p);
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003369 goto fail;
3370 } else {
3371 skip_key = 1;
3372 }
bellard9307c4c2004-04-04 12:57:25 +00003373 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003374 if(skip_key) {
3375 p = tmp;
3376 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003377 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003378 p++;
Eric Blake46f5ac22017-04-27 16:58:17 -05003379 qdict_put_bool(qdict, key, true);
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003380 }
bellard9307c4c2004-04-04 12:57:25 +00003381 }
bellard9307c4c2004-04-04 12:57:25 +00003382 }
3383 break;
Wenchao Xia129be002013-08-27 20:38:26 +08003384 case 'S':
3385 {
3386 /* package all remaining string */
3387 int len;
3388
3389 while (qemu_isspace(*p)) {
3390 p++;
3391 }
3392 if (*typestr == '?') {
3393 typestr++;
3394 if (*p == '\0') {
3395 /* no remaining string: NULL argument */
3396 break;
3397 }
3398 }
3399 len = strlen(p);
3400 if (len <= 0) {
3401 monitor_printf(mon, "%s: string expected\n",
Bandan Dasae502122015-06-03 18:38:08 -04003402 cmd->name);
Bandan Dase549d2a2015-06-03 18:38:10 -04003403 goto fail;
Wenchao Xia129be002013-08-27 20:38:26 +08003404 }
Eric Blake46f5ac22017-04-27 16:58:17 -05003405 qdict_put_str(qdict, key, p);
Wenchao Xia129be002013-08-27 20:38:26 +08003406 p += len;
3407 }
3408 break;
bellard9307c4c2004-04-04 12:57:25 +00003409 default:
3410 bad_type:
Bandan Dasae502122015-06-03 18:38:08 -04003411 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
bellard9307c4c2004-04-04 12:57:25 +00003412 goto fail;
3413 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003414 g_free(key);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003415 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00003416 }
3417 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00003418 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003419 p++;
3420 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00003421 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
Bandan Dasae502122015-06-03 18:38:08 -04003422 cmd->name);
bellard9307c4c2004-04-04 12:57:25 +00003423 goto fail;
3424 }
3425
Bandan Dasae502122015-06-03 18:38:08 -04003426 return qdict;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02003427
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003428fail:
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003429 qobject_unref(qdict);
Anthony Liguori7267c092011-08-20 22:09:37 -05003430 g_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003431 return NULL;
3432}
3433
Markus Armbruster7ef6cf62015-03-06 19:12:36 +01003434static void handle_hmp_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003435{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003436 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05003437 const mon_cmd_t *cmd;
Collin Walling317c52c2018-05-07 10:30:54 -04003438 const char *cmd_start = cmdline;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003439
Stefan Hajnoczi79cad8b2017-06-05 11:42:15 +01003440 trace_handle_hmp_command(mon, cmdline);
3441
Dr. David Alan Gilbert250b8192017-08-17 11:42:16 +01003442 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
Bandan Dasae502122015-06-03 18:38:08 -04003443 if (!cmd) {
3444 return;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003445 }
3446
Bandan Dasae502122015-06-03 18:38:08 -04003447 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3448 if (!qdict) {
Collin Walling317c52c2018-05-07 10:30:54 -04003449 while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
3450 cmdline--;
3451 }
3452 monitor_printf(mon, "Try \"help %.*s\" for more information\n",
3453 (int)(cmdline - cmd_start), cmd_start);
Bandan Dasae502122015-06-03 18:38:08 -04003454 return;
3455 }
3456
Marc-André Lureau2b9e3572016-09-12 13:19:06 +04003457 cmd->cmd(mon, qdict);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02003458 qobject_unref(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00003459}
3460
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08003461static void cmd_completion(Monitor *mon, const char *name, const char *list)
bellard81d09122004-07-14 17:21:37 +00003462{
3463 const char *p, *pstart;
3464 char cmd[128];
3465 int len;
3466
3467 p = list;
3468 for(;;) {
3469 pstart = p;
Keno Fischer5c99fa32018-06-29 12:32:10 +02003470 p = qemu_strchrnul(p, '|');
bellard81d09122004-07-14 17:21:37 +00003471 len = p - pstart;
3472 if (len > sizeof(cmd) - 2)
3473 len = sizeof(cmd) - 2;
3474 memcpy(cmd, pstart, len);
3475 cmd[len] = '\0';
3476 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08003477 readline_add_completion(mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00003478 }
3479 if (*p == '\0')
3480 break;
3481 p++;
3482 }
3483}
3484
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08003485static void file_completion(Monitor *mon, const char *input)
bellard81d09122004-07-14 17:21:37 +00003486{
3487 DIR *ffs;
3488 struct dirent *d;
3489 char path[1024];
3490 char file[1024], file_prefix[1024];
3491 int input_path_len;
3492 const char *p;
3493
ths5fafdf22007-09-16 21:08:06 +00003494 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00003495 if (!p) {
3496 input_path_len = 0;
3497 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00003498 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00003499 } else {
3500 input_path_len = p - input + 1;
3501 memcpy(path, input, input_path_len);
3502 if (input_path_len > sizeof(path) - 1)
3503 input_path_len = sizeof(path) - 1;
3504 path[input_path_len] = '\0';
3505 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3506 }
Bandan Das19f2db52015-06-03 18:38:07 -04003507
bellard81d09122004-07-14 17:21:37 +00003508 ffs = opendir(path);
3509 if (!ffs)
3510 return;
3511 for(;;) {
3512 struct stat sb;
3513 d = readdir(ffs);
3514 if (!d)
3515 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09003516
3517 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3518 continue;
3519 }
3520
bellard81d09122004-07-14 17:21:37 +00003521 if (strstart(d->d_name, file_prefix, NULL)) {
3522 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00003523 if (input_path_len < sizeof(file))
3524 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3525 d->d_name);
bellard81d09122004-07-14 17:21:37 +00003526 /* stat the file to find out if it's a directory.
3527 * In that case add a slash to speed up typing long paths
3528 */
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01003529 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
blueswir1363a37d2008-08-21 17:58:08 +00003530 pstrcat(file, sizeof(file), "/");
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01003531 }
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08003532 readline_add_completion(mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00003533 }
3534 }
3535 closedir(ffs);
3536}
3537
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003538static const char *next_arg_type(const char *typestr)
3539{
3540 const char *p = strchr(typestr, ':');
3541 return (p != NULL ? ++p : typestr);
3542}
3543
Hani Benhabiles40d19392014-05-07 23:41:30 +01003544static void add_completion_option(ReadLineState *rs, const char *str,
3545 const char *option)
3546{
3547 if (!str || !option) {
3548 return;
3549 }
3550 if (!strncmp(option, str, strlen(str))) {
3551 readline_add_completion(rs, option);
3552 }
3553}
3554
Hani Benhabiles13e315d2014-05-07 23:41:29 +01003555void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3556{
3557 size_t len;
3558 ChardevBackendInfoList *list, *start;
3559
3560 if (nb_args != 2) {
3561 return;
3562 }
3563 len = strlen(str);
3564 readline_set_completion_index(rs, len);
3565
3566 start = list = qmp_query_chardev_backends(NULL);
3567 while (list) {
3568 const char *chr_name = list->value->name;
3569
3570 if (!strncmp(chr_name, str, len)) {
3571 readline_add_completion(rs, chr_name);
3572 }
3573 list = list->next;
3574 }
3575 qapi_free_ChardevBackendInfoList(start);
3576}
3577
Hani Benhabilesb162b492014-05-07 23:41:31 +01003578void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3579{
3580 size_t len;
3581 int i;
3582
3583 if (nb_args != 2) {
3584 return;
3585 }
3586 len = strlen(str);
3587 readline_set_completion_index(rs, len);
Markus Armbruster1c236ba2017-08-24 10:46:06 +02003588 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02003589 add_completion_option(rs, str, NetClientDriver_str(i));
Hani Benhabilesb162b492014-05-07 23:41:31 +01003590 }
3591}
3592
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003593void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles992d3e62014-02-06 23:30:11 +01003594{
3595 GSList *list, *elt;
3596 size_t len;
3597
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003598 if (nb_args != 2) {
3599 return;
3600 }
3601
Hani Benhabiles992d3e62014-02-06 23:30:11 +01003602 len = strlen(str);
3603 readline_set_completion_index(rs, len);
3604 list = elt = object_class_get_list(TYPE_DEVICE, false);
3605 while (elt) {
3606 const char *name;
3607 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3608 TYPE_DEVICE);
3609 name = object_class_get_name(OBJECT_CLASS(dc));
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003610
Eduardo Habkoste90f2a82017-05-03 17:35:44 -03003611 if (dc->user_creatable
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003612 && !strncmp(name, str, len)) {
Hani Benhabiles992d3e62014-02-06 23:30:11 +01003613 readline_add_completion(rs, name);
3614 }
3615 elt = elt->next;
3616 }
3617 g_slist_free(list);
3618}
3619
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01003620void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles1094fd32014-02-06 23:30:13 +01003621{
3622 GSList *list, *elt;
3623 size_t len;
3624
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01003625 if (nb_args != 2) {
3626 return;
3627 }
3628
Hani Benhabiles1094fd32014-02-06 23:30:13 +01003629 len = strlen(str);
3630 readline_set_completion_index(rs, len);
3631 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3632 while (elt) {
3633 const char *name;
3634
3635 name = object_class_get_name(OBJECT_CLASS(elt->data));
3636 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3637 readline_add_completion(rs, name);
3638 }
3639 elt = elt->next;
3640 }
3641 g_slist_free(list);
3642}
3643
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08003644static void peripheral_device_del_completion(ReadLineState *rs,
3645 const char *str, size_t len)
3646{
Marcel Apfelbaum4cae4d52014-11-26 13:50:01 +02003647 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3648 GSList *list, *item;
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08003649
Marcel Apfelbaum4cae4d52014-11-26 13:50:01 +02003650 list = qdev_build_hotpluggable_device_list(peripheral);
3651 if (!list) {
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08003652 return;
3653 }
3654
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08003655 for (item = list; item; item = g_slist_next(item)) {
3656 DeviceState *dev = item->data;
3657
3658 if (dev->id && !strncmp(str, dev->id, len)) {
3659 readline_add_completion(rs, dev->id);
3660 }
3661 }
3662
3663 g_slist_free(list);
3664}
3665
Hani Benhabiles6297d9a2014-05-07 23:41:28 +01003666void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3667{
3668 size_t len;
3669 ChardevInfoList *list, *start;
3670
3671 if (nb_args != 2) {
3672 return;
3673 }
3674 len = strlen(str);
3675 readline_set_completion_index(rs, len);
3676
3677 start = list = qmp_query_chardev(NULL);
3678 while (list) {
3679 ChardevInfo *chr = list->value;
3680
3681 if (!strncmp(chr->label, str, len)) {
3682 readline_add_completion(rs, chr->label);
3683 }
3684 list = list->next;
3685 }
3686 qapi_free_ChardevInfoList(start);
3687}
3688
Hani Benhabiles8e597772014-05-27 23:39:30 +01003689static void ringbuf_completion(ReadLineState *rs, const char *str)
3690{
3691 size_t len;
3692 ChardevInfoList *list, *start;
3693
3694 len = strlen(str);
3695 readline_set_completion_index(rs, len);
3696
3697 start = list = qmp_query_chardev(NULL);
3698 while (list) {
3699 ChardevInfo *chr_info = list->value;
3700
3701 if (!strncmp(chr_info->label, str, len)) {
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03003702 Chardev *chr = qemu_chr_find(chr_info->label);
Marc-André Lureau777357d2016-12-07 18:39:10 +03003703 if (chr && CHARDEV_IS_RINGBUF(chr)) {
Hani Benhabiles8e597772014-05-27 23:39:30 +01003704 readline_add_completion(rs, chr_info->label);
3705 }
3706 }
3707 list = list->next;
3708 }
3709 qapi_free_ChardevInfoList(start);
3710}
3711
Hani Benhabiles8e597772014-05-27 23:39:30 +01003712void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3713{
3714 if (nb_args != 2) {
3715 return;
3716 }
3717 ringbuf_completion(rs, str);
3718}
3719
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003720void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3721{
3722 size_t len;
3723
3724 if (nb_args != 2) {
3725 return;
3726 }
3727
3728 len = strlen(str);
3729 readline_set_completion_index(rs, len);
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08003730 peripheral_device_del_completion(rs, str, len);
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01003731}
3732
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01003733void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabilesb48fa072014-02-06 23:30:12 +01003734{
3735 ObjectPropertyInfoList *list, *start;
3736 size_t len;
3737
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01003738 if (nb_args != 2) {
3739 return;
3740 }
Hani Benhabilesb48fa072014-02-06 23:30:12 +01003741 len = strlen(str);
3742 readline_set_completion_index(rs, len);
3743
3744 start = list = qmp_qom_list("/objects", NULL);
3745 while (list) {
3746 ObjectPropertyInfo *info = list->value;
3747
3748 if (!strncmp(info->type, "child<", 5)
3749 && !strncmp(info->name, str, len)) {
3750 readline_add_completion(rs, info->name);
3751 }
3752 list = list->next;
3753 }
3754 qapi_free_ObjectPropertyInfoList(start);
3755}
3756
Hani Benhabiles29136cd2014-05-07 23:41:27 +01003757void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3758{
3759 int i;
3760 char *sep;
3761 size_t len;
3762
3763 if (nb_args != 2) {
3764 return;
3765 }
3766 sep = strrchr(str, '-');
3767 if (sep) {
3768 str = sep + 1;
3769 }
3770 len = strlen(str);
3771 readline_set_completion_index(rs, len);
Eric Blake7fb1cf12015-11-18 01:52:57 -07003772 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02003773 if (!strncmp(str, QKeyCode_str(i), len)) {
3774 readline_add_completion(rs, QKeyCode_str(i));
Hani Benhabiles29136cd2014-05-07 23:41:27 +01003775 }
3776 }
3777}
3778
Hani Benhabiles40d19392014-05-07 23:41:30 +01003779void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3780{
3781 size_t len;
3782
3783 len = strlen(str);
3784 readline_set_completion_index(rs, len);
3785 if (nb_args == 2) {
Jason Wangeaed4832015-04-23 14:21:38 +08003786 NetClientState *ncs[MAX_QUEUE_NUM];
Hani Benhabiles40d19392014-05-07 23:41:30 +01003787 int count, i;
3788 count = qemu_find_net_clients_except(NULL, ncs,
Eric Blakef394b2e2016-07-13 21:50:23 -06003789 NET_CLIENT_DRIVER_NONE,
Jason Wangeaed4832015-04-23 14:21:38 +08003790 MAX_QUEUE_NUM);
Jason Wangbcfa4d62015-04-23 14:21:39 +08003791 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
Hani Benhabiles40d19392014-05-07 23:41:30 +01003792 const char *name = ncs[i]->name;
3793 if (!strncmp(str, name, len)) {
3794 readline_add_completion(rs, name);
3795 }
3796 }
3797 } else if (nb_args == 3) {
3798 add_completion_option(rs, str, "on");
3799 add_completion_option(rs, str, "off");
3800 }
3801}
3802
Hani Benhabiles11b389f2014-05-07 23:41:32 +01003803void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3804{
3805 int len, count, i;
Jason Wangeaed4832015-04-23 14:21:38 +08003806 NetClientState *ncs[MAX_QUEUE_NUM];
Hani Benhabiles11b389f2014-05-07 23:41:32 +01003807
3808 if (nb_args != 2) {
3809 return;
3810 }
3811
3812 len = strlen(str);
3813 readline_set_completion_index(rs, len);
Eric Blakef394b2e2016-07-13 21:50:23 -06003814 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
Jason Wangeaed4832015-04-23 14:21:38 +08003815 MAX_QUEUE_NUM);
Jason Wangbcfa4d62015-04-23 14:21:39 +08003816 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
Hani Benhabiles11b389f2014-05-07 23:41:32 +01003817 QemuOpts *opts;
3818 const char *name = ncs[i]->name;
3819 if (strncmp(str, name, len)) {
3820 continue;
3821 }
3822 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3823 if (opts) {
3824 readline_add_completion(rs, name);
3825 }
3826 }
3827}
3828
Lluís Vilanovabd712112016-07-11 12:53:51 +02003829void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3830{
3831 size_t len;
3832
3833 len = strlen(str);
3834 readline_set_completion_index(rs, len);
3835 if (nb_args == 2) {
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01003836 TraceEventIter iter;
3837 TraceEvent *ev;
3838 char *pattern = g_strdup_printf("%s*", str);
3839 trace_event_iter_init(&iter, pattern);
3840 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3841 readline_add_completion(rs, trace_event_get_name(ev));
Lluís Vilanovabd712112016-07-11 12:53:51 +02003842 }
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01003843 g_free(pattern);
Lluís Vilanovabd712112016-07-11 12:53:51 +02003844 }
3845}
3846
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01003847void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3848{
3849 size_t len;
3850
3851 len = strlen(str);
3852 readline_set_completion_index(rs, len);
3853 if (nb_args == 2) {
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01003854 TraceEventIter iter;
3855 TraceEvent *ev;
3856 char *pattern = g_strdup_printf("%s*", str);
3857 trace_event_iter_init(&iter, pattern);
3858 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3859 readline_add_completion(rs, trace_event_get_name(ev));
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01003860 }
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01003861 g_free(pattern);
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01003862 } else if (nb_args == 3) {
3863 add_completion_option(rs, str, "on");
3864 add_completion_option(rs, str, "off");
3865 }
3866}
3867
Hani Benhabilesd0ece342014-05-27 23:39:31 +01003868void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3869{
Hani Benhabiles4bb08af2014-07-29 23:22:40 +01003870 int i;
3871
Hani Benhabilesd0ece342014-05-27 23:39:31 +01003872 if (nb_args != 2) {
3873 return;
3874 }
3875 readline_set_completion_index(rs, strlen(str));
Michal Privoznik14d53b42017-09-07 10:05:24 +02003876 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3877 add_completion_option(rs, str, WatchdogAction_str(i));
Hani Benhabiles4bb08af2014-07-29 23:22:40 +01003878 }
Hani Benhabilesd0ece342014-05-27 23:39:31 +01003879}
3880
Hani Benhabilesc68a0402014-05-27 23:39:32 +01003881void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3882 const char *str)
3883{
3884 size_t len;
3885
3886 len = strlen(str);
3887 readline_set_completion_index(rs, len);
3888 if (nb_args == 2) {
3889 int i;
Eric Blake7fb1cf12015-11-18 01:52:57 -07003890 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02003891 const char *name = MigrationCapability_str(i);
Hani Benhabilesc68a0402014-05-27 23:39:32 +01003892 if (!strncmp(str, name, len)) {
3893 readline_add_completion(rs, name);
3894 }
3895 }
3896 } else if (nb_args == 3) {
3897 add_completion_option(rs, str, "on");
3898 add_completion_option(rs, str, "off");
3899 }
3900}
3901
Liang Li50e9a622015-03-23 16:32:29 +08003902void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3903 const char *str)
3904{
3905 size_t len;
3906
3907 len = strlen(str);
3908 readline_set_completion_index(rs, len);
3909 if (nb_args == 2) {
3910 int i;
Eric Blake7fb1cf12015-11-18 01:52:57 -07003911 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02003912 const char *name = MigrationParameter_str(i);
Liang Li50e9a622015-03-23 16:32:29 +08003913 if (!strncmp(str, name, len)) {
3914 readline_add_completion(rs, name);
3915 }
3916 }
3917 }
3918}
3919
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003920static void vm_completion(ReadLineState *rs, const char *str)
3921{
3922 size_t len;
Kevin Wolf7c8eece2016-03-22 18:58:50 +01003923 BlockDriverState *bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +02003924 BdrvNextIterator it;
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003925
3926 len = strlen(str);
3927 readline_set_completion_index(rs, len);
Kevin Wolf7c8eece2016-03-22 18:58:50 +01003928
Kevin Wolf88be7b42016-05-20 18:49:07 +02003929 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003930 SnapshotInfoList *snapshots, *snapshot;
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03003931 AioContext *ctx = bdrv_get_aio_context(bs);
3932 bool ok = false;
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003933
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03003934 aio_context_acquire(ctx);
3935 if (bdrv_can_snapshot(bs)) {
3936 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3937 }
3938 aio_context_release(ctx);
3939 if (!ok) {
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003940 continue;
3941 }
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03003942
Hani Benhabilesb21631f2014-05-27 23:39:37 +01003943 snapshot = snapshots;
3944 while (snapshot) {
3945 char *completion = snapshot->value->name;
3946 if (!strncmp(str, completion, len)) {
3947 readline_add_completion(rs, completion);
3948 }
3949 completion = snapshot->value->id;
3950 if (!strncmp(str, completion, len)) {
3951 readline_add_completion(rs, completion);
3952 }
3953 snapshot = snapshot->next;
3954 }
3955 qapi_free_SnapshotInfoList(snapshots);
3956 }
3957
3958}
3959
3960void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3961{
3962 if (nb_args == 2) {
3963 vm_completion(rs, str);
3964 }
3965}
3966
3967void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3968{
3969 if (nb_args == 2) {
3970 vm_completion(rs, str);
3971 }
3972}
3973
Wenchao Xiac35b6402013-08-27 20:38:24 +08003974static void monitor_find_completion_by_table(Monitor *mon,
3975 const mon_cmd_t *cmd_table,
3976 char **args,
3977 int nb_args)
bellard81d09122004-07-14 17:21:37 +00003978{
3979 const char *cmdname;
Wenchao Xiac35b6402013-08-27 20:38:24 +08003980 int i;
Dr. David Alan Gilbertbf67f1c2018-02-13 12:51:43 +00003981 const char *ptype, *old_ptype, *str, *name;
Anthony Liguoric227f092009-10-01 16:12:16 -05003982 const mon_cmd_t *cmd;
Max Reitzda27a002016-03-16 19:54:29 +01003983 BlockBackend *blk = NULL;
bellard81d09122004-07-14 17:21:37 +00003984
bellard81d09122004-07-14 17:21:37 +00003985 if (nb_args <= 1) {
3986 /* command completion */
3987 if (nb_args == 0)
3988 cmdname = "";
3989 else
3990 cmdname = args[0];
Wenchao Xiad2674b22013-08-27 20:38:16 +08003991 readline_set_completion_index(mon->rs, strlen(cmdname));
Wenchao Xiac35b6402013-08-27 20:38:24 +08003992 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Dr. David Alan Gilbert6d9f7832018-06-20 16:39:43 +01003993 if (!runstate_check(RUN_STATE_PRECONFIG) ||
3994 cmd_can_preconfig(cmd)) {
3995 cmd_completion(mon, cmdname, cmd->name);
3996 }
bellard81d09122004-07-14 17:21:37 +00003997 }
3998 } else {
3999 /* find the command */
Wenchao Xiac35b6402013-08-27 20:38:24 +08004000 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Dr. David Alan Gilbert6d9f7832018-06-20 16:39:43 +01004001 if (compare_cmd(args[0], cmd->name) &&
4002 (!runstate_check(RUN_STATE_PRECONFIG) ||
4003 cmd_can_preconfig(cmd))) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004004 break;
4005 }
bellard81d09122004-07-14 17:21:37 +00004006 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004007 if (!cmd->name) {
Wenchao Xiac35b6402013-08-27 20:38:24 +08004008 return;
Jan Kiszka03a63482010-06-16 00:38:33 +02004009 }
4010
Wenchao Xiad903a772013-08-27 20:38:25 +08004011 if (cmd->sub_table) {
4012 /* do the job again */
Stefan Weile7ae7712015-03-08 19:30:01 +01004013 monitor_find_completion_by_table(mon, cmd->sub_table,
4014 &args[1], nb_args - 1);
4015 return;
Wenchao Xiad903a772013-08-27 20:38:25 +08004016 }
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004017 if (cmd->command_completion) {
Stefan Weile7ae7712015-03-08 19:30:01 +01004018 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4019 return;
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01004020 }
Wenchao Xiad903a772013-08-27 20:38:25 +08004021
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004022 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004023 for(i = 0; i < nb_args - 2; i++) {
4024 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004025 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004026 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004027 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004028 }
4029 }
4030 str = args[nb_args - 1];
Dr. David Alan Gilbertbf67f1c2018-02-13 12:51:43 +00004031 old_ptype = NULL;
4032 while (*ptype == '-' && old_ptype != ptype) {
4033 old_ptype = ptype;
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004034 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004035 }
bellard81d09122004-07-14 17:21:37 +00004036 switch(*ptype) {
4037 case 'F':
4038 /* file completion */
Wenchao Xiad2674b22013-08-27 20:38:16 +08004039 readline_set_completion_index(mon->rs, strlen(str));
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004040 file_completion(mon, str);
bellard81d09122004-07-14 17:21:37 +00004041 break;
4042 case 'B':
4043 /* block device name completion */
Wenchao Xia599a9262013-08-27 20:38:15 +08004044 readline_set_completion_index(mon->rs, strlen(str));
Max Reitzda27a002016-03-16 19:54:29 +01004045 while ((blk = blk_next(blk)) != NULL) {
4046 name = blk_name(blk);
Markus Armbrusterfea68bb2014-10-07 13:59:10 +02004047 if (str[0] == '\0' ||
4048 !strncmp(name, str, strlen(str))) {
4049 readline_add_completion(mon->rs, name);
4050 }
4051 }
bellard81d09122004-07-14 17:21:37 +00004052 break;
bellard7fe48482004-10-09 18:08:01 +00004053 case 's':
Wenchao Xia129be002013-08-27 20:38:26 +08004054 case 'S':
Hani Benhabiles29136cd2014-05-07 23:41:27 +01004055 if (!strcmp(cmd->name, "help|?")) {
Wenchao Xia7ca0e062013-08-27 20:38:27 +08004056 monitor_find_completion_by_table(mon, cmd_table,
4057 &args[1], nb_args - 1);
bellard7fe48482004-10-09 18:08:01 +00004058 }
4059 break;
bellard81d09122004-07-14 17:21:37 +00004060 default:
4061 break;
4062 }
4063 }
Wenchao Xiac35b6402013-08-27 20:38:24 +08004064}
4065
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004066static void monitor_find_completion(void *opaque,
Wenchao Xiac35b6402013-08-27 20:38:24 +08004067 const char *cmdline)
4068{
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004069 Monitor *mon = opaque;
Wenchao Xiac35b6402013-08-27 20:38:24 +08004070 char *args[MAX_ARGS];
4071 int nb_args, len;
4072
4073 /* 1. parse the cmdline */
4074 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4075 return;
4076 }
Wenchao Xiac35b6402013-08-27 20:38:24 +08004077
4078 /* if the line ends with a space, it means we want to complete the
4079 next arg */
4080 len = strlen(cmdline);
4081 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4082 if (nb_args >= MAX_ARGS) {
4083 goto cleanup;
4084 }
4085 args[nb_args++] = g_strdup("");
4086 }
4087
4088 /* 2. auto complete according to args */
4089 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
Jan Kiszka03a63482010-06-16 00:38:33 +02004090
4091cleanup:
Wenchao Xiadcc70cd2013-08-27 20:38:22 +08004092 free_cmdline_args(args, nb_args);
bellard81d09122004-07-14 17:21:37 +00004093}
4094
aliguori731b0362009-03-05 23:01:42 +00004095static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004096{
aliguori731b0362009-03-05 23:01:42 +00004097 Monitor *mon = opaque;
4098
Peter Xudf152fb2018-03-09 16:59:55 +08004099 return !atomic_mb_read(&mon->suspend_cnt);
bellard9dc39cb2004-03-14 21:38:27 +00004100}
4101
Peter Xu546aa562018-03-09 16:59:54 +08004102/*
4103 * 1. This function takes ownership of rsp, err, and id.
4104 * 2. rsp, err, and id may be NULL.
4105 * 3. If err != NULL then rsp must be NULL.
4106 */
4107static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
4108 Error *err, QObject *id)
4109{
Peter Xu546aa562018-03-09 16:59:54 +08004110 if (err) {
4111 assert(!rsp);
Markus Armbrustercee32792018-07-03 10:53:48 +02004112 rsp = QOBJECT(qmp_error_response(err));
Peter Xu546aa562018-03-09 16:59:54 +08004113 }
4114
4115 if (rsp) {
4116 if (id) {
Marc-André Lureauf5a74a52018-04-19 17:01:44 +02004117 qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
Peter Xu546aa562018-03-09 16:59:54 +08004118 }
4119
4120 monitor_json_emitter(mon, rsp);
4121 }
4122
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004123 qobject_unref(id);
4124 qobject_unref(rsp);
Peter Xu546aa562018-03-09 16:59:54 +08004125}
4126
Markus Armbrusterb2731452018-07-03 10:53:41 +02004127static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004128{
Markus Armbrusterb2731452018-07-03 10:53:41 +02004129 Monitor *old_mon;
4130 QObject *rsp;
Markus Armbruster69240fe2018-07-03 10:53:43 +02004131 QDict *error;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004132
Peter Xu227a0752018-03-09 16:59:49 +08004133 old_mon = cur_mon;
4134 cur_mon = mon;
4135
Markus Armbruster674ed722018-07-03 10:53:37 +02004136 rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004137
Peter Xu227a0752018-03-09 16:59:49 +08004138 cur_mon = old_mon;
4139
Markus Armbruster69240fe2018-07-03 10:53:43 +02004140 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
4141 error = qdict_get_qdict(qobject_to(QDict, rsp), "error");
4142 if (error
4143 && !g_strcmp0(qdict_get_try_str(error, "class"),
4144 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
4145 /* Provide a more useful error message */
4146 qdict_del(error, "desc");
4147 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
4148 " with 'qmp_capabilities'");
4149 }
4150 }
4151
4152 /* Respond if necessary */
Markus Armbruster05f72742018-07-03 10:53:40 +02004153 monitor_qmp_respond(mon, rsp, NULL, qobject_ref(id));
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004154}
4155
Peter Xu71da4662018-03-09 16:59:57 +08004156/*
4157 * Pop one QMP request from monitor queues, return NULL if not found.
4158 * We are using round-robin fashion to pop the request, to avoid
4159 * processing commands only on a very busy monitor. To achieve that,
4160 * when we process one request on a specific monitor, we put that
4161 * monitor to the end of mon_list queue.
4162 */
Peter Xu40687eb2018-06-20 15:32:18 +08004163static QMPRequest *monitor_qmp_requests_pop_any(void)
Peter Xu71da4662018-03-09 16:59:57 +08004164{
4165 QMPRequest *req_obj = NULL;
4166 Monitor *mon;
4167
4168 qemu_mutex_lock(&monitor_lock);
4169
4170 QTAILQ_FOREACH(mon, &mon_list, entry) {
4171 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4172 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4173 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4174 if (req_obj) {
4175 break;
4176 }
4177 }
4178
4179 if (req_obj) {
4180 /*
4181 * We found one request on the monitor. Degrade this monitor's
4182 * priority to lowest by re-inserting it to end of queue.
4183 */
4184 QTAILQ_REMOVE(&mon_list, mon, entry);
4185 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4186 }
4187
4188 qemu_mutex_unlock(&monitor_lock);
4189
4190 return req_obj;
4191}
4192
4193static void monitor_qmp_bh_dispatcher(void *data)
4194{
Peter Xu40687eb2018-06-20 15:32:18 +08004195 QMPRequest *req_obj = monitor_qmp_requests_pop_any();
Peter Xu71da4662018-03-09 16:59:57 +08004196
Markus Armbrusterb2731452018-07-03 10:53:41 +02004197 if (!req_obj) {
4198 return;
Peter Xu71da4662018-03-09 16:59:57 +08004199 }
Markus Armbrusterb2731452018-07-03 10:53:41 +02004200
Markus Armbruster1cc37472018-07-03 10:53:44 +02004201 if (req_obj->req) {
4202 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4203 monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
4204 } else {
4205 assert(req_obj->err);
4206 monitor_qmp_respond(req_obj->mon, NULL, req_obj->err, NULL);
4207 }
4208
Markus Armbrusterb2731452018-07-03 10:53:41 +02004209 if (req_obj->need_resume) {
4210 /* Pairs with the monitor_suspend() in handle_qmp_command() */
4211 monitor_resume(req_obj->mon);
4212 }
4213 qmp_request_free(req_obj);
4214
4215 /* Reschedule instead of looping so the main loop stays responsive */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004216 qemu_bh_schedule(qmp_dispatcher_bh);
Peter Xu71da4662018-03-09 16:59:57 +08004217}
4218
Peter Xubf1e7302018-03-09 16:59:59 +08004219#define QMP_REQ_QUEUE_LEN_MAX (8)
4220
Peter Xu71da4662018-03-09 16:59:57 +08004221static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
4222{
4223 QObject *req, *id = NULL;
Markus Armbruster0fa39d02018-07-03 10:53:35 +02004224 QDict *qdict;
Peter Xu71da4662018-03-09 16:59:57 +08004225 MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
4226 Monitor *mon = container_of(mon_qmp, Monitor, qmp);
4227 Error *err = NULL;
4228 QMPRequest *req_obj;
4229
4230 req = json_parser_parse_err(tokens, NULL, &err);
4231 if (!req && !err) {
4232 /* json_parser_parse_err() sucks: can fail without setting @err */
4233 error_setg(&err, QERR_JSON_PARSING);
4234 }
Peter Xu71da4662018-03-09 16:59:57 +08004235
Markus Armbruster0fa39d02018-07-03 10:53:35 +02004236 qdict = qobject_to(QDict, req);
4237 if (qdict) {
4238 id = qobject_ref(qdict_get(qdict, "id"));
4239 qdict_del(qdict, "id");
4240 } /* else will fail qmp_dispatch() */
4241
Markus Armbruster45434ba2018-07-03 10:53:39 +02004242 if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4243 QString *req_json = qobject_to_json(req);
4244 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4245 qobject_unref(req_json);
4246 }
4247
Markus Armbruster69240fe2018-07-03 10:53:43 +02004248 if (qdict && qmp_is_oob(qdict)) {
Markus Armbrusterb2731452018-07-03 10:53:41 +02004249 /* Out-of-band (OOB) requests are executed directly in parser. */
4250 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id)
4251 ?: "");
4252 monitor_qmp_dispatch(mon, req, id);
4253 return;
4254 }
4255
Peter Xu71da4662018-03-09 16:59:57 +08004256 req_obj = g_new0(QMPRequest, 1);
4257 req_obj->mon = mon;
Markus Armbruster0fa39d02018-07-03 10:53:35 +02004258 req_obj->id = id;
Peter Xu71da4662018-03-09 16:59:57 +08004259 req_obj->req = req;
Markus Armbruster1cc37472018-07-03 10:53:44 +02004260 req_obj->err = err;
Peter Xu71da4662018-03-09 16:59:57 +08004261 req_obj->need_resume = false;
4262
Peter Xubf1e7302018-03-09 16:59:59 +08004263 /* Protect qmp_requests and fetching its length. */
4264 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4265
Peter Xu71da4662018-03-09 16:59:57 +08004266 /*
4267 * If OOB is not enabled on the current monitor, we'll emulate the
4268 * old behavior that we won't process the current monitor any more
4269 * until it has responded. This helps make sure that as long as
4270 * OOB is not enabled, the server will never drop any command.
4271 */
4272 if (!qmp_oob_enabled(mon)) {
4273 monitor_suspend(mon);
4274 req_obj->need_resume = true;
Peter Xubf1e7302018-03-09 16:59:59 +08004275 } else {
4276 /* Drop the request if queue is full. */
4277 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4278 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
Markus Armbrusterd621cfe2018-07-03 10:53:30 +02004279 /*
4280 * FIXME @id's scope is just @mon, and broadcasting it is
4281 * wrong. If another monitor's client has a command with
4282 * the same ID in flight, the event will incorrectly claim
4283 * that command was dropped.
4284 */
Peter Xubf1e7302018-03-09 16:59:59 +08004285 qapi_event_send_command_dropped(id,
4286 COMMAND_DROP_REASON_QUEUE_FULL,
4287 &error_abort);
Peter Xu6d2d5632018-03-26 14:38:55 +08004288 qmp_request_free(req_obj);
Peter Xubf1e7302018-03-09 16:59:59 +08004289 return;
4290 }
Peter Xu71da4662018-03-09 16:59:57 +08004291 }
4292
4293 /*
4294 * Put the request to the end of queue so that requests will be
4295 * handled in time order. Ownership for req_obj, req, id,
4296 * etc. will be delivered to the handler side.
4297 */
Peter Xu71da4662018-03-09 16:59:57 +08004298 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4299 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4300
4301 /* Kick the dispatcher routine */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004302 qemu_bh_schedule(qmp_dispatcher_bh);
Peter Xu71da4662018-03-09 16:59:57 +08004303}
4304
Markus Armbrusterc83fe232015-03-06 19:20:51 +01004305static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004306{
Peter Xu227a0752018-03-09 16:59:49 +08004307 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004308
Peter Xu227a0752018-03-09 16:59:49 +08004309 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004310}
4311
aliguori731b0362009-03-05 23:01:42 +00004312static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004313{
aliguori731b0362009-03-05 23:01:42 +00004314 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004315 int i;
aliguori376253e2009-03-05 23:01:23 +00004316
aliguori731b0362009-03-05 23:01:42 +00004317 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004318
aliguoricde76ee2009-03-05 23:01:51 +00004319 if (cur_mon->rs) {
4320 for (i = 0; i < size; i++)
4321 readline_handle_byte(cur_mon->rs, buf[i]);
4322 } else {
4323 if (size == 0 || buf[size - 1] != 0)
4324 monitor_printf(cur_mon, "corrupted command\n");
4325 else
Markus Armbruster7ef6cf62015-03-06 19:12:36 +01004326 handle_hmp_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004327 }
aliguori731b0362009-03-05 23:01:42 +00004328
4329 cur_mon = old_mon;
4330}
aliguorid8f44602008-10-06 13:52:44 +00004331
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004332static void monitor_command_cb(void *opaque, const char *cmdline,
4333 void *readline_opaque)
bellard7e2515e2004-08-01 21:52:19 +00004334{
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004335 Monitor *mon = opaque;
4336
aliguori731b0362009-03-05 23:01:42 +00004337 monitor_suspend(mon);
Markus Armbruster7ef6cf62015-03-06 19:12:36 +01004338 handle_hmp_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004339 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004340}
4341
aliguoricde76ee2009-03-05 23:01:51 +00004342int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004343{
Peter Xue3e977d2018-03-09 16:59:56 +08004344 if (monitor_is_hmp_non_interactive(mon)) {
aliguoricde76ee2009-03-05 23:01:51 +00004345 return -ENOTTY;
Peter Xue3e977d2018-03-09 16:59:56 +08004346 }
4347
Peter Xudf152fb2018-03-09 16:59:55 +08004348 atomic_inc(&mon->suspend_cnt);
Peter Xue3e977d2018-03-09 16:59:56 +08004349
4350 if (monitor_is_qmp(mon)) {
4351 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004352 * Kick I/O thread to make sure this takes effect. It'll be
Peter Xue3e977d2018-03-09 16:59:56 +08004353 * evaluated again in prepare() of the watch object.
4354 */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004355 aio_notify(iothread_get_aio_context(mon_iothread));
Peter Xue3e977d2018-03-09 16:59:56 +08004356 }
4357
4358 trace_monitor_suspend(mon, 1);
aliguoricde76ee2009-03-05 23:01:51 +00004359 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004360}
4361
aliguori376253e2009-03-05 23:01:23 +00004362void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004363{
Peter Xue3e977d2018-03-09 16:59:56 +08004364 if (monitor_is_hmp_non_interactive(mon)) {
aliguoricde76ee2009-03-05 23:01:51 +00004365 return;
Peter Xudf152fb2018-03-09 16:59:55 +08004366 }
Peter Xue3e977d2018-03-09 16:59:56 +08004367
4368 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4369 if (monitor_is_qmp(mon)) {
4370 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004371 * For QMP monitors that are running in I/O thread, let's
Peter Xue3e977d2018-03-09 16:59:56 +08004372 * kick the thread in case it's sleeping.
4373 */
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02004374 if (mon->use_io_thread) {
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004375 aio_notify(iothread_get_aio_context(mon_iothread));
Peter Xue3e977d2018-03-09 16:59:56 +08004376 }
4377 } else {
4378 assert(mon->rs);
4379 readline_show_prompt(mon->rs);
4380 }
4381 }
4382 trace_monitor_suspend(mon, -1);
bellard7e2515e2004-08-01 21:52:19 +00004383}
4384
Peter Xu02130312018-03-09 16:59:53 +08004385static QObject *get_qmp_greeting(Monitor *mon)
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004386{
Peter Xu02130312018-03-09 16:59:53 +08004387 QList *cap_list = qlist_new();
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004388 QObject *ver = NULL;
Peter Xu02130312018-03-09 16:59:53 +08004389 QMPCapability cap;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004390
Markus Armbruster7fad30f2015-09-16 13:06:19 +02004391 qmp_marshal_query_version(NULL, &ver, NULL);
Marc-André Lureauc8235012016-09-12 13:19:04 +04004392
Peter Xu02130312018-03-09 16:59:53 +08004393 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02004394 if (!mon->use_io_thread && cap == QMP_CAPABILITY_OOB) {
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004395 /* Monitors that are not using I/O thread won't support OOB */
Peter Xu02130312018-03-09 16:59:53 +08004396 continue;
4397 }
Laurent Vivier625eaca2018-03-23 15:32:01 +01004398 qlist_append_str(cap_list, QMPCapability_str(cap));
Peter Xu02130312018-03-09 16:59:53 +08004399 }
4400
4401 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
4402 ver, cap_list);
4403}
4404
4405static void monitor_qmp_caps_reset(Monitor *mon)
4406{
4407 memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004408}
4409
Markus Armbrusterc83fe232015-03-06 19:20:51 +01004410static void monitor_qmp_event(void *opaque, int event)
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004411{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004412 QObject *data;
4413 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004414
Luiz Capitulino47116d12010-02-08 17:01:30 -02004415 switch (event) {
4416 case CHR_EVENT_OPENED:
Markus Armbruster635db182017-03-03 13:32:27 +01004417 mon->qmp.commands = &qmp_cap_negotiation_commands;
Peter Xu02130312018-03-09 16:59:53 +08004418 monitor_qmp_caps_reset(mon);
4419 data = get_qmp_greeting(mon);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004420 monitor_json_emitter(mon, data);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02004421 qobject_unref(data);
Corey Bryantefb87c12012-08-14 16:43:48 -04004422 mon_refcount++;
Luiz Capitulino47116d12010-02-08 17:01:30 -02004423 break;
4424 case CHR_EVENT_CLOSED:
Peter Xuc73a8432018-06-20 15:32:19 +08004425 /*
4426 * Note: this is only useful when the output of the chardev
4427 * backend is still open. For example, when the backend is
4428 * stdio, it's possible that stdout is still open when stdin
4429 * is closed.
4430 */
4431 monitor_qmp_response_flush(mon);
Peter Xu6d2d5632018-03-26 14:38:55 +08004432 monitor_qmp_cleanup_queues(mon);
Markus Armbruster74358f22015-03-06 19:35:59 +01004433 json_message_parser_destroy(&mon->qmp.parser);
4434 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
Corey Bryantefb87c12012-08-14 16:43:48 -04004435 mon_refcount--;
4436 monitor_fdsets_cleanup();
Luiz Capitulino47116d12010-02-08 17:01:30 -02004437 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004438 }
4439}
4440
aliguori731b0362009-03-05 23:01:42 +00004441static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004442{
aliguori376253e2009-03-05 23:01:23 +00004443 Monitor *mon = opaque;
4444
aliguori2724b182009-03-05 23:01:47 +00004445 switch (event) {
4446 case CHR_EVENT_MUX_IN:
Peter Xudc7cbcd2018-06-08 11:55:05 +08004447 qemu_mutex_lock(&mon->mon_lock);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004448 mon->mux_out = 0;
Peter Xudc7cbcd2018-06-08 11:55:05 +08004449 qemu_mutex_unlock(&mon->mon_lock);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004450 if (mon->reset_seen) {
4451 readline_restart(mon->rs);
4452 monitor_resume(mon);
4453 monitor_flush(mon);
4454 } else {
Peter Xudf152fb2018-03-09 16:59:55 +08004455 atomic_mb_set(&mon->suspend_cnt, 0);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004456 }
aliguori2724b182009-03-05 23:01:47 +00004457 break;
ths86e94de2007-01-05 22:01:59 +00004458
aliguori2724b182009-03-05 23:01:47 +00004459 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004460 if (mon->reset_seen) {
Peter Xudf152fb2018-03-09 16:59:55 +08004461 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004462 monitor_printf(mon, "\n");
4463 }
4464 monitor_flush(mon);
4465 monitor_suspend(mon);
4466 } else {
Peter Xudf152fb2018-03-09 16:59:55 +08004467 atomic_inc(&mon->suspend_cnt);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004468 }
Peter Xudc7cbcd2018-06-08 11:55:05 +08004469 qemu_mutex_lock(&mon->mon_lock);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004470 mon->mux_out = 1;
Peter Xudc7cbcd2018-06-08 11:55:05 +08004471 qemu_mutex_unlock(&mon->mon_lock);
aliguori2724b182009-03-05 23:01:47 +00004472 break;
4473
Amit Shahb6b8df52009-10-07 18:31:16 +05304474 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004475 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4476 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004477 if (!mon->mux_out) {
Stratos Psomadakise5554e22014-09-15 15:34:57 +03004478 readline_restart(mon->rs);
aliguori2724b182009-03-05 23:01:47 +00004479 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004480 }
4481 mon->reset_seen = 1;
Corey Bryantefb87c12012-08-14 16:43:48 -04004482 mon_refcount++;
4483 break;
4484
4485 case CHR_EVENT_CLOSED:
4486 mon_refcount--;
4487 monitor_fdsets_cleanup();
aliguori2724b182009-03-05 23:01:47 +00004488 break;
4489 }
ths86e94de2007-01-05 22:01:59 +00004490}
4491
Wayne Xia816f8922011-10-12 11:32:41 +08004492static int
4493compare_mon_cmd(const void *a, const void *b)
4494{
4495 return strcmp(((const mon_cmd_t *)a)->name,
4496 ((const mon_cmd_t *)b)->name);
4497}
4498
4499static void sortcmdlist(void)
4500{
4501 int array_num;
4502 int elem_size = sizeof(mon_cmd_t);
4503
4504 array_num = sizeof(mon_cmds)/elem_size-1;
4505 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4506
4507 array_num = sizeof(info_cmds)/elem_size-1;
4508 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4509}
4510
Peter Xua5ed3522018-03-09 16:59:52 +08004511static GMainContext *monitor_get_io_context(void)
4512{
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004513 return iothread_get_g_main_context(mon_iothread);
Peter Xua5ed3522018-03-09 16:59:52 +08004514}
4515
4516static AioContext *monitor_get_aio_context(void)
4517{
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004518 return iothread_get_aio_context(mon_iothread);
Peter Xua5ed3522018-03-09 16:59:52 +08004519}
4520
4521static void monitor_iothread_init(void)
4522{
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004523 mon_iothread = iothread_create("mon_iothread", &error_abort);
Peter Xu71da4662018-03-09 16:59:57 +08004524
4525 /*
4526 * This MUST be on main loop thread since we have commands that
4527 * have assumption to be run on main loop thread. It would be
4528 * nice that one day we can remove this assumption in the future.
4529 */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004530 qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4531 monitor_qmp_bh_dispatcher,
4532 NULL);
Peter Xuabe3cd02018-03-09 17:00:02 +08004533
4534 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004535 * Unlike the dispatcher BH, this must be run on the monitor I/O
4536 * thread, so that monitors that are using I/O thread will make
4537 * sure read/write operations are all done on the I/O thread.
Peter Xuabe3cd02018-03-09 17:00:02 +08004538 */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004539 qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4540 monitor_qmp_bh_responder,
4541 NULL);
Peter Xua5ed3522018-03-09 16:59:52 +08004542}
4543
Peter Xu6adf08d2018-03-09 16:59:50 +08004544void monitor_init_globals(void)
4545{
4546 monitor_init_qmp_commands();
4547 monitor_qapi_event_init();
4548 sortcmdlist();
4549 qemu_mutex_init(&monitor_lock);
Peter Xu47451462018-06-08 11:55:11 +08004550 qemu_mutex_init(&mon_fdsets_lock);
Peter Xua5ed3522018-03-09 16:59:52 +08004551 monitor_iothread_init();
Peter Xu6adf08d2018-03-09 16:59:50 +08004552}
4553
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004554/* These functions just adapt the readline interface in a typesafe way. We
4555 * could cast function pointers but that discards compiler checks.
4556 */
Stefan Weild5d15072014-01-25 18:18:23 +01004557static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4558 const char *fmt, ...)
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004559{
4560 va_list ap;
4561 va_start(ap, fmt);
4562 monitor_vprintf(opaque, fmt, ap);
4563 va_end(ap);
4564}
4565
4566static void monitor_readline_flush(void *opaque)
4567{
4568 monitor_flush(opaque);
4569}
4570
Paolo Bonzini397d30e2016-10-24 18:31:02 +02004571/*
4572 * Print to current monitor if we have one, else to stderr.
4573 * TODO should return int, so callers can calculate width, but that
4574 * requires surgery to monitor_vprintf(). Left for another day.
4575 */
4576void error_vprintf(const char *fmt, va_list ap)
4577{
4578 if (cur_mon && !monitor_cur_is_qmp()) {
4579 monitor_vprintf(cur_mon, fmt, ap);
4580 } else {
4581 vfprintf(stderr, fmt, ap);
4582 }
4583}
4584
4585void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4586{
4587 if (cur_mon && !monitor_cur_is_qmp()) {
4588 monitor_vprintf(cur_mon, fmt, ap);
Marc-André Lureau0d6b50d2017-01-05 14:59:57 +01004589 } else if (!cur_mon) {
4590 vfprintf(stderr, fmt, ap);
Paolo Bonzini397d30e2016-10-24 18:31:02 +02004591 }
4592}
4593
Peter Xua5ed3522018-03-09 16:59:52 +08004594static void monitor_list_append(Monitor *mon)
4595{
4596 qemu_mutex_lock(&monitor_lock);
4597 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4598 qemu_mutex_unlock(&monitor_lock);
4599}
4600
4601static void monitor_qmp_setup_handlers_bh(void *opaque)
4602{
4603 Monitor *mon = opaque;
4604 GMainContext *context;
4605
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02004606 if (mon->use_io_thread) {
Peter Xua5ed3522018-03-09 16:59:52 +08004607 /*
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02004608 * When @use_io_thread is set, we use the global shared dedicated
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004609 * I/O thread for this monitor to handle input/output.
Peter Xua5ed3522018-03-09 16:59:52 +08004610 */
4611 context = monitor_get_io_context();
4612 /* We should have inited globals before reaching here. */
4613 assert(context);
4614 } else {
4615 /* The default main loop, which is the main thread */
4616 context = NULL;
4617 }
4618
4619 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4620 monitor_qmp_event, NULL, mon, context, true);
4621 monitor_list_append(mon);
4622}
4623
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03004624void monitor_init(Chardev *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004625{
Peter Xu6adf08d2018-03-09 16:59:50 +08004626 Monitor *mon = g_malloc(sizeof(*mon));
Peter Xube933ff2018-03-26 14:38:56 +08004627 bool use_readline = flags & MONITOR_USE_READLINE;
4628 bool use_oob = flags & MONITOR_USE_OOB;
ths20d8a3e2007-02-18 17:04:49 +00004629
Peter Xube933ff2018-03-26 14:38:56 +08004630 if (use_oob) {
4631 if (CHARDEV_IS_MUX(chr)) {
Markus Armbrusterc0698212018-07-03 10:53:27 +02004632 error_report("Monitor out-of-band is not supported with "
Peter Xube933ff2018-03-26 14:38:56 +08004633 "MUX typed chardev backend");
4634 exit(1);
4635 }
4636 if (use_readline) {
Markus Armbrusterc0698212018-07-03 10:53:27 +02004637 error_report("Monitor out-of-band is only supported by QMP");
Peter Xube933ff2018-03-26 14:38:56 +08004638 exit(1);
4639 }
4640 }
4641
4642 monitor_data_init(mon, false, use_oob);
ths20d8a3e2007-02-18 17:04:49 +00004643
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03004644 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
aliguori731b0362009-03-05 23:01:42 +00004645 mon->flags = flags;
Peter Xube933ff2018-03-26 14:38:56 +08004646 if (use_readline) {
Stefan Hajnoczic60bf332013-11-14 11:54:14 +01004647 mon->rs = readline_init(monitor_readline_printf,
4648 monitor_readline_flush,
4649 mon,
4650 monitor_find_completion);
aliguoricde76ee2009-03-05 23:01:51 +00004651 monitor_read_command(mon, 0);
4652 }
aliguori87127162009-03-05 23:01:29 +00004653
Markus Armbruster9f3982f2015-03-06 19:56:38 +01004654 if (monitor_is_qmp(mon)) {
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03004655 qemu_chr_fe_set_echo(&mon->chr, true);
Markus Armbruster74358f22015-03-06 19:35:59 +01004656 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
Markus Armbrusterf91dc2a2018-07-03 10:53:45 +02004657 if (mon->use_io_thread) {
Peter Xua5ed3522018-03-09 16:59:52 +08004658 /*
4659 * Make sure the old iowatch is gone. It's possible when
4660 * e.g. the chardev is in client mode, with wait=on.
4661 */
4662 remove_fd_in_watch(chr);
4663 /*
4664 * We can't call qemu_chr_fe_set_handlers() directly here
4665 * since during the procedure the chardev will be active
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004666 * and running in monitor I/O thread, while we'll still do
Peter Xua5ed3522018-03-09 16:59:52 +08004667 * something before returning from it, which is a possible
4668 * race too. To avoid that, we just create a BH to setup
4669 * the handlers.
4670 */
4671 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4672 monitor_qmp_setup_handlers_bh, mon);
4673 /* We'll add this to mon_list in the BH when setup done */
4674 return;
4675 } else {
4676 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4677 monitor_qmp_read, monitor_qmp_event,
4678 NULL, mon, NULL, true);
4679 }
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004680 } else {
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03004681 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
Anton Nefedov81517ba2017-07-06 15:08:49 +03004682 monitor_event, NULL, mon, NULL, true);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004683 }
aliguori87127162009-03-05 23:01:29 +00004684
Peter Xua5ed3522018-03-09 16:59:52 +08004685 monitor_list_append(mon);
bellard7e2515e2004-08-01 21:52:19 +00004686}
4687
Marc-André Lureau2ef45712016-08-01 15:23:42 +04004688void monitor_cleanup(void)
4689{
4690 Monitor *mon, *next;
4691
Peter Xua5ed3522018-03-09 16:59:52 +08004692 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004693 * We need to explicitly stop the I/O thread (but not destroy it),
4694 * cleanup the monitor resources, then destroy the I/O thread since
Peter Xua5ed3522018-03-09 16:59:52 +08004695 * we need to unregister from chardev below in
4696 * monitor_data_destroy(), and chardev is not thread-safe yet
4697 */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004698 iothread_stop(mon_iothread);
Peter Xua5ed3522018-03-09 16:59:52 +08004699
Peter Xuabe3cd02018-03-09 17:00:02 +08004700 /*
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004701 * After we have I/O thread to send responses, it's possible that
4702 * when we stop the I/O thread there are still replies queued in the
Peter Xuabe3cd02018-03-09 17:00:02 +08004703 * responder queue. Flush all of them. Note that even after this
4704 * flush it's still possible that out buffer is not flushed.
4705 * It'll be done in below monitor_flush() as the last resort.
4706 */
4707 monitor_qmp_bh_responder(NULL);
4708
Marc-André Lureau2ef45712016-08-01 15:23:42 +04004709 qemu_mutex_lock(&monitor_lock);
Peter Xu238d9f32018-03-09 16:59:51 +08004710 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4711 QTAILQ_REMOVE(&mon_list, mon, entry);
Peter Xuabe3cd02018-03-09 17:00:02 +08004712 monitor_flush(mon);
Marc-André Lureau2ef45712016-08-01 15:23:42 +04004713 monitor_data_destroy(mon);
4714 g_free(mon);
4715 }
4716 qemu_mutex_unlock(&monitor_lock);
Peter Xua5ed3522018-03-09 16:59:52 +08004717
Markus Armbrusterc5f57ed2018-07-03 10:53:28 +02004718 /* QEMUBHs needs to be deleted before destroying the I/O thread */
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004719 qemu_bh_delete(qmp_dispatcher_bh);
4720 qmp_dispatcher_bh = NULL;
4721 qemu_bh_delete(qmp_respond_bh);
4722 qmp_respond_bh = NULL;
Peter Xu71da4662018-03-09 16:59:57 +08004723
Markus Armbrustercab5ad82018-07-03 10:53:46 +02004724 iothread_destroy(mon_iothread);
4725 mon_iothread = NULL;
Marc-André Lureau2ef45712016-08-01 15:23:42 +04004726}
4727
Paolo Bonzini4d454572012-11-26 16:03:42 +01004728QemuOptsList qemu_mon_opts = {
4729 .name = "mon",
4730 .implied_opt_name = "chardev",
4731 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4732 .desc = {
4733 {
4734 .name = "mode",
4735 .type = QEMU_OPT_STRING,
4736 },{
4737 .name = "chardev",
4738 .type = QEMU_OPT_STRING,
4739 },{
Paolo Bonzini4d454572012-11-26 16:03:42 +01004740 .name = "pretty",
4741 .type = QEMU_OPT_BOOL,
Peter Xube933ff2018-03-26 14:38:56 +08004742 },{
4743 .name = "x-oob",
4744 .type = QEMU_OPT_BOOL,
Paolo Bonzini4d454572012-11-26 16:03:42 +01004745 },
4746 { /* end of list */ }
4747 },
4748};
Marcelo Tosattif2ae8ab2014-06-24 18:55:11 -03004749
4750#ifndef TARGET_I386
4751void qmp_rtc_reset_reinjection(Error **errp)
4752{
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01004753 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
Marcelo Tosattif2ae8ab2014-06-24 18:55:11 -03004754}
Brijesh Singh08a161f2018-03-08 06:48:42 -06004755
4756SevInfo *qmp_query_sev(Error **errp)
4757{
4758 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4759 return NULL;
4760}
Brijesh Singh1b6a0342018-03-08 06:48:56 -06004761
4762SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4763{
4764 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4765 return NULL;
4766}
Brijesh Singh31dd67f2018-03-08 06:48:59 -06004767
4768SevCapability *qmp_query_sev_capabilities(Error **errp)
4769{
4770 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4771 return NULL;
4772}
Marcelo Tosattif2ae8ab2014-06-24 18:55:11 -03004773#endif
Jason J. Herne7ee0c3e2015-06-26 14:03:16 -04004774
4775#ifndef TARGET_S390X
4776void qmp_dump_skeys(const char *filename, Error **errp)
4777{
4778 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4779}
4780#endif
Peter Xuae50a772016-03-30 17:27:24 +01004781
4782#ifndef TARGET_ARM
4783GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4784{
4785 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4786 return NULL;
4787}
4788#endif
Igor Mammedovd4633542016-06-10 06:29:06 +05304789
4790HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4791{
4792 MachineState *ms = MACHINE(qdev_get_machine());
4793 MachineClass *mc = MACHINE_GET_CLASS(ms);
4794
Igor Mammedovc5514d02017-02-10 11:20:57 +01004795 if (!mc->has_hotpluggable_cpus) {
Igor Mammedovd4633542016-06-10 06:29:06 +05304796 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4797 return NULL;
4798 }
4799
Igor Mammedovc5514d02017-02-10 11:20:57 +01004800 return machine_query_hotpluggable_cpus(ms);
Igor Mammedovd4633542016-06-10 06:29:06 +05304801}