blob: c2d227a07ce4c9ac7808d6649bea16b22cf80efe [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"
Kevin Wolf5bce3082019-06-13 17:33:59 +020026#include "monitor-internal.h"
Paolo Bonzinib4a42f82013-02-04 11:37:52 +010027#include "monitor/qdev.h"
pbrook87ecb682007-11-17 17:14:51 +000028#include "hw/usb.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020029#include "hw/pci/pci.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010030#include "sysemu/watchdog.h"
Gerd Hoffmann45a50b12009-10-01 16:42:33 +020031#include "hw/loader.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010032#include "exec/gdbstub.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020033#include "net/net.h"
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000034#include "net/slirp.h"
Gerd Hoffmann75721502010-10-07 12:22:54 +020035#include "ui/qemu-spice.h"
Marc-André Lureau213dcb02016-12-12 20:22:24 +030036#include "qemu/config-file.h"
Markus Armbruster856dfd82019-05-23 16:35:06 +020037#include "qemu/ctype.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010038#include "ui/console.h"
Gerd Hoffmannc751a742013-12-04 15:02:28 +010039#include "ui/input.h"
pbrook87ecb682007-11-17 17:14:51 +000040#include "audio/audio.h"
Paolo Bonzini76cad712012-10-24 11:12:21 +020041#include "disas/disas.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010042#include "sysemu/balloon.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010043#include "qemu/timer.h"
Vincent Palatinb3946622017-01-10 11:59:55 +010044#include "sysemu/hw_accel.h"
Markus Armbruster54d31232019-08-12 07:23:59 +020045#include "sysemu/runstate.h"
Daniel P. Berrangeb76806d2016-02-18 18:40:24 +000046#include "authz/list.h"
47#include "qapi/util.h"
Markus Armbruster55225c82019-06-19 22:10:44 +020048#include "sysemu/blockdev.h"
49#include "sysemu/sysemu.h"
Markus Armbruster14a48c12019-05-23 16:35:05 +020050#include "sysemu/tcg.h"
Paolo Bonzinibdee56f2013-04-02 18:28:41 +020051#include "sysemu/tpm.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010052#include "qapi/qmp/qdict.h"
Markus Armbrustercc7a8ea2015-03-17 17:22:46 +010053#include "qapi/qmp/qerror.h"
Markus Armbrusterfc81fa12018-02-01 12:18:40 +010054#include "qapi/qmp/qstring.h"
Markus Armbrustera9c94272016-06-22 19:11:19 +020055#include "qom/object_interfaces.h"
Lluís31965ae2011-08-31 20:31:24 +020056#include "trace/control.h"
Pavel Butsykinbf957282015-09-10 18:38:59 +030057#include "monitor/hmp-target.h"
Markus Armbruster275307a2019-06-19 22:10:36 +020058#include "monitor/hmp.h"
Lluís6d8a7642011-08-31 20:30:43 +020059#ifdef CONFIG_TRACE_SIMPLE
Lluís31965ae2011-08-31 20:31:24 +020060#include "trace/simple.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053061#endif
Paolo Bonzini022c62c2012-12-17 18:19:49 +010062#include "exec/memory.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010063#include "exec/exec-all.h"
Markus Armbruster922a01a2018-02-01 12:18:46 +010064#include "qemu/option.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010065#include "qemu/thread.h"
Hani Benhabilesb21631f2014-05-27 23:39:37 +010066#include "block/qapi.h"
Maxim Levitskya2dde2f2020-03-08 11:24:32 +020067#include "block/block-hmp-cmds.h"
Markus Armbruster00ca24f2019-11-20 19:25:48 +010068#include "qapi/qapi-commands-char.h"
Kevin Wolffa4dcf52020-01-29 11:22:37 +010069#include "qapi/qapi-commands-control.h"
Markus Armbruster00ca24f2019-11-20 19:25:48 +010070#include "qapi/qapi-commands-migration.h"
71#include "qapi/qapi-commands-misc.h"
72#include "qapi/qapi-commands-qom.h"
73#include "qapi/qapi-commands-trace.h"
Markus Armbruster00ca24f2019-11-20 19:25:48 +010074#include "qapi/qapi-init-commands.h"
Markus Armbrustere688df62018-02-01 12:18:31 +010075#include "qapi/error.h"
Wenchao Xia43a14cf2014-06-18 08:43:31 +020076#include "qapi/qmp-event.h"
Paolo Bonzinid2528bd2017-03-03 12:01:16 +010077#include "sysemu/cpus.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020078#include "qemu/cutils.h"
ths6a5bd302007-12-03 17:05:38 +000079
Jason J. Hernea4538a52015-06-26 14:07:21 -040080#if defined(TARGET_S390X)
81#include "hw/s390x/storage-keys.h"
Claudio Imbrendaf860d492016-08-15 18:44:04 +020082#include "hw/s390x/storage-attributes.h"
Jason J. Hernea4538a52015-06-26 14:07:21 -040083#endif
84
Mark McLoughlinf07918f2009-07-22 09:11:40 +010085/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -050086typedef struct mon_fd_t mon_fd_t;
87struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +010088 char *name;
89 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -050090 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +010091};
92
Corey Bryantba1c0482012-08-14 16:43:43 -040093/* file descriptor associated with a file descriptor set */
94typedef struct MonFdsetFd MonFdsetFd;
95struct MonFdsetFd {
96 int fd;
97 bool removed;
98 char *opaque;
99 QLIST_ENTRY(MonFdsetFd) next;
100};
101
102/* file descriptor set containing fds passed via SCM_RIGHTS */
103typedef struct MonFdset MonFdset;
104struct MonFdset {
105 int64_t id;
106 QLIST_HEAD(, MonFdsetFd) fds;
Corey Bryantadb696f2012-08-14 16:43:47 -0400107 QLIST_HEAD(, MonFdsetFd) dup_fds;
Corey Bryantba1c0482012-08-14 16:43:43 -0400108 QLIST_ENTRY(MonFdset) next;
109};
110
Peter Xu47451462018-06-08 11:55:11 +0800111/* Protects mon_fdsets */
112static QemuMutex mon_fdsets_lock;
Paolo Bonzinib58deb32018-12-06 11:58:10 +0100113static QLIST_HEAD(, MonFdset) mon_fdsets;
Peter Xu47451462018-06-08 11:55:11 +0800114
Kevin Wolfa0cd5e12019-06-13 17:33:56 +0200115static HMPCommand hmp_info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000116
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200117char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
118 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200119{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200120 char *output = NULL;
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200121 MonitorHMP hmp = {};
Luiz Capitulino0268d972010-10-22 10:08:02 -0200122
Kevin Wolf92082412019-06-13 17:34:03 +0200123 monitor_data_init(&hmp.common, false, true, false);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200124
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200125 if (has_cpu_index) {
Kevin Wolfdcba65f2020-10-05 17:58:42 +0200126 int ret = monitor_set_cpu(&hmp.common, cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200127 if (ret < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100128 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
129 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200130 goto out;
131 }
132 }
133
Markus Armbruster7ef6cf62015-03-06 19:12:36 +0100134 handle_hmp_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200135
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +0100136 WITH_QEMU_LOCK_GUARD(&hmp.common.mon_lock) {
Markus Armbruster20076f42020-12-11 18:11:34 +0100137 output = g_strdup(hmp.common.outbuf->str);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200138 }
139
140out:
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200141 monitor_data_destroy(&hmp.common);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200142 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200143}
144
Kevin Wolfed7bda52019-06-13 17:34:01 +0200145/**
146 * Is @name in the '|' separated list of names @list?
147 */
148int hmp_compare_cmd(const char *name, const char *list)
bellard9dc39cb2004-03-14 21:38:27 +0000149{
150 const char *p, *pstart;
151 int len;
152 len = strlen(name);
153 p = list;
Kevin Wolfed7bda52019-06-13 17:34:01 +0200154 for (;;) {
bellard9dc39cb2004-03-14 21:38:27 +0000155 pstart = p;
Keno Fischer5c99fa32018-06-29 12:32:10 +0200156 p = qemu_strchrnul(p, '|');
Kevin Wolfed7bda52019-06-13 17:34:01 +0200157 if ((p - pstart) == len && !memcmp(pstart, name, len)) {
bellard9dc39cb2004-03-14 21:38:27 +0000158 return 1;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800159 }
160 if (*p == '\0') {
161 break;
162 }
Kevin Wolfed7bda52019-06-13 17:34:01 +0200163 p++;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800164 }
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800165 return 0;
bellard9dc39cb2004-03-14 21:38:27 +0000166}
167
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300168static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300169{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300170 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300171}
172
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100173static void hmp_trace_event(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530174{
175 const char *tp_name = qdict_get_str(qdict, "name");
176 bool new_state = qdict_get_bool(qdict, "option");
Lluís Vilanova77e2b172016-07-11 12:53:57 +0200177 bool has_vcpu = qdict_haskey(qdict, "vcpu");
178 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
Lluís Vilanova14101d02014-08-25 13:20:03 +0200179 Error *local_err = NULL;
Blue Swirlf871d682010-10-13 19:14:29 +0000180
Lluís Vilanova77e2b172016-07-11 12:53:57 +0200181 if (vcpu < 0) {
182 monitor_printf(mon, "argument vcpu must be positive");
183 return;
184 }
185
186 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
Lluís Vilanova14101d02014-08-25 13:20:03 +0200187 if (local_err) {
Markus Armbruster091e38b2015-02-10 15:15:43 +0100188 error_report_err(local_err);
Blue Swirlf871d682010-10-13 19:14:29 +0000189 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530190}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100191
Michael Rothc45a8162011-10-02 08:44:37 -0500192#ifdef CONFIG_TRACE_SIMPLE
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100193static void hmp_trace_file(Monitor *mon, const QDict *qdict)
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100194{
195 const char *op = qdict_get_try_str(qdict, "op");
196 const char *arg = qdict_get_try_str(qdict, "arg");
197
198 if (!op) {
Markus Armbrusterba4912c2019-04-17 21:17:50 +0200199 st_print_trace_file_status();
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100200 } else if (!strcmp(op, "on")) {
201 st_set_trace_file_enabled(true);
202 } else if (!strcmp(op, "off")) {
203 st_set_trace_file_enabled(false);
204 } else if (!strcmp(op, "flush")) {
205 st_flush_trace_buffer();
206 } else if (!strcmp(op, "set")) {
207 if (arg) {
208 st_set_trace_file(arg);
209 }
210 } else {
211 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
212 help_cmd(mon, "trace-file");
213 }
214}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530215#endif
216
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100217static void hmp_info_help(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000218{
Luiz Capitulino13c74252009-10-07 13:41:55 -0300219 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +0000220}
221
Peter Xu6adf08d2018-03-09 16:59:50 +0800222static void monitor_init_qmp_commands(void)
Marc-André Lureauedcfaef2016-09-12 13:19:00 +0400223{
Markus Armbruster635db182017-03-03 13:32:27 +0100224 /*
225 * Two command lists:
226 * - qmp_commands contains all QMP commands
227 * - qmp_cap_negotiation_commands contains just
228 * "qmp_capabilities", to enforce capability negotiation
229 */
230
Markus Armbruster1527bad2017-03-03 13:32:25 +0100231 qmp_init_marshal(&qmp_commands);
Markus Armbruster05875682017-03-03 13:32:24 +0100232
Markus Armbruster6604e472021-10-28 12:25:17 +0200233 qmp_register_command(&qmp_commands, "device_add",
234 qmp_device_add, 0, 0);
Marc-André Lureau5032a162016-09-12 13:19:02 +0400235
Markus Armbruster635db182017-03-03 13:32:27 +0100236 QTAILQ_INIT(&qmp_cap_negotiation_commands);
237 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
Markus Armbruster6604e472021-10-28 12:25:17 +0200238 qmp_marshal_qmp_capabilities,
239 QCO_ALLOW_PRECONFIG, 0);
Markus Armbruster635db182017-03-03 13:32:27 +0100240}
241
Peter Xud9f25282018-06-08 11:55:07 +0800242/* Set the current CPU defined by the user. Callers must hold BQL. */
Kevin Wolfdcba65f2020-10-05 17:58:42 +0200243int monitor_set_cpu(Monitor *mon, int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000244{
Andreas Färber55e5c282012-12-17 06:18:02 +0100245 CPUState *cpu;
bellard6a00d602005-11-21 23:25:50 +0000246
Andreas Färber1c8bb3c2013-02-15 17:01:09 +0100247 cpu = qemu_get_cpu(cpu_index);
248 if (cpu == NULL) {
249 return -1;
bellard6a00d602005-11-21 23:25:50 +0000250 }
Kevin Wolfdcba65f2020-10-05 17:58:42 +0200251 g_free(mon->mon_cpu_path);
252 mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
Andreas Färber1c8bb3c2013-02-15 17:01:09 +0100253 return 0;
bellard6a00d602005-11-21 23:25:50 +0000254}
255
Peter Xud9f25282018-06-08 11:55:07 +0800256/* Callers must hold BQL. */
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200257static CPUState *mon_get_cpu_sync(Monitor *mon, bool synchronize)
bellard6a00d602005-11-21 23:25:50 +0000258{
Marc-André Lureaua85d0bf2019-10-04 15:18:20 +0400259 CPUState *cpu = NULL;
Greg Kurz751f8cf2017-10-17 10:16:22 +0200260
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200261 if (mon->mon_cpu_path) {
262 cpu = (CPUState *) object_resolve_path_type(mon->mon_cpu_path,
Greg Kurz751f8cf2017-10-17 10:16:22 +0200263 TYPE_CPU, NULL);
264 if (!cpu) {
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200265 g_free(mon->mon_cpu_path);
266 mon->mon_cpu_path = NULL;
Greg Kurz751f8cf2017-10-17 10:16:22 +0200267 }
268 }
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200269 if (!mon->mon_cpu_path) {
Thomas Huth854e67f2017-01-13 13:12:35 +0100270 if (!first_cpu) {
271 return NULL;
272 }
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200273 monitor_set_cpu(mon, first_cpu->cpu_index);
Greg Kurz751f8cf2017-10-17 10:16:22 +0200274 cpu = first_cpu;
bellard6a00d602005-11-21 23:25:50 +0000275 }
Marc-André Lureaua85d0bf2019-10-04 15:18:20 +0400276 assert(cpu != NULL);
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +0100277 if (synchronize) {
278 cpu_synchronize_state(cpu);
279 }
Greg Kurz751f8cf2017-10-17 10:16:22 +0200280 return cpu;
Peter Crosthwaite5bcda5f2015-05-24 14:20:40 -0700281}
282
Kevin Wolf2fc5d012020-11-13 12:43:24 +0100283CPUState *mon_get_cpu(Monitor *mon)
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +0100284{
Kevin Wolf2fc5d012020-11-13 12:43:24 +0100285 return mon_get_cpu_sync(mon, true);
Viktor Mihajlovski137b5cb2018-02-16 17:08:41 +0100286}
287
Kevin Wolfe7cff9c2020-11-13 12:43:26 +0100288CPUArchState *mon_get_cpu_env(Monitor *mon)
Peter Crosthwaite5bcda5f2015-05-24 14:20:40 -0700289{
Kevin Wolfe7cff9c2020-11-13 12:43:26 +0100290 CPUState *cs = mon_get_cpu(mon);
Thomas Huth854e67f2017-01-13 13:12:35 +0100291
292 return cs ? cs->env_ptr : NULL;
bellard6a00d602005-11-21 23:25:50 +0000293}
294
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200295int monitor_get_cpu_index(Monitor *mon)
Luiz Capitulino99b77962011-10-24 10:53:44 -0200296{
Kevin Wolf87e6f4a2020-10-05 17:58:43 +0200297 CPUState *cs = mon_get_cpu_sync(mon, false);
Thomas Huth854e67f2017-01-13 13:12:35 +0100298
299 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
Luiz Capitulino99b77962011-10-24 10:53:44 -0200300}
301
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100302static void hmp_info_registers(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +0000303{
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +1000304 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
305 CPUState *cs;
Thomas Huth854e67f2017-01-13 13:12:35 +0100306
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +1000307 if (all_cpus) {
308 CPU_FOREACH(cs) {
309 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
Markus Armbruster90c84c52019-04-17 21:18:02 +0200310 cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +1000311 }
312 } else {
Kevin Wolf2fc5d012020-11-13 12:43:24 +0100313 cs = mon_get_cpu(mon);
Suraj Jitindar Singh18f08282017-06-08 15:41:16 +1000314
315 if (!cs) {
316 monitor_printf(mon, "No CPU available\n");
317 return;
318 }
319
Markus Armbruster90c84c52019-04-17 21:18:02 +0200320 cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
Thomas Huth854e67f2017-01-13 13:12:35 +0100321 }
bellard9307c4c2004-04-04 12:57:25 +0000322}
323
Emilio G. Cota97bfafe2017-08-08 13:54:42 -0400324static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
325{
326 int64_t max = qdict_get_try_int(qdict, "max", 10);
327 bool mean = qdict_get_try_bool(qdict, "mean", false);
328 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
329 enum QSPSortBy sort_by;
330
331 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
Markus Armbrusterac7ff4c2019-04-17 21:17:54 +0200332 qsp_report(max, sort_by, coalesce);
Emilio G. Cota97bfafe2017-08-08 13:54:42 -0400333}
334
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100335static void hmp_info_history(Monitor *mon, const QDict *qdict)
bellardaa455482004-04-04 13:07:25 +0000336{
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200337 MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
bellardaa455482004-04-04 13:07:25 +0000338 int i;
bellard7e2515e2004-08-01 21:52:19 +0000339 const char *str;
ths3b46e622007-09-17 08:09:54 +0000340
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200341 if (!hmp_mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000342 return;
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200343 }
bellard7e2515e2004-08-01 21:52:19 +0000344 i = 0;
345 for(;;) {
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200346 str = readline_get_history(hmp_mon->rs, i);
347 if (!str) {
bellard7e2515e2004-08-01 21:52:19 +0000348 break;
Kevin Wolf5f9dba12019-06-13 17:33:54 +0200349 }
aliguori376253e2009-03-05 23:01:23 +0000350 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +0000351 i++;
bellardaa455482004-04-04 13:07:25 +0000352 }
353}
354
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100355static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530356{
Lluís Vilanovabd712112016-07-11 12:53:51 +0200357 const char *name = qdict_get_try_str(qdict, "name");
Lluís Vilanova77e2b172016-07-11 12:53:57 +0200358 bool has_vcpu = qdict_haskey(qdict, "vcpu");
359 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
Lluís Vilanovabd712112016-07-11 12:53:51 +0200360 TraceEventInfoList *events;
Lluís Vilanova14101d02014-08-25 13:20:03 +0200361 TraceEventInfoList *elem;
Lluís Vilanovabd712112016-07-11 12:53:51 +0200362 Error *local_err = NULL;
363
364 if (name == NULL) {
365 name = "*";
366 }
Lluís Vilanova77e2b172016-07-11 12:53:57 +0200367 if (vcpu < 0) {
368 monitor_printf(mon, "argument vcpu must be positive");
369 return;
370 }
Lluís Vilanovabd712112016-07-11 12:53:51 +0200371
Lluís Vilanova77e2b172016-07-11 12:53:57 +0200372 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
Lluís Vilanovabd712112016-07-11 12:53:51 +0200373 if (local_err) {
374 error_report_err(local_err);
375 return;
376 }
Lluís Vilanova14101d02014-08-25 13:20:03 +0200377
378 for (elem = events; elem != NULL; elem = elem->next) {
379 monitor_printf(mon, "%s : state %u\n",
380 elem->value->name,
381 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
382 }
383 qapi_free_TraceEventInfoList(events);
Prerna Saxena22890ab2010-06-24 17:04:53 +0530384}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530385
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100386void qmp_client_migrate_info(const char *protocol, const char *hostname,
387 bool has_port, int64_t port,
388 bool has_tls_port, int64_t tls_port,
389 bool has_cert_subject, const char *cert_subject,
390 Error **errp)
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200391{
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200392 if (strcmp(protocol, "spice") == 0) {
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100393 if (!qemu_using_spice(errp)) {
394 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200395 }
396
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100397 if (!has_port && !has_tls_port) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +0100398 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100399 return;
Yonit Halperin6ec5dae2012-03-18 09:42:39 +0200400 }
401
Gerd Hoffmann74774772020-10-19 09:52:12 +0200402 if (qemu_spice.migrate_info(hostname,
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100403 has_port ? port : -1,
404 has_tls_port ? tls_port : -1,
405 cert_subject)) {
Markus Armbruster9e1b9c62020-11-13 09:26:21 +0100406 error_setg(errp, "Could not set up display for migration");
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100407 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200408 }
Markus Armbrusterb8a185b2015-03-05 17:29:02 +0100409 return;
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200410 }
411
Markus Armbruster99750d82020-11-13 09:26:22 +0100412 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "'spice'");
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200413}
414
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100415static void hmp_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +0000416{
Markus Armbrusterdaa76aa2016-06-15 19:27:16 +0200417 Error *err = NULL;
418
419 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
420 if (err) {
421 error_report_err(err);
422 }
pbrooke735b912007-06-30 13:53:24 +0000423}
424
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100425static void hmp_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +0000426{
427 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300428 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +0000429
bellard9307c4c2004-04-04 12:57:25 +0000430 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +0000431 mask = 0;
432 } else {
Peter Maydell4fde1eb2013-02-11 16:41:22 +0000433 mask = qemu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +0000434 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +0000435 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +0000436 return;
437 }
438 }
Peter Maydell24537a02013-02-11 16:41:23 +0000439 qemu_set_log(mask);
bellardf193c792004-03-21 17:06:25 +0000440}
441
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100442static void hmp_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +0000443{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300444 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +0000445 if (!option || !strcmp(option, "on")) {
446 singlestep = 1;
447 } else if (!strcmp(option, "off")) {
448 singlestep = 0;
449 } else {
450 monitor_printf(mon, "unexpected option %s\n", option);
451 }
452}
453
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100454static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +0000455{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300456 const char *device = qdict_get_try_str(qdict, "device");
Yutao Ai89854b92020-11-25 01:45:13 +0000457 if (!device) {
aliguori59030a82009-04-05 18:43:41 +0000458 device = "tcp::" DEFAULT_GDBSTUB_PORT;
Yutao Ai89854b92020-11-25 01:45:13 +0000459 }
460
aliguori59030a82009-04-05 18:43:41 +0000461 if (gdbserver_start(device) < 0) {
462 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
463 device);
464 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +0000465 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +0000466 } else {
aliguori59030a82009-04-05 18:43:41 +0000467 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
468 device);
bellard8a7ddc32004-03-31 19:00:16 +0000469 }
470}
471
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100472static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +0100473{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300474 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +0100475 if (select_watchdog_action(action) == -1) {
476 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
477 }
478}
479
aliguori376253e2009-03-05 23:01:23 +0000480static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +0000481{
aliguori376253e2009-03-05 23:01:23 +0000482 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +0000483 switch(c) {
484 case '\'':
aliguori376253e2009-03-05 23:01:23 +0000485 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +0000486 break;
487 case '\\':
aliguori376253e2009-03-05 23:01:23 +0000488 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +0000489 break;
490 case '\n':
aliguori376253e2009-03-05 23:01:23 +0000491 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +0000492 break;
493 case '\r':
aliguori376253e2009-03-05 23:01:23 +0000494 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +0000495 break;
496 default:
497 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +0000498 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +0000499 } else {
aliguori376253e2009-03-05 23:01:23 +0000500 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +0000501 }
502 break;
503 }
aliguori376253e2009-03-05 23:01:23 +0000504 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +0000505}
506
aliguori376253e2009-03-05 23:01:23 +0000507static void memory_dump(Monitor *mon, int count, int format, int wsize,
Avi Kivitya8170e52012-10-23 12:30:10 +0200508 hwaddr addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +0000509{
Blue Swirl23842aa2010-01-12 20:27:43 +0000510 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +0000511 uint8_t buf[16];
512 uint64_t v;
Kevin Wolf2fc5d012020-11-13 12:43:24 +0100513 CPUState *cs = mon_get_cpu(mon);
Thomas Huth854e67f2017-01-13 13:12:35 +0100514
515 if (!cs && (format == 'i' || !is_physical)) {
516 monitor_printf(mon, "Can not dump without CPU\n");
517 return;
518 }
bellard9307c4c2004-04-04 12:57:25 +0000519
520 if (format == 'i') {
Richard Henderson1d484742017-09-14 08:38:35 -0700521 monitor_disas(mon, cs, addr, count, is_physical);
bellard9307c4c2004-04-04 12:57:25 +0000522 return;
523 }
524
525 len = wsize * count;
Yutao Ai89854b92020-11-25 01:45:13 +0000526 if (wsize == 1) {
bellard9307c4c2004-04-04 12:57:25 +0000527 line_size = 8;
Yutao Ai89854b92020-11-25 01:45:13 +0000528 } else {
bellard9307c4c2004-04-04 12:57:25 +0000529 line_size = 16;
Yutao Ai89854b92020-11-25 01:45:13 +0000530 }
bellard9307c4c2004-04-04 12:57:25 +0000531 max_digits = 0;
532
533 switch(format) {
534 case 'o':
Marc-André Lureau69db8df2017-06-22 13:04:16 +0200535 max_digits = DIV_ROUND_UP(wsize * 8, 3);
bellard9307c4c2004-04-04 12:57:25 +0000536 break;
537 default:
538 case 'x':
539 max_digits = (wsize * 8) / 4;
540 break;
541 case 'u':
542 case 'd':
Marc-André Lureau69db8df2017-06-22 13:04:16 +0200543 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
bellard9307c4c2004-04-04 12:57:25 +0000544 break;
545 case 'c':
546 wsize = 1;
547 break;
548 }
549
550 while (len > 0) {
Yutao Ai89854b92020-11-25 01:45:13 +0000551 if (is_physical) {
aliguori376253e2009-03-05 23:01:23 +0000552 monitor_printf(mon, TARGET_FMT_plx ":", addr);
Yutao Ai89854b92020-11-25 01:45:13 +0000553 } else {
aliguori376253e2009-03-05 23:01:23 +0000554 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
Yutao Ai89854b92020-11-25 01:45:13 +0000555 }
bellard9307c4c2004-04-04 12:57:25 +0000556 l = len;
557 if (l > line_size)
558 l = line_size;
559 if (is_physical) {
Peter Maydell6f89ae52018-12-14 13:30:49 +0000560 AddressSpace *as = cs ? cs->as : &address_space_memory;
561 MemTxResult r = address_space_read(as, addr,
562 MEMTXATTRS_UNSPECIFIED, buf, l);
563 if (r != MEMTX_OK) {
564 monitor_printf(mon, " Cannot access memory\n");
565 break;
566 }
bellard9307c4c2004-04-04 12:57:25 +0000567 } else {
Thomas Huth854e67f2017-01-13 13:12:35 +0100568 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +0000569 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +0000570 break;
571 }
bellard9307c4c2004-04-04 12:57:25 +0000572 }
ths5fafdf22007-09-16 21:08:06 +0000573 i = 0;
bellard9307c4c2004-04-04 12:57:25 +0000574 while (i < l) {
575 switch(wsize) {
576 default:
577 case 1:
Peter Maydell24e60302015-01-20 15:19:32 +0000578 v = ldub_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +0000579 break;
580 case 2:
Peter Maydell24e60302015-01-20 15:19:32 +0000581 v = lduw_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +0000582 break;
583 case 4:
Peter Maydell24e60302015-01-20 15:19:32 +0000584 v = (uint32_t)ldl_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +0000585 break;
586 case 8:
Peter Maydell24e60302015-01-20 15:19:32 +0000587 v = ldq_p(buf + i);
bellard9307c4c2004-04-04 12:57:25 +0000588 break;
589 }
aliguori376253e2009-03-05 23:01:23 +0000590 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +0000591 switch(format) {
592 case 'o':
aliguori376253e2009-03-05 23:01:23 +0000593 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +0000594 break;
595 case 'x':
aliguori376253e2009-03-05 23:01:23 +0000596 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +0000597 break;
598 case 'u':
aliguori376253e2009-03-05 23:01:23 +0000599 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +0000600 break;
601 case 'd':
aliguori376253e2009-03-05 23:01:23 +0000602 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +0000603 break;
604 case 'c':
aliguori376253e2009-03-05 23:01:23 +0000605 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +0000606 break;
607 }
608 i += wsize;
609 }
aliguori376253e2009-03-05 23:01:23 +0000610 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +0000611 addr += l;
612 len -= l;
613 }
614}
615
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100616static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +0000617{
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300618 int count = qdict_get_int(qdict, "count");
619 int format = qdict_get_int(qdict, "format");
620 int size = qdict_get_int(qdict, "size");
621 target_long addr = qdict_get_int(qdict, "addr");
622
aliguori376253e2009-03-05 23:01:23 +0000623 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +0000624}
625
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100626static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +0000627{
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300628 int count = qdict_get_int(qdict, "count");
629 int format = qdict_get_int(qdict, "format");
630 int size = qdict_get_int(qdict, "size");
Avi Kivitya8170e52012-10-23 12:30:10 +0200631 hwaddr addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300632
aliguori376253e2009-03-05 23:01:23 +0000633 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +0000634}
635
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400636void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, uint64_t size, Error **errp)
Paolo Bonzinie9628442017-04-20 15:30:58 +0200637{
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400638 Int128 gpa_region_size;
Paolo Bonzinie9628442017-04-20 15:30:58 +0200639 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400640 addr, size);
Paolo Bonzinie9628442017-04-20 15:30:58 +0200641
642 if (!mrs.mr) {
643 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
644 return NULL;
645 }
646
647 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
648 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
649 memory_region_unref(mrs.mr);
650 return NULL;
651 }
652
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400653 gpa_region_size = int128_make64(size);
654 if (int128_lt(mrs.size, gpa_region_size)) {
655 error_setg(errp, "Size of memory region at 0x%" HWADDR_PRIx
656 " exceeded.", addr);
657 memory_region_unref(mrs.mr);
658 return NULL;
659 }
660
Paolo Bonzinie9628442017-04-20 15:30:58 +0200661 *p_mr = mrs.mr;
662 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
663}
664
665static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
666{
667 hwaddr addr = qdict_get_int(qdict, "addr");
668 Error *local_err = NULL;
669 MemoryRegion *mr = NULL;
670 void *ptr;
671
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400672 ptr = gpa2hva(&mr, addr, 1, &local_err);
Paolo Bonzinie9628442017-04-20 15:30:58 +0200673 if (local_err) {
674 error_report_err(local_err);
675 return;
676 }
677
678 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
679 " (%s) is %p\n",
680 addr, mr->name, ptr);
681
682 memory_region_unref(mr);
683}
684
Dr. David Alan Gilbert574d9692019-04-12 16:26:52 +0100685static void hmp_gva2gpa(Monitor *mon, const QDict *qdict)
686{
687 target_ulong addr = qdict_get_int(qdict, "addr");
688 MemTxAttrs attrs;
Kevin Wolf2fc5d012020-11-13 12:43:24 +0100689 CPUState *cs = mon_get_cpu(mon);
Dr. David Alan Gilbert574d9692019-04-12 16:26:52 +0100690 hwaddr gpa;
691
692 if (!cs) {
693 monitor_printf(mon, "No cpu\n");
694 return;
695 }
696
Eduardo Habkost9d3250d2019-05-10 15:56:20 -0300697 gpa = cpu_get_phys_page_attrs_debug(cs, addr & TARGET_PAGE_MASK, &attrs);
Dr. David Alan Gilbert574d9692019-04-12 16:26:52 +0100698 if (gpa == -1) {
699 monitor_printf(mon, "Unmapped\n");
700 } else {
701 monitor_printf(mon, "gpa: %#" HWADDR_PRIx "\n",
702 gpa + (addr & ~TARGET_PAGE_MASK));
703 }
704}
705
Paolo Bonzinie9628442017-04-20 15:30:58 +0200706#ifdef CONFIG_LINUX
707static uint64_t vtop(void *ptr, Error **errp)
708{
709 uint64_t pinfo;
710 uint64_t ret = -1;
711 uintptr_t addr = (uintptr_t) ptr;
Wei Yang038adc22019-10-13 10:11:45 +0800712 uintptr_t pagesize = qemu_real_host_page_size;
Paolo Bonzinie9628442017-04-20 15:30:58 +0200713 off_t offset = addr / pagesize * sizeof(pinfo);
714 int fd;
715
716 fd = open("/proc/self/pagemap", O_RDONLY);
717 if (fd == -1) {
718 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
719 return -1;
720 }
721
722 /* Force copy-on-write if necessary. */
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100723 qatomic_add((uint8_t *)ptr, 0);
Paolo Bonzinie9628442017-04-20 15:30:58 +0200724
725 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
726 error_setg_errno(errp, errno, "Cannot read pagemap");
727 goto out;
728 }
729 if ((pinfo & (1ull << 63)) == 0) {
730 error_setg(errp, "Page not present");
731 goto out;
732 }
733 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
734
735out:
736 close(fd);
737 return ret;
738}
739
740static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
741{
742 hwaddr addr = qdict_get_int(qdict, "addr");
743 Error *local_err = NULL;
744 MemoryRegion *mr = NULL;
745 void *ptr;
746 uint64_t physaddr;
747
Tobin Feldman-Fitzthumc7f7e692020-10-27 13:03:03 -0400748 ptr = gpa2hva(&mr, addr, 1, &local_err);
Paolo Bonzinie9628442017-04-20 15:30:58 +0200749 if (local_err) {
750 error_report_err(local_err);
751 return;
752 }
753
754 physaddr = vtop(ptr, &local_err);
755 if (local_err) {
756 error_report_err(local_err);
757 } else {
758 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
759 " (%s) is 0x%" PRIx64 "\n",
760 addr, mr->name, (uint64_t) physaddr);
761 }
762
763 memory_region_unref(mr);
764}
765#endif
766
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300767static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +0000768{
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300769 int format = qdict_get_int(qdict, "format");
Avi Kivitya8170e52012-10-23 12:30:10 +0200770 hwaddr val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300771
bellard9307c4c2004-04-04 12:57:25 +0000772 switch(format) {
773 case 'o':
Avi Kivitya8170e52012-10-23 12:30:10 +0200774 monitor_printf(mon, "%#" HWADDR_PRIo, val);
bellard9307c4c2004-04-04 12:57:25 +0000775 break;
776 case 'x':
Avi Kivitya8170e52012-10-23 12:30:10 +0200777 monitor_printf(mon, "%#" HWADDR_PRIx, val);
bellard9307c4c2004-04-04 12:57:25 +0000778 break;
779 case 'u':
Avi Kivitya8170e52012-10-23 12:30:10 +0200780 monitor_printf(mon, "%" HWADDR_PRIu, val);
bellard9307c4c2004-04-04 12:57:25 +0000781 break;
782 default:
783 case 'd':
Avi Kivitya8170e52012-10-23 12:30:10 +0200784 monitor_printf(mon, "%" HWADDR_PRId, val);
bellard9307c4c2004-04-04 12:57:25 +0000785 break;
786 case 'c':
aliguori376253e2009-03-05 23:01:23 +0000787 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +0000788 break;
789 }
aliguori376253e2009-03-05 23:01:23 +0000790 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +0000791}
792
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100793static void hmp_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +0000794{
795 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +0000796 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -0300797 uint32_t start = qdict_get_int(qdict, "start");
798 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +0000799
800 sum = 0;
801 for(addr = start; addr < (start + size); addr++) {
Peter Maydell42874d32015-04-26 16:49:24 +0100802 uint8_t val = address_space_ldub(&address_space_memory, addr,
803 MEMTXATTRS_UNSPECIFIED, NULL);
bellarde4cf1ad2005-06-04 20:15:57 +0000804 /* BSD sum algorithm ('sum' Unix command) */
805 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +0200806 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +0000807 }
aliguori376253e2009-03-05 23:01:23 +0000808 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +0000809}
810
bellard13224a82006-07-14 22:03:35 +0000811static int mouse_button_state;
812
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100813static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +0000814{
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100815 int dx, dy, dz, button;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -0300816 const char *dx_str = qdict_get_str(qdict, "dx_str");
817 const char *dy_str = qdict_get_str(qdict, "dy_str");
818 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100819
bellard13224a82006-07-14 22:03:35 +0000820 dx = strtol(dx_str, NULL, 0);
821 dy = strtol(dy_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100822 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
823 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
824
825 if (dz_str) {
bellard13224a82006-07-14 22:03:35 +0000826 dz = strtol(dz_str, NULL, 0);
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100827 if (dz != 0) {
Gerd Hoffmannf22d0af2016-01-12 12:14:12 +0100828 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100829 qemu_input_queue_btn(NULL, button, true);
830 qemu_input_event_sync();
831 qemu_input_queue_btn(NULL, button, false);
832 }
833 }
834 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +0000835}
836
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100837static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +0000838{
Eric Blake7fb1cf12015-11-18 01:52:57 -0700839 static uint32_t bmap[INPUT_BUTTON__MAX] = {
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100840 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
841 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
842 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
843 };
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300844 int button_state = qdict_get_int(qdict, "button_state");
Gerd Hoffmannc751a742013-12-04 15:02:28 +0100845
846 if (mouse_button_state == button_state) {
847 return;
848 }
849 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
850 qemu_input_event_sync();
bellard13224a82006-07-14 22:03:35 +0000851 mouse_button_state = button_state;
bellard13224a82006-07-14 22:03:35 +0000852}
853
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100854static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +0000855{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -0300856 int size = qdict_get_int(qdict, "size");
857 int addr = qdict_get_int(qdict, "addr");
858 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +0000859 uint32_t val;
860 int suffix;
861
862 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -0300863 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +0000864 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +0000865 addr++;
866 }
867 addr &= 0xffff;
868
869 switch(size) {
870 default:
871 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000872 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +0000873 suffix = 'b';
874 break;
875 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000876 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +0000877 suffix = 'w';
878 break;
879 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000880 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +0000881 suffix = 'l';
882 break;
883 }
Yutao Ai33b1fa92020-11-25 01:45:14 +0000884 monitor_printf(mon, "port%c[0x%04x] = 0x%0*x\n",
aliguori376253e2009-03-05 23:01:23 +0000885 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +0000886}
bellarda3a91a32004-06-04 11:06:21 +0000887
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100888static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +0200889{
Luiz Capitulino1bd14422009-08-28 15:27:17 -0300890 int size = qdict_get_int(qdict, "size");
891 int addr = qdict_get_int(qdict, "addr");
892 int val = qdict_get_int(qdict, "val");
893
Jan Kiszkaf1147842009-07-14 10:20:11 +0200894 addr &= IOPORTS_MASK;
895
896 switch (size) {
897 default:
898 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000899 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +0200900 break;
901 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000902 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +0200903 break;
904 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000905 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +0200906 break;
907 }
908}
909
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100910static void hmp_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +0000911{
Gongleif1839932014-12-03 18:20:58 +0000912 Error *local_err = NULL;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300913 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +0000914
Gongleif1839932014-12-03 18:20:58 +0000915 qemu_boot_set(bootdevice, &local_err);
916 if (local_err) {
Markus Armbruster193227f2015-12-18 16:35:06 +0100917 error_report_err(local_err);
aurel320ecdffb2008-05-04 20:11:34 +0000918 } else {
Gongleif1839932014-12-03 18:20:58 +0000919 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
aurel320ecdffb2008-05-04 20:11:34 +0000920 }
921}
922
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100923static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
Blue Swirl314e2982011-09-11 20:22:05 +0000924{
Peter Xu57bb40c2017-01-16 16:40:05 +0800925 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
Alexey Kardashevskiy5e8fd942017-09-21 18:51:06 +1000926 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
Alexey Kardashevskiyfc051ae2018-06-04 13:25:11 +1000927 bool owner = qdict_get_try_bool(qdict, "owner", false);
Philippe Mathieu-Daudé2261d392020-05-29 14:53:25 +0200928 bool disabled = qdict_get_try_bool(qdict, "disabled", false);
Peter Xu57bb40c2017-01-16 16:40:05 +0800929
Philippe Mathieu-Daudé2261d392020-05-29 14:53:25 +0200930 mtree_info(flatview, dispatch_tree, owner, disabled);
Blue Swirl314e2982011-09-11 20:22:05 +0000931}
932
bellard5f1ce942006-02-08 22:40:15 +0000933#ifdef CONFIG_PROFILER
934
Aurelien Jarnoe9a66252009-09-30 14:09:52 +0200935int64_t dev_time;
936
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100937static void hmp_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +0000938{
Emilio G. Cota72fd2ef2018-10-10 10:48:53 -0400939 static int64_t last_cpu_exec_time;
940 int64_t cpu_exec_time;
941 int64_t delta;
942
943 cpu_exec_time = tcg_cpu_exec_time();
944 delta = cpu_exec_time - last_cpu_exec_time;
945
aliguori376253e2009-03-05 23:01:23 +0000946 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Rutuja Shah73bcb242016-03-21 21:32:30 +0530947 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
aliguori376253e2009-03-05 23:01:23 +0000948 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Emilio G. Cota72fd2ef2018-10-10 10:48:53 -0400949 delta, delta / (double)NANOSECONDS_PER_SECOND);
950 last_cpu_exec_time = cpu_exec_time;
bellard5f1ce942006-02-08 22:40:15 +0000951 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +0000952}
953#else
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100954static void hmp_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +0000955{
aliguori376253e2009-03-05 23:01:23 +0000956 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +0000957}
958#endif
959
bellardec36b692006-07-16 18:57:03 +0000960/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +0000961static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +0000962
Markus Armbruster1ce6be22015-02-06 14:18:24 +0100963static void hmp_info_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +0000964{
965 int i;
966 CaptureState *s;
967
968 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +0000969 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +0000970 s->ops.info (s->opaque);
971 }
972}
973
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100974static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +0000975{
976 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300977 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +0000978 CaptureState *s;
979
980 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
981 if (i == n) {
982 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +0000983 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -0500984 g_free (s);
bellardec36b692006-07-16 18:57:03 +0000985 return;
986 }
987 }
988}
989
Markus Armbruster3e5a50d2015-02-06 13:55:43 +0100990static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +0000991{
Luiz Capitulinoc1925482009-08-28 15:27:19 -0300992 const char *path = qdict_get_str(qdict, "path");
Kővágó, Zoltánf0b9f362019-08-19 01:06:48 +0200993 int freq = qdict_get_try_int(qdict, "freq", 44100);
994 int bits = qdict_get_try_int(qdict, "bits", 16);
995 int nchannels = qdict_get_try_int(qdict, "nchannels", 2);
996 const char *audiodev = qdict_get_str(qdict, "audiodev");
bellardec36b692006-07-16 18:57:03 +0000997 CaptureState *s;
Kővágó, Zoltánf0b9f362019-08-19 01:06:48 +0200998 AudioState *as = audio_state_by_name(audiodev);
999
1000 if (!as) {
1001 monitor_printf(mon, "Audiodev '%s' not found\n", audiodev);
1002 return;
1003 }
bellardec36b692006-07-16 18:57:03 +00001004
Anthony Liguori7267c092011-08-20 22:09:37 -05001005 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00001006
Kővágó, Zoltánf0b9f362019-08-19 01:06:48 +02001007 if (wav_start_capture(as, s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001008 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05001009 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001010 return;
bellardec36b692006-07-16 18:57:03 +00001011 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00001012 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00001013}
bellardec36b692006-07-16 18:57:03 +00001014
Corey Bryant208c9d12012-06-22 14:36:09 -04001015void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001016{
Kevin Wolf947e4742020-10-05 17:58:44 +02001017 Monitor *cur_mon = monitor_cur();
Anthony Liguoric227f092009-10-01 16:12:16 -05001018 mon_fd_t *monfd;
Peter Xu9409fc02018-06-08 11:55:06 +08001019 int fd, tmp_fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001020
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03001021 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001022 if (fd == -1) {
Markus Armbrusterf820af82020-11-13 09:26:18 +01001023 error_setg(errp, "No file descriptor supplied via SCM_RIGHTS");
Corey Bryant208c9d12012-06-22 14:36:09 -04001024 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001025 }
1026
1027 if (qemu_isdigit(fdname[0])) {
Stefan Hajnoczi0b9f0e22014-04-24 13:58:18 +02001028 close(fd);
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001029 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1030 "a name not starting with a digit");
Corey Bryant208c9d12012-06-22 14:36:09 -04001031 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001032 }
1033
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001034 QEMU_LOCK_GUARD(&cur_mon->mon_lock);
Corey Bryant208c9d12012-06-22 14:36:09 -04001035 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001036 if (strcmp(monfd->name, fdname) != 0) {
1037 continue;
1038 }
1039
Peter Xu9409fc02018-06-08 11:55:06 +08001040 tmp_fd = monfd->fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001041 monfd->fd = fd;
Markus Armbruster774a6b62018-07-03 10:53:57 +02001042 /* Make sure close() is outside critical section */
Peter Xu9409fc02018-06-08 11:55:06 +08001043 close(tmp_fd);
Corey Bryant208c9d12012-06-22 14:36:09 -04001044 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001045 }
1046
Anthony Liguori7267c092011-08-20 22:09:37 -05001047 monfd = g_malloc0(sizeof(mon_fd_t));
1048 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001049 monfd->fd = fd;
1050
Corey Bryant208c9d12012-06-22 14:36:09 -04001051 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001052}
1053
Corey Bryant208c9d12012-06-22 14:36:09 -04001054void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001055{
Kevin Wolf947e4742020-10-05 17:58:44 +02001056 Monitor *cur_mon = monitor_cur();
Anthony Liguoric227f092009-10-01 16:12:16 -05001057 mon_fd_t *monfd;
Peter Xu9409fc02018-06-08 11:55:06 +08001058 int tmp_fd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001059
Peter Xu9409fc02018-06-08 11:55:06 +08001060 qemu_mutex_lock(&cur_mon->mon_lock);
Corey Bryant208c9d12012-06-22 14:36:09 -04001061 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001062 if (strcmp(monfd->name, fdname) != 0) {
1063 continue;
1064 }
1065
Blue Swirl72cf2d42009-09-12 07:36:22 +00001066 QLIST_REMOVE(monfd, next);
Peter Xu9409fc02018-06-08 11:55:06 +08001067 tmp_fd = monfd->fd;
Anthony Liguori7267c092011-08-20 22:09:37 -05001068 g_free(monfd->name);
1069 g_free(monfd);
Peter Xu9409fc02018-06-08 11:55:06 +08001070 qemu_mutex_unlock(&cur_mon->mon_lock);
Markus Armbruster774a6b62018-07-03 10:53:57 +02001071 /* Make sure close() is outside critical section */
Peter Xu9409fc02018-06-08 11:55:06 +08001072 close(tmp_fd);
Corey Bryant208c9d12012-06-22 14:36:09 -04001073 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001074 }
1075
Peter Xu9409fc02018-06-08 11:55:06 +08001076 qemu_mutex_unlock(&cur_mon->mon_lock);
Markus Armbrusterf820af82020-11-13 09:26:18 +01001077 error_setg(errp, "File descriptor named '%s' not found", fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01001078}
1079
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02001080int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01001081{
Anthony Liguoric227f092009-10-01 16:12:16 -05001082 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01001083
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001084 QEMU_LOCK_GUARD(&mon->mon_lock);
Blue Swirl72cf2d42009-09-12 07:36:22 +00001085 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01001086 int fd;
1087
1088 if (strcmp(monfd->name, fdname) != 0) {
1089 continue;
1090 }
1091
1092 fd = monfd->fd;
1093
1094 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00001095 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05001096 g_free(monfd->name);
1097 g_free(monfd);
Mark McLoughlin7768e042009-07-22 09:11:41 +01001098
1099 return fd;
1100 }
1101
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02001102 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01001103 return -1;
1104}
1105
Corey Bryantba1c0482012-08-14 16:43:43 -04001106static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1107{
1108 MonFdsetFd *mon_fdset_fd;
1109 MonFdsetFd *mon_fdset_fd_next;
1110
1111 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantebe52b52012-10-18 15:19:33 -04001112 if ((mon_fdset_fd->removed ||
1113 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1114 runstate_is_running()) {
Corey Bryantba1c0482012-08-14 16:43:43 -04001115 close(mon_fdset_fd->fd);
1116 g_free(mon_fdset_fd->opaque);
1117 QLIST_REMOVE(mon_fdset_fd, next);
1118 g_free(mon_fdset_fd);
1119 }
1120 }
1121
Corey Bryantadb696f2012-08-14 16:43:47 -04001122 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04001123 QLIST_REMOVE(mon_fdset, next);
1124 g_free(mon_fdset);
1125 }
1126}
1127
Kevin Wolf7e3c0de2019-06-13 17:34:00 +02001128void monitor_fdsets_cleanup(void)
Corey Bryantefb87c12012-08-14 16:43:48 -04001129{
1130 MonFdset *mon_fdset;
1131 MonFdset *mon_fdset_next;
1132
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001133 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryantefb87c12012-08-14 16:43:48 -04001134 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1135 monitor_fdset_cleanup(mon_fdset);
1136 }
1137}
1138
Corey Bryantba1c0482012-08-14 16:43:43 -04001139AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1140 const char *opaque, Error **errp)
1141{
1142 int fd;
Kevin Wolf947e4742020-10-05 17:58:44 +02001143 Monitor *mon = monitor_cur();
Corey Bryantba1c0482012-08-14 16:43:43 -04001144 AddfdInfo *fdinfo;
1145
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03001146 fd = qemu_chr_fe_get_msgfd(&mon->chr);
Corey Bryantba1c0482012-08-14 16:43:43 -04001147 if (fd == -1) {
Markus Armbrusterf820af82020-11-13 09:26:18 +01001148 error_setg(errp, "No file descriptor supplied via SCM_RIGHTS");
Corey Bryantba1c0482012-08-14 16:43:43 -04001149 goto error;
1150 }
1151
Corey Bryante446f702012-10-18 15:19:32 -04001152 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1153 has_opaque, opaque, errp);
1154 if (fdinfo) {
1155 return fdinfo;
Corey Bryant9ac54af2012-10-18 15:19:31 -04001156 }
1157
Corey Bryantba1c0482012-08-14 16:43:43 -04001158error:
1159 if (fd != -1) {
1160 close(fd);
1161 }
1162 return NULL;
1163}
1164
1165void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1166{
1167 MonFdset *mon_fdset;
1168 MonFdsetFd *mon_fdset_fd;
1169 char fd_str[60];
1170
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001171 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04001172 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1173 if (mon_fdset->id != fdset_id) {
1174 continue;
1175 }
1176 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1177 if (has_fd) {
1178 if (mon_fdset_fd->fd != fd) {
1179 continue;
1180 }
1181 mon_fdset_fd->removed = true;
1182 break;
1183 } else {
1184 mon_fdset_fd->removed = true;
1185 }
1186 }
1187 if (has_fd && !mon_fdset_fd) {
1188 goto error;
1189 }
1190 monitor_fdset_cleanup(mon_fdset);
1191 return;
1192 }
1193
1194error:
1195 if (has_fd) {
1196 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1197 fdset_id, fd);
1198 } else {
1199 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1200 }
Markus Armbrusterf820af82020-11-13 09:26:18 +01001201 error_setg(errp, "File descriptor named '%s' not found", fd_str);
Corey Bryantba1c0482012-08-14 16:43:43 -04001202}
1203
1204FdsetInfoList *qmp_query_fdsets(Error **errp)
1205{
1206 MonFdset *mon_fdset;
1207 MonFdsetFd *mon_fdset_fd;
1208 FdsetInfoList *fdset_list = NULL;
1209
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001210 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryantba1c0482012-08-14 16:43:43 -04001211 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
Eric Blake54aa3de2020-11-12 19:13:37 -06001212 FdsetInfo *fdset_info = g_malloc0(sizeof(*fdset_info));
Corey Bryantba1c0482012-08-14 16:43:43 -04001213
Eric Blake54aa3de2020-11-12 19:13:37 -06001214 fdset_info->fdset_id = mon_fdset->id;
Corey Bryantba1c0482012-08-14 16:43:43 -04001215
1216 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
Eric Blake54aa3de2020-11-12 19:13:37 -06001217 FdsetFdInfo *fdsetfd_info;
Corey Bryantba1c0482012-08-14 16:43:43 -04001218
1219 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
Eric Blake54aa3de2020-11-12 19:13:37 -06001220 fdsetfd_info->fd = mon_fdset_fd->fd;
Corey Bryantba1c0482012-08-14 16:43:43 -04001221 if (mon_fdset_fd->opaque) {
Eric Blake54aa3de2020-11-12 19:13:37 -06001222 fdsetfd_info->has_opaque = true;
1223 fdsetfd_info->opaque = g_strdup(mon_fdset_fd->opaque);
Corey Bryantba1c0482012-08-14 16:43:43 -04001224 } else {
Eric Blake54aa3de2020-11-12 19:13:37 -06001225 fdsetfd_info->has_opaque = false;
Corey Bryantba1c0482012-08-14 16:43:43 -04001226 }
1227
Eric Blake54aa3de2020-11-12 19:13:37 -06001228 QAPI_LIST_PREPEND(fdset_info->fds, fdsetfd_info);
Corey Bryantba1c0482012-08-14 16:43:43 -04001229 }
1230
Eric Blake54aa3de2020-11-12 19:13:37 -06001231 QAPI_LIST_PREPEND(fdset_list, fdset_info);
Corey Bryantba1c0482012-08-14 16:43:43 -04001232 }
1233
1234 return fdset_list;
1235}
1236
Corey Bryante446f702012-10-18 15:19:32 -04001237AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
1238 bool has_opaque, const char *opaque,
1239 Error **errp)
1240{
1241 MonFdset *mon_fdset = NULL;
1242 MonFdsetFd *mon_fdset_fd;
1243 AddfdInfo *fdinfo;
1244
Daniel Brodsky6e8a3552020-04-03 21:21:08 -07001245 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryante446f702012-10-18 15:19:32 -04001246 if (has_fdset_id) {
1247 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1248 /* Break if match found or match impossible due to ordering by ID */
1249 if (fdset_id <= mon_fdset->id) {
1250 if (fdset_id < mon_fdset->id) {
1251 mon_fdset = NULL;
1252 }
1253 break;
1254 }
1255 }
1256 }
1257
1258 if (mon_fdset == NULL) {
1259 int64_t fdset_id_prev = -1;
1260 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
1261
1262 if (has_fdset_id) {
1263 if (fdset_id < 0) {
Markus Armbrusterc6bd8c72015-03-17 11:54:50 +01001264 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
1265 "a non-negative value");
Corey Bryante446f702012-10-18 15:19:32 -04001266 return NULL;
1267 }
1268 /* Use specified fdset ID */
1269 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1270 mon_fdset_cur = mon_fdset;
1271 if (fdset_id < mon_fdset_cur->id) {
1272 break;
1273 }
1274 }
1275 } else {
1276 /* Use first available fdset ID */
1277 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1278 mon_fdset_cur = mon_fdset;
1279 if (fdset_id_prev == mon_fdset_cur->id - 1) {
1280 fdset_id_prev = mon_fdset_cur->id;
1281 continue;
1282 }
1283 break;
1284 }
1285 }
1286
1287 mon_fdset = g_malloc0(sizeof(*mon_fdset));
1288 if (has_fdset_id) {
1289 mon_fdset->id = fdset_id;
1290 } else {
1291 mon_fdset->id = fdset_id_prev + 1;
1292 }
1293
1294 /* The fdset list is ordered by fdset ID */
1295 if (!mon_fdset_cur) {
1296 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
1297 } else if (mon_fdset->id < mon_fdset_cur->id) {
1298 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
1299 } else {
1300 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
1301 }
1302 }
1303
1304 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
1305 mon_fdset_fd->fd = fd;
1306 mon_fdset_fd->removed = false;
1307 if (has_opaque) {
1308 mon_fdset_fd->opaque = g_strdup(opaque);
1309 }
1310 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
1311
1312 fdinfo = g_malloc0(sizeof(*fdinfo));
1313 fdinfo->fdset_id = mon_fdset->id;
1314 fdinfo->fd = mon_fdset_fd->fd;
1315
1316 return fdinfo;
1317}
1318
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001319int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags)
Corey Bryantadb696f2012-08-14 16:43:47 -04001320{
Peter Xu47451462018-06-08 11:55:11 +08001321#ifdef _WIN32
1322 return -ENOENT;
1323#else
Corey Bryantadb696f2012-08-14 16:43:47 -04001324 MonFdset *mon_fdset;
Corey Bryantadb696f2012-08-14 16:43:47 -04001325
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001326 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04001327 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001328 MonFdsetFd *mon_fdset_fd;
1329 MonFdsetFd *mon_fdset_fd_dup;
1330 int fd = -1;
1331 int dup_fd;
1332 int mon_fd_flags;
1333
Corey Bryantadb696f2012-08-14 16:43:47 -04001334 if (mon_fdset->id != fdset_id) {
1335 continue;
1336 }
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001337
Corey Bryantadb696f2012-08-14 16:43:47 -04001338 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1339 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
1340 if (mon_fd_flags == -1) {
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001341 return -1;
Corey Bryantadb696f2012-08-14 16:43:47 -04001342 }
1343
1344 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001345 fd = mon_fdset_fd->fd;
1346 break;
Corey Bryantadb696f2012-08-14 16:43:47 -04001347 }
1348 }
Corey Bryantadb696f2012-08-14 16:43:47 -04001349
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001350 if (fd == -1) {
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001351 errno = EACCES;
1352 return -1;
Corey Bryantadb696f2012-08-14 16:43:47 -04001353 }
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001354
1355 dup_fd = qemu_dup_flags(fd, flags);
1356 if (dup_fd == -1) {
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001357 return -1;
Corey Bryantadb696f2012-08-14 16:43:47 -04001358 }
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001359
Corey Bryantadb696f2012-08-14 16:43:47 -04001360 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
1361 mon_fdset_fd_dup->fd = dup_fd;
1362 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001363 return dup_fd;
Corey Bryantadb696f2012-08-14 16:43:47 -04001364 }
Peter Xu47451462018-06-08 11:55:11 +08001365
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001366 errno = ENOENT;
Corey Bryantadb696f2012-08-14 16:43:47 -04001367 return -1;
Daniel P. Berrangé60efffa2020-08-27 13:27:00 +01001368#endif
Corey Bryantadb696f2012-08-14 16:43:47 -04001369}
1370
Yury Kotov854f63d2019-05-23 12:44:33 +03001371static int64_t monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
Corey Bryantadb696f2012-08-14 16:43:47 -04001372{
1373 MonFdset *mon_fdset;
1374 MonFdsetFd *mon_fdset_fd_dup;
1375
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001376 QEMU_LOCK_GUARD(&mon_fdsets_lock);
Corey Bryantadb696f2012-08-14 16:43:47 -04001377 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1378 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
1379 if (mon_fdset_fd_dup->fd == dup_fd) {
1380 if (remove) {
1381 QLIST_REMOVE(mon_fdset_fd_dup, next);
Chen Quna6616142020-01-15 15:20:16 +08001382 g_free(mon_fdset_fd_dup);
Corey Bryantadb696f2012-08-14 16:43:47 -04001383 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
1384 monitor_fdset_cleanup(mon_fdset);
1385 }
Dr. David Alan Gilbert0210c3b2020-09-22 10:57:41 +01001386 return -1;
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02001387 } else {
1388 return mon_fdset->id;
Corey Bryantadb696f2012-08-14 16:43:47 -04001389 }
Corey Bryantadb696f2012-08-14 16:43:47 -04001390 }
1391 }
1392 }
Peter Xu47451462018-06-08 11:55:11 +08001393
Corey Bryantadb696f2012-08-14 16:43:47 -04001394 return -1;
1395}
1396
Yury Kotov854f63d2019-05-23 12:44:33 +03001397int64_t monitor_fdset_dup_fd_find(int dup_fd)
Corey Bryantadb696f2012-08-14 16:43:47 -04001398{
1399 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
1400}
1401
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02001402void monitor_fdset_dup_fd_remove(int dup_fd)
Corey Bryantadb696f2012-08-14 16:43:47 -04001403{
Michael S. Tsirkinb3dd1b82014-08-17 11:45:17 +02001404 monitor_fdset_dup_fd_find_remove(dup_fd, true);
Corey Bryantadb696f2012-08-14 16:43:47 -04001405}
1406
Markus Armbruster1677f4c2015-02-09 14:03:19 +01001407int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
Laszlo Ersek59063662014-04-10 10:24:31 +02001408{
1409 int fd;
1410 Error *local_err = NULL;
1411
1412 if (!qemu_isdigit(fdname[0]) && mon) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02001413 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00001414 } else {
1415 fd = qemu_parse_fd(fdname);
Laszlo Ersek59063662014-04-10 10:24:31 +02001416 if (fd == -1) {
1417 error_setg(&local_err, "Invalid file descriptor number '%s'",
1418 fdname);
1419 }
1420 }
1421 if (local_err) {
1422 error_propagate(errp, local_err);
1423 assert(fd == -1);
1424 } else {
1425 assert(fd != -1);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00001426 }
1427
1428 return fd;
1429}
1430
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03001431/* Please update hmp-commands.hx when adding or changing commands */
Kevin Wolfa0cd5e12019-06-13 17:33:56 +02001432static HMPCommand hmp_info_cmds[] = {
Pavel Butsykinda76ee72015-09-10 18:38:58 +03001433#include "hmp-commands-info.h"
1434 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00001435};
1436
Kevin Wolfa0cd5e12019-06-13 17:33:56 +02001437/* hmp_cmds and hmp_info_cmds would be sorted at runtime */
Kevin Wolfed7bda52019-06-13 17:34:01 +02001438HMPCommand hmp_cmds[] = {
Wenchao Xiaa13ced52013-01-14 14:06:28 +08001439#include "hmp-commands.h"
1440 { NULL, NULL, },
1441};
1442
Kevin Wolfed7bda52019-06-13 17:34:01 +02001443/*
1444 * Set @pval to the value in the register identified by @name.
1445 * return 0 if OK, -1 if not found
1446 */
Kevin Wolf2fc5d012020-11-13 12:43:24 +01001447int get_monitor_def(Monitor *mon, int64_t *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00001448{
Pavel Butsykinbf957282015-09-10 18:38:59 +03001449 const MonitorDef *md = target_monitor_defs();
Kevin Wolf2fc5d012020-11-13 12:43:24 +01001450 CPUState *cs = mon_get_cpu(mon);
bellard92a31b12005-02-10 22:00:52 +00001451 void *ptr;
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11001452 uint64_t tmp = 0;
1453 int ret;
bellard92a31b12005-02-10 22:00:52 +00001454
Thomas Huth854e67f2017-01-13 13:12:35 +01001455 if (cs == NULL || md == NULL) {
Pavel Butsykinbf957282015-09-10 18:38:59 +03001456 return -1;
1457 }
1458
1459 for(; md->name != NULL; md++) {
Kevin Wolfed7bda52019-06-13 17:34:01 +02001460 if (hmp_compare_cmd(name, md->name)) {
bellard9307c4c2004-04-04 12:57:25 +00001461 if (md->get_value) {
Kevin Wolf43cf0672020-11-13 12:43:25 +01001462 *pval = md->get_value(mon, md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00001463 } else {
Kevin Wolfe7cff9c2020-11-13 12:43:26 +01001464 CPUArchState *env = mon_get_cpu_env(mon);
bellard6a00d602005-11-21 23:25:50 +00001465 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00001466 switch(md->type) {
1467 case MD_I32:
1468 *pval = *(int32_t *)ptr;
1469 break;
1470 case MD_TLONG:
1471 *pval = *(target_long *)ptr;
1472 break;
1473 default:
1474 *pval = 0;
1475 break;
1476 }
bellard9307c4c2004-04-04 12:57:25 +00001477 }
1478 return 0;
1479 }
1480 }
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11001481
Thomas Huth854e67f2017-01-13 13:12:35 +01001482 ret = target_get_monitor_def(cs, name, &tmp);
Alexey Kardashevskiy0a9516c2015-11-12 14:44:23 +11001483 if (!ret) {
1484 *pval = (target_long) tmp;
1485 }
1486
1487 return ret;
bellard9307c4c2004-04-04 12:57:25 +00001488}
1489
Hani Benhabiles40d19392014-05-07 23:41:30 +01001490static void add_completion_option(ReadLineState *rs, const char *str,
1491 const char *option)
1492{
1493 if (!str || !option) {
1494 return;
1495 }
1496 if (!strncmp(option, str, strlen(str))) {
1497 readline_add_completion(rs, option);
1498 }
1499}
1500
Hani Benhabiles13e315d2014-05-07 23:41:29 +01001501void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1502{
1503 size_t len;
1504 ChardevBackendInfoList *list, *start;
1505
1506 if (nb_args != 2) {
1507 return;
1508 }
1509 len = strlen(str);
1510 readline_set_completion_index(rs, len);
1511
1512 start = list = qmp_query_chardev_backends(NULL);
1513 while (list) {
1514 const char *chr_name = list->value->name;
1515
1516 if (!strncmp(chr_name, str, len)) {
1517 readline_add_completion(rs, chr_name);
1518 }
1519 list = list->next;
1520 }
1521 qapi_free_ChardevBackendInfoList(start);
1522}
1523
Hani Benhabilesb162b492014-05-07 23:41:31 +01001524void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1525{
1526 size_t len;
1527 int i;
1528
1529 if (nb_args != 2) {
1530 return;
1531 }
1532 len = strlen(str);
1533 readline_set_completion_index(rs, len);
Markus Armbruster1c236ba2017-08-24 10:46:06 +02001534 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02001535 add_completion_option(rs, str, NetClientDriver_str(i));
Hani Benhabilesb162b492014-05-07 23:41:31 +01001536 }
1537}
1538
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001539void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles992d3e62014-02-06 23:30:11 +01001540{
1541 GSList *list, *elt;
1542 size_t len;
1543
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001544 if (nb_args != 2) {
1545 return;
1546 }
1547
Hani Benhabiles992d3e62014-02-06 23:30:11 +01001548 len = strlen(str);
1549 readline_set_completion_index(rs, len);
1550 list = elt = object_class_get_list(TYPE_DEVICE, false);
1551 while (elt) {
1552 const char *name;
1553 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
1554 TYPE_DEVICE);
1555 name = object_class_get_name(OBJECT_CLASS(dc));
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001556
Eduardo Habkoste90f2a82017-05-03 17:35:44 -03001557 if (dc->user_creatable
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001558 && !strncmp(name, str, len)) {
Hani Benhabiles992d3e62014-02-06 23:30:11 +01001559 readline_add_completion(rs, name);
1560 }
1561 elt = elt->next;
1562 }
1563 g_slist_free(list);
1564}
1565
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01001566void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabiles1094fd32014-02-06 23:30:13 +01001567{
1568 GSList *list, *elt;
1569 size_t len;
1570
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01001571 if (nb_args != 2) {
1572 return;
1573 }
1574
Hani Benhabiles1094fd32014-02-06 23:30:13 +01001575 len = strlen(str);
1576 readline_set_completion_index(rs, len);
1577 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
1578 while (elt) {
1579 const char *name;
1580
1581 name = object_class_get_name(OBJECT_CLASS(elt->data));
1582 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
1583 readline_add_completion(rs, name);
1584 }
1585 elt = elt->next;
1586 }
1587 g_slist_free(list);
1588}
1589
Marc-André Lureau91590152020-01-10 19:30:17 +04001590static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
1591{
1592 GSList **list = opaque;
Philippe Mathieu-Daudé688ffbb2020-05-12 09:00:19 +02001593 DeviceState *dev = (DeviceState *)object_dynamic_cast(obj, TYPE_DEVICE);
Marc-André Lureau91590152020-01-10 19:30:17 +04001594
1595 if (dev == NULL) {
1596 return 0;
1597 }
1598
1599 if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
1600 *list = g_slist_append(*list, dev);
1601 }
1602
1603 return 0;
1604}
1605
1606static GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
1607{
1608 GSList *list = NULL;
1609
1610 object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
1611
1612 return list;
1613}
1614
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08001615static void peripheral_device_del_completion(ReadLineState *rs,
1616 const char *str, size_t len)
1617{
Marcel Apfelbaum4cae4d52014-11-26 13:50:01 +02001618 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
1619 GSList *list, *item;
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08001620
Marcel Apfelbaum4cae4d52014-11-26 13:50:01 +02001621 list = qdev_build_hotpluggable_device_list(peripheral);
1622 if (!list) {
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08001623 return;
1624 }
1625
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08001626 for (item = list; item; item = g_slist_next(item)) {
1627 DeviceState *dev = item->data;
1628
1629 if (dev->id && !strncmp(str, dev->id, len)) {
1630 readline_add_completion(rs, dev->id);
1631 }
1632 }
1633
1634 g_slist_free(list);
1635}
1636
Hani Benhabiles6297d9a2014-05-07 23:41:28 +01001637void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
1638{
1639 size_t len;
1640 ChardevInfoList *list, *start;
1641
1642 if (nb_args != 2) {
1643 return;
1644 }
1645 len = strlen(str);
1646 readline_set_completion_index(rs, len);
1647
1648 start = list = qmp_query_chardev(NULL);
1649 while (list) {
1650 ChardevInfo *chr = list->value;
1651
1652 if (!strncmp(chr->label, str, len)) {
1653 readline_add_completion(rs, chr->label);
1654 }
1655 list = list->next;
1656 }
1657 qapi_free_ChardevInfoList(start);
1658}
1659
Hani Benhabiles8e597772014-05-27 23:39:30 +01001660static void ringbuf_completion(ReadLineState *rs, const char *str)
1661{
1662 size_t len;
1663 ChardevInfoList *list, *start;
1664
1665 len = strlen(str);
1666 readline_set_completion_index(rs, len);
1667
1668 start = list = qmp_query_chardev(NULL);
1669 while (list) {
1670 ChardevInfo *chr_info = list->value;
1671
1672 if (!strncmp(chr_info->label, str, len)) {
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03001673 Chardev *chr = qemu_chr_find(chr_info->label);
Marc-André Lureau777357d2016-12-07 18:39:10 +03001674 if (chr && CHARDEV_IS_RINGBUF(chr)) {
Hani Benhabiles8e597772014-05-27 23:39:30 +01001675 readline_add_completion(rs, chr_info->label);
1676 }
1677 }
1678 list = list->next;
1679 }
1680 qapi_free_ChardevInfoList(start);
1681}
1682
Hani Benhabiles8e597772014-05-27 23:39:30 +01001683void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
1684{
1685 if (nb_args != 2) {
1686 return;
1687 }
1688 ringbuf_completion(rs, str);
1689}
1690
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001691void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
1692{
1693 size_t len;
1694
1695 if (nb_args != 2) {
1696 return;
1697 }
1698
1699 len = strlen(str);
1700 readline_set_completion_index(rs, len);
Zhu Guihua6a1fa9f2014-10-21 19:46:05 +08001701 peripheral_device_del_completion(rs, str, len);
Hani Benhabiles2da1b3a2014-04-13 16:25:07 +01001702}
1703
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01001704void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
Hani Benhabilesb48fa072014-02-06 23:30:12 +01001705{
1706 ObjectPropertyInfoList *list, *start;
1707 size_t len;
1708
Hani Benhabilesbfa40f72014-04-13 16:25:06 +01001709 if (nb_args != 2) {
1710 return;
1711 }
Hani Benhabilesb48fa072014-02-06 23:30:12 +01001712 len = strlen(str);
1713 readline_set_completion_index(rs, len);
1714
1715 start = list = qmp_qom_list("/objects", NULL);
1716 while (list) {
1717 ObjectPropertyInfo *info = list->value;
1718
1719 if (!strncmp(info->type, "child<", 5)
1720 && !strncmp(info->name, str, len)) {
1721 readline_add_completion(rs, info->name);
1722 }
1723 list = list->next;
1724 }
1725 qapi_free_ObjectPropertyInfoList(start);
1726}
1727
Hani Benhabiles29136cd2014-05-07 23:41:27 +01001728void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
1729{
1730 int i;
1731 char *sep;
1732 size_t len;
1733
1734 if (nb_args != 2) {
1735 return;
1736 }
1737 sep = strrchr(str, '-');
1738 if (sep) {
1739 str = sep + 1;
1740 }
1741 len = strlen(str);
1742 readline_set_completion_index(rs, len);
Eric Blake7fb1cf12015-11-18 01:52:57 -07001743 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02001744 if (!strncmp(str, QKeyCode_str(i), len)) {
1745 readline_add_completion(rs, QKeyCode_str(i));
Hani Benhabiles29136cd2014-05-07 23:41:27 +01001746 }
1747 }
1748}
1749
Hani Benhabiles40d19392014-05-07 23:41:30 +01001750void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
1751{
1752 size_t len;
1753
1754 len = strlen(str);
1755 readline_set_completion_index(rs, len);
1756 if (nb_args == 2) {
Jason Wangeaed4832015-04-23 14:21:38 +08001757 NetClientState *ncs[MAX_QUEUE_NUM];
Hani Benhabiles40d19392014-05-07 23:41:30 +01001758 int count, i;
1759 count = qemu_find_net_clients_except(NULL, ncs,
Eric Blakef394b2e2016-07-13 21:50:23 -06001760 NET_CLIENT_DRIVER_NONE,
Jason Wangeaed4832015-04-23 14:21:38 +08001761 MAX_QUEUE_NUM);
Jason Wangbcfa4d62015-04-23 14:21:39 +08001762 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
Hani Benhabiles40d19392014-05-07 23:41:30 +01001763 const char *name = ncs[i]->name;
1764 if (!strncmp(str, name, len)) {
1765 readline_add_completion(rs, name);
1766 }
1767 }
1768 } else if (nb_args == 3) {
1769 add_completion_option(rs, str, "on");
1770 add_completion_option(rs, str, "off");
1771 }
1772}
1773
Hani Benhabiles11b389f2014-05-07 23:41:32 +01001774void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
1775{
1776 int len, count, i;
Jason Wangeaed4832015-04-23 14:21:38 +08001777 NetClientState *ncs[MAX_QUEUE_NUM];
Hani Benhabiles11b389f2014-05-07 23:41:32 +01001778
1779 if (nb_args != 2) {
1780 return;
1781 }
1782
1783 len = strlen(str);
1784 readline_set_completion_index(rs, len);
Eric Blakef394b2e2016-07-13 21:50:23 -06001785 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
Jason Wangeaed4832015-04-23 14:21:38 +08001786 MAX_QUEUE_NUM);
Jason Wangbcfa4d62015-04-23 14:21:39 +08001787 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
Hani Benhabiles11b389f2014-05-07 23:41:32 +01001788 const char *name = ncs[i]->name;
1789 if (strncmp(str, name, len)) {
1790 continue;
1791 }
Eric Blake08712fc2020-03-17 15:17:11 -05001792 if (ncs[i]->is_netdev) {
Hani Benhabiles11b389f2014-05-07 23:41:32 +01001793 readline_add_completion(rs, name);
1794 }
1795 }
1796}
1797
Lluís Vilanovabd712112016-07-11 12:53:51 +02001798void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
1799{
1800 size_t len;
1801
1802 len = strlen(str);
1803 readline_set_completion_index(rs, len);
1804 if (nb_args == 2) {
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001805 TraceEventIter iter;
1806 TraceEvent *ev;
1807 char *pattern = g_strdup_printf("%s*", str);
Gerd Hoffmann117856c2021-06-01 15:24:03 +02001808 trace_event_iter_init_pattern(&iter, pattern);
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001809 while ((ev = trace_event_iter_next(&iter)) != NULL) {
1810 readline_add_completion(rs, trace_event_get_name(ev));
Lluís Vilanovabd712112016-07-11 12:53:51 +02001811 }
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001812 g_free(pattern);
Lluís Vilanovabd712112016-07-11 12:53:51 +02001813 }
1814}
1815
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01001816void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
1817{
1818 size_t len;
1819
1820 len = strlen(str);
1821 readline_set_completion_index(rs, len);
1822 if (nb_args == 2) {
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001823 TraceEventIter iter;
1824 TraceEvent *ev;
1825 char *pattern = g_strdup_printf("%s*", str);
Gerd Hoffmann117856c2021-06-01 15:24:03 +02001826 trace_event_iter_init_pattern(&iter, pattern);
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001827 while ((ev = trace_event_iter_next(&iter)) != NULL) {
1828 readline_add_completion(rs, trace_event_get_name(ev));
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01001829 }
Daniel P. Berrange0d4e9952016-10-04 14:35:43 +01001830 g_free(pattern);
Dr. David Alan Gilbert987bd272015-08-14 11:27:43 +01001831 } else if (nb_args == 3) {
1832 add_completion_option(rs, str, "on");
1833 add_completion_option(rs, str, "off");
1834 }
1835}
1836
Hani Benhabilesd0ece342014-05-27 23:39:31 +01001837void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
1838{
Hani Benhabiles4bb08af2014-07-29 23:22:40 +01001839 int i;
1840
Hani Benhabilesd0ece342014-05-27 23:39:31 +01001841 if (nb_args != 2) {
1842 return;
1843 }
1844 readline_set_completion_index(rs, strlen(str));
Michal Privoznik14d53b42017-09-07 10:05:24 +02001845 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
1846 add_completion_option(rs, str, WatchdogAction_str(i));
Hani Benhabiles4bb08af2014-07-29 23:22:40 +01001847 }
Hani Benhabilesd0ece342014-05-27 23:39:31 +01001848}
1849
Hani Benhabilesc68a0402014-05-27 23:39:32 +01001850void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
1851 const char *str)
1852{
1853 size_t len;
1854
1855 len = strlen(str);
1856 readline_set_completion_index(rs, len);
1857 if (nb_args == 2) {
1858 int i;
Eric Blake7fb1cf12015-11-18 01:52:57 -07001859 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02001860 const char *name = MigrationCapability_str(i);
Hani Benhabilesc68a0402014-05-27 23:39:32 +01001861 if (!strncmp(str, name, len)) {
1862 readline_add_completion(rs, name);
1863 }
1864 }
1865 } else if (nb_args == 3) {
1866 add_completion_option(rs, str, "on");
1867 add_completion_option(rs, str, "off");
1868 }
1869}
1870
Liang Li50e9a622015-03-23 16:32:29 +08001871void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
1872 const char *str)
1873{
1874 size_t len;
1875
1876 len = strlen(str);
1877 readline_set_completion_index(rs, len);
1878 if (nb_args == 2) {
1879 int i;
Eric Blake7fb1cf12015-11-18 01:52:57 -07001880 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
Markus Armbruster977c7362017-08-24 10:46:08 +02001881 const char *name = MigrationParameter_str(i);
Liang Li50e9a622015-03-23 16:32:29 +08001882 if (!strncmp(str, name, len)) {
1883 readline_add_completion(rs, name);
1884 }
1885 }
1886 }
1887}
1888
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001889static void vm_completion(ReadLineState *rs, const char *str)
1890{
1891 size_t len;
Kevin Wolf7c8eece2016-03-22 18:58:50 +01001892 BlockDriverState *bs;
Kevin Wolf88be7b42016-05-20 18:49:07 +02001893 BdrvNextIterator it;
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001894
1895 len = strlen(str);
1896 readline_set_completion_index(rs, len);
Kevin Wolf7c8eece2016-03-22 18:58:50 +01001897
Kevin Wolf88be7b42016-05-20 18:49:07 +02001898 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001899 SnapshotInfoList *snapshots, *snapshot;
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03001900 AioContext *ctx = bdrv_get_aio_context(bs);
1901 bool ok = false;
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001902
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03001903 aio_context_acquire(ctx);
1904 if (bdrv_can_snapshot(bs)) {
1905 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
1906 }
1907 aio_context_release(ctx);
1908 if (!ok) {
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001909 continue;
1910 }
Denis V. Lunev6bf1faa2015-11-04 20:19:42 +03001911
Hani Benhabilesb21631f2014-05-27 23:39:37 +01001912 snapshot = snapshots;
1913 while (snapshot) {
1914 char *completion = snapshot->value->name;
1915 if (!strncmp(str, completion, len)) {
1916 readline_add_completion(rs, completion);
1917 }
1918 completion = snapshot->value->id;
1919 if (!strncmp(str, completion, len)) {
1920 readline_add_completion(rs, completion);
1921 }
1922 snapshot = snapshot->next;
1923 }
1924 qapi_free_SnapshotInfoList(snapshots);
1925 }
1926
1927}
1928
1929void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
1930{
1931 if (nb_args == 2) {
1932 vm_completion(rs, str);
1933 }
1934}
1935
1936void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
1937{
1938 if (nb_args == 2) {
1939 vm_completion(rs, str);
1940 }
1941}
1942
Wayne Xia816f8922011-10-12 11:32:41 +08001943static int
1944compare_mon_cmd(const void *a, const void *b)
1945{
Kevin Wolfa0cd5e12019-06-13 17:33:56 +02001946 return strcmp(((const HMPCommand *)a)->name,
1947 ((const HMPCommand *)b)->name);
Wayne Xia816f8922011-10-12 11:32:41 +08001948}
1949
1950static void sortcmdlist(void)
1951{
Kevin Wolfa0cd5e12019-06-13 17:33:56 +02001952 qsort(hmp_cmds, ARRAY_SIZE(hmp_cmds) - 1,
1953 sizeof(*hmp_cmds),
1954 compare_mon_cmd);
1955 qsort(hmp_info_cmds, ARRAY_SIZE(hmp_info_cmds) - 1,
1956 sizeof(*hmp_info_cmds),
1957 compare_mon_cmd);
Wayne Xia816f8922011-10-12 11:32:41 +08001958}
1959
Gerd Hoffmannf0e48cb2021-06-24 12:38:32 +02001960void monitor_register_hmp(const char *name, bool info,
1961 void (*cmd)(Monitor *mon, const QDict *qdict))
1962{
1963 HMPCommand *table = info ? hmp_info_cmds : hmp_cmds;
1964
1965 while (table->name != NULL) {
1966 if (strcmp(table->name, name) == 0) {
1967 g_assert(table->cmd == NULL);
1968 table->cmd = cmd;
1969 return;
1970 }
1971 table++;
1972 }
1973 g_assert_not_reached();
1974}
1975
Peter Xu6adf08d2018-03-09 16:59:50 +08001976void monitor_init_globals(void)
1977{
Kevin Wolf1d95db72019-06-13 17:34:02 +02001978 monitor_init_globals_core();
Peter Xu6adf08d2018-03-09 16:59:50 +08001979 monitor_init_qmp_commands();
Peter Xu6adf08d2018-03-09 16:59:50 +08001980 sortcmdlist();
Peter Xu47451462018-06-08 11:55:11 +08001981 qemu_mutex_init(&mon_fdsets_lock);
Peter Xu6adf08d2018-03-09 16:59:50 +08001982}