hmp: Update current monitor only in handle_hmp_command()
[qemu.git] / monitor / misc.c
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * 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 */
24
25 #include "qemu/osdep.h"
26 #include "monitor-internal.h"
27 #include "cpu.h"
28 #include "monitor/qdev.h"
29 #include "hw/usb.h"
30 #include "hw/pci/pci.h"
31 #include "sysemu/watchdog.h"
32 #include "hw/loader.h"
33 #include "exec/gdbstub.h"
34 #include "net/net.h"
35 #include "net/slirp.h"
36 #include "ui/qemu-spice.h"
37 #include "qemu/config-file.h"
38 #include "qemu/ctype.h"
39 #include "ui/console.h"
40 #include "ui/input.h"
41 #include "audio/audio.h"
42 #include "disas/disas.h"
43 #include "sysemu/balloon.h"
44 #include "qemu/timer.h"
45 #include "sysemu/hw_accel.h"
46 #include "sysemu/runstate.h"
47 #include "authz/list.h"
48 #include "qapi/util.h"
49 #include "sysemu/blockdev.h"
50 #include "sysemu/sysemu.h"
51 #include "sysemu/tcg.h"
52 #include "sysemu/tpm.h"
53 #include "qapi/qmp/qdict.h"
54 #include "qapi/qmp/qerror.h"
55 #include "qapi/qmp/qstring.h"
56 #include "qom/object_interfaces.h"
57 #include "trace/control.h"
58 #include "monitor/hmp-target.h"
59 #include "monitor/hmp.h"
60 #ifdef CONFIG_TRACE_SIMPLE
61 #include "trace/simple.h"
62 #endif
63 #include "exec/memory.h"
64 #include "exec/exec-all.h"
65 #include "qemu/option.h"
66 #include "qemu/thread.h"
67 #include "block/qapi.h"
68 #include "block/block-hmp-cmds.h"
69 #include "qapi/qapi-commands-char.h"
70 #include "qapi/qapi-commands-control.h"
71 #include "qapi/qapi-commands-migration.h"
72 #include "qapi/qapi-commands-misc.h"
73 #include "qapi/qapi-commands-qom.h"
74 #include "qapi/qapi-commands-trace.h"
75 #include "qapi/qapi-init-commands.h"
76 #include "qapi/error.h"
77 #include "qapi/qmp-event.h"
78 #include "sysemu/cpus.h"
79 #include "qemu/cutils.h"
80 #include "tcg/tcg.h"
81
82 #if defined(TARGET_S390X)
83 #include "hw/s390x/storage-keys.h"
84 #include "hw/s390x/storage-attributes.h"
85 #endif
86
87 /* file descriptors passed via SCM_RIGHTS */
88 typedef struct mon_fd_t mon_fd_t;
89 struct mon_fd_t {
90 char *name;
91 int fd;
92 QLIST_ENTRY(mon_fd_t) next;
93 };
94
95 /* file descriptor associated with a file descriptor set */
96 typedef struct MonFdsetFd MonFdsetFd;
97 struct MonFdsetFd {
98 int fd;
99 bool removed;
100 char *opaque;
101 QLIST_ENTRY(MonFdsetFd) next;
102 };
103
104 /* file descriptor set containing fds passed via SCM_RIGHTS */
105 typedef struct MonFdset MonFdset;
106 struct MonFdset {
107 int64_t id;
108 QLIST_HEAD(, MonFdsetFd) fds;
109 QLIST_HEAD(, MonFdsetFd) dup_fds;
110 QLIST_ENTRY(MonFdset) next;
111 };
112
113 /* Protects mon_fdsets */
114 static QemuMutex mon_fdsets_lock;
115 static QLIST_HEAD(, MonFdset) mon_fdsets;
116
117 static HMPCommand hmp_info_cmds[];
118
119 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
120 int64_t cpu_index, Error **errp)
121 {
122 char *output = NULL;
123 MonitorHMP hmp = {};
124
125 monitor_data_init(&hmp.common, false, true, false);
126
127 if (has_cpu_index) {
128 int ret = monitor_set_cpu(&hmp.common, cpu_index);
129 if (ret < 0) {
130 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
131 "a CPU number");
132 goto out;
133 }
134 }
135
136 handle_hmp_command(&hmp, command_line);
137
138 WITH_QEMU_LOCK_GUARD(&hmp.common.mon_lock) {
139 if (qstring_get_length(hmp.common.outbuf) > 0) {
140 output = g_strdup(qstring_get_str(hmp.common.outbuf));
141 } else {
142 output = g_strdup("");
143 }
144 }
145
146 out:
147 monitor_data_destroy(&hmp.common);
148 return output;
149 }
150
151 /**
152 * Is @name in the '|' separated list of names @list?
153 */
154 int hmp_compare_cmd(const char *name, const char *list)
155 {
156 const char *p, *pstart;
157 int len;
158 len = strlen(name);
159 p = list;
160 for (;;) {
161 pstart = p;
162 p = qemu_strchrnul(p, '|');
163 if ((p - pstart) == len && !memcmp(pstart, name, len)) {
164 return 1;
165 }
166 if (*p == '\0') {
167 break;
168 }
169 p++;
170 }
171 return 0;
172 }
173
174 static void do_help_cmd(Monitor *mon, const QDict *qdict)
175 {
176 help_cmd(mon, qdict_get_try_str(qdict, "name"));
177 }
178
179 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
180 {
181 const char *tp_name = qdict_get_str(qdict, "name");
182 bool new_state = qdict_get_bool(qdict, "option");
183 bool has_vcpu = qdict_haskey(qdict, "vcpu");
184 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
185 Error *local_err = NULL;
186
187 if (vcpu < 0) {
188 monitor_printf(mon, "argument vcpu must be positive");
189 return;
190 }
191
192 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
193 if (local_err) {
194 error_report_err(local_err);
195 }
196 }
197
198 #ifdef CONFIG_TRACE_SIMPLE
199 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
200 {
201 const char *op = qdict_get_try_str(qdict, "op");
202 const char *arg = qdict_get_try_str(qdict, "arg");
203
204 if (!op) {
205 st_print_trace_file_status();
206 } else if (!strcmp(op, "on")) {
207 st_set_trace_file_enabled(true);
208 } else if (!strcmp(op, "off")) {
209 st_set_trace_file_enabled(false);
210 } else if (!strcmp(op, "flush")) {
211 st_flush_trace_buffer();
212 } else if (!strcmp(op, "set")) {
213 if (arg) {
214 st_set_trace_file(arg);
215 }
216 } else {
217 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
218 help_cmd(mon, "trace-file");
219 }
220 }
221 #endif
222
223 static void hmp_info_help(Monitor *mon, const QDict *qdict)
224 {
225 help_cmd(mon, "info");
226 }
227
228 static void monitor_init_qmp_commands(void)
229 {
230 /*
231 * Two command lists:
232 * - qmp_commands contains all QMP commands
233 * - qmp_cap_negotiation_commands contains just
234 * "qmp_capabilities", to enforce capability negotiation
235 */
236
237 qmp_init_marshal(&qmp_commands);
238
239 qmp_register_command(&qmp_commands, "query-qmp-schema",
240 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
241 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
242 QCO_NO_OPTIONS);
243 qmp_register_command(&qmp_commands, "object-add", qmp_object_add,
244 QCO_NO_OPTIONS);
245
246 QTAILQ_INIT(&qmp_cap_negotiation_commands);
247 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
248 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
249 }
250
251 /* Set the current CPU defined by the user. Callers must hold BQL. */
252 int monitor_set_cpu(Monitor *mon, int cpu_index)
253 {
254 CPUState *cpu;
255
256 cpu = qemu_get_cpu(cpu_index);
257 if (cpu == NULL) {
258 return -1;
259 }
260 g_free(mon->mon_cpu_path);
261 mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
262 return 0;
263 }
264
265 /* Callers must hold BQL. */
266 static CPUState *mon_get_cpu_sync(Monitor *mon, bool synchronize)
267 {
268 CPUState *cpu = NULL;
269
270 if (mon->mon_cpu_path) {
271 cpu = (CPUState *) object_resolve_path_type(mon->mon_cpu_path,
272 TYPE_CPU, NULL);
273 if (!cpu) {
274 g_free(mon->mon_cpu_path);
275 mon->mon_cpu_path = NULL;
276 }
277 }
278 if (!mon->mon_cpu_path) {
279 if (!first_cpu) {
280 return NULL;
281 }
282 monitor_set_cpu(mon, first_cpu->cpu_index);
283 cpu = first_cpu;
284 }
285 assert(cpu != NULL);
286 if (synchronize) {
287 cpu_synchronize_state(cpu);
288 }
289 return cpu;
290 }
291
292 CPUState *mon_get_cpu(void)
293 {
294 return mon_get_cpu_sync(monitor_cur(), true);
295 }
296
297 CPUArchState *mon_get_cpu_env(void)
298 {
299 CPUState *cs = mon_get_cpu();
300
301 return cs ? cs->env_ptr : NULL;
302 }
303
304 int monitor_get_cpu_index(Monitor *mon)
305 {
306 CPUState *cs = mon_get_cpu_sync(mon, false);
307
308 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
309 }
310
311 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
312 {
313 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
314 CPUState *cs;
315
316 if (all_cpus) {
317 CPU_FOREACH(cs) {
318 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
319 cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
320 }
321 } else {
322 cs = mon_get_cpu();
323
324 if (!cs) {
325 monitor_printf(mon, "No CPU available\n");
326 return;
327 }
328
329 cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
330 }
331 }
332
333 #ifdef CONFIG_TCG
334 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
335 {
336 if (!tcg_enabled()) {
337 error_report("JIT information is only available with accel=tcg");
338 return;
339 }
340
341 dump_exec_info();
342 dump_drift_info();
343 }
344
345 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
346 {
347 dump_opcount_info();
348 }
349 #endif
350
351 static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
352 {
353 int64_t max = qdict_get_try_int(qdict, "max", 10);
354 bool mean = qdict_get_try_bool(qdict, "mean", false);
355 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
356 enum QSPSortBy sort_by;
357
358 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
359 qsp_report(max, sort_by, coalesce);
360 }
361
362 static void hmp_info_history(Monitor *mon, const QDict *qdict)
363 {
364 MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
365 int i;
366 const char *str;
367
368 if (!hmp_mon->rs) {
369 return;
370 }
371 i = 0;
372 for(;;) {
373 str = readline_get_history(hmp_mon->rs, i);
374 if (!str) {
375 break;
376 }
377 monitor_printf(mon, "%d: '%s'\n", i, str);
378 i++;
379 }
380 }
381
382 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
383 {
384 CPUState *cs = mon_get_cpu();
385
386 if (!cs) {
387 monitor_printf(mon, "No CPU available\n");
388 return;
389 }
390 cpu_dump_statistics(cs, 0);
391 }
392
393 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
394 {
395 const char *name = qdict_get_try_str(qdict, "name");
396 bool has_vcpu = qdict_haskey(qdict, "vcpu");
397 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
398 TraceEventInfoList *events;
399 TraceEventInfoList *elem;
400 Error *local_err = NULL;
401
402 if (name == NULL) {
403 name = "*";
404 }
405 if (vcpu < 0) {
406 monitor_printf(mon, "argument vcpu must be positive");
407 return;
408 }
409
410 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
411 if (local_err) {
412 error_report_err(local_err);
413 return;
414 }
415
416 for (elem = events; elem != NULL; elem = elem->next) {
417 monitor_printf(mon, "%s : state %u\n",
418 elem->value->name,
419 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
420 }
421 qapi_free_TraceEventInfoList(events);
422 }
423
424 void qmp_client_migrate_info(const char *protocol, const char *hostname,
425 bool has_port, int64_t port,
426 bool has_tls_port, int64_t tls_port,
427 bool has_cert_subject, const char *cert_subject,
428 Error **errp)
429 {
430 if (strcmp(protocol, "spice") == 0) {
431 if (!qemu_using_spice(errp)) {
432 return;
433 }
434
435 if (!has_port && !has_tls_port) {
436 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
437 return;
438 }
439
440 if (qemu_spice_migrate_info(hostname,
441 has_port ? port : -1,
442 has_tls_port ? tls_port : -1,
443 cert_subject)) {
444 error_setg(errp, QERR_UNDEFINED_ERROR);
445 return;
446 }
447 return;
448 }
449
450 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
451 }
452
453 static void hmp_logfile(Monitor *mon, const QDict *qdict)
454 {
455 Error *err = NULL;
456
457 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
458 if (err) {
459 error_report_err(err);
460 }
461 }
462
463 static void hmp_log(Monitor *mon, const QDict *qdict)
464 {
465 int mask;
466 const char *items = qdict_get_str(qdict, "items");
467
468 if (!strcmp(items, "none")) {
469 mask = 0;
470 } else {
471 mask = qemu_str_to_log_mask(items);
472 if (!mask) {
473 help_cmd(mon, "log");
474 return;
475 }
476 }
477 qemu_set_log(mask);
478 }
479
480 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
481 {
482 const char *option = qdict_get_try_str(qdict, "option");
483 if (!option || !strcmp(option, "on")) {
484 singlestep = 1;
485 } else if (!strcmp(option, "off")) {
486 singlestep = 0;
487 } else {
488 monitor_printf(mon, "unexpected option %s\n", option);
489 }
490 }
491
492 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
493 {
494 const char *device = qdict_get_try_str(qdict, "device");
495 if (!device)
496 device = "tcp::" DEFAULT_GDBSTUB_PORT;
497 if (gdbserver_start(device) < 0) {
498 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
499 device);
500 } else if (strcmp(device, "none") == 0) {
501 monitor_printf(mon, "Disabled gdbserver\n");
502 } else {
503 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
504 device);
505 }
506 }
507
508 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
509 {
510 const char *action = qdict_get_str(qdict, "action");
511 if (select_watchdog_action(action) == -1) {
512 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
513 }
514 }
515
516 static void monitor_printc(Monitor *mon, int c)
517 {
518 monitor_printf(mon, "'");
519 switch(c) {
520 case '\'':
521 monitor_printf(mon, "\\'");
522 break;
523 case '\\':
524 monitor_printf(mon, "\\\\");
525 break;
526 case '\n':
527 monitor_printf(mon, "\\n");
528 break;
529 case '\r':
530 monitor_printf(mon, "\\r");
531 break;
532 default:
533 if (c >= 32 && c <= 126) {
534 monitor_printf(mon, "%c", c);
535 } else {
536 monitor_printf(mon, "\\x%02x", c);
537 }
538 break;
539 }
540 monitor_printf(mon, "'");
541 }
542
543 static void memory_dump(Monitor *mon, int count, int format, int wsize,
544 hwaddr addr, int is_physical)
545 {
546 int l, line_size, i, max_digits, len;
547 uint8_t buf[16];
548 uint64_t v;
549 CPUState *cs = mon_get_cpu();
550
551 if (!cs && (format == 'i' || !is_physical)) {
552 monitor_printf(mon, "Can not dump without CPU\n");
553 return;
554 }
555
556 if (format == 'i') {
557 monitor_disas(mon, cs, addr, count, is_physical);
558 return;
559 }
560
561 len = wsize * count;
562 if (wsize == 1)
563 line_size = 8;
564 else
565 line_size = 16;
566 max_digits = 0;
567
568 switch(format) {
569 case 'o':
570 max_digits = DIV_ROUND_UP(wsize * 8, 3);
571 break;
572 default:
573 case 'x':
574 max_digits = (wsize * 8) / 4;
575 break;
576 case 'u':
577 case 'd':
578 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
579 break;
580 case 'c':
581 wsize = 1;
582 break;
583 }
584
585 while (len > 0) {
586 if (is_physical)
587 monitor_printf(mon, TARGET_FMT_plx ":", addr);
588 else
589 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
590 l = len;
591 if (l > line_size)
592 l = line_size;
593 if (is_physical) {
594 AddressSpace *as = cs ? cs->as : &address_space_memory;
595 MemTxResult r = address_space_read(as, addr,
596 MEMTXATTRS_UNSPECIFIED, buf, l);
597 if (r != MEMTX_OK) {
598 monitor_printf(mon, " Cannot access memory\n");
599 break;
600 }
601 } else {
602 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
603 monitor_printf(mon, " Cannot access memory\n");
604 break;
605 }
606 }
607 i = 0;
608 while (i < l) {
609 switch(wsize) {
610 default:
611 case 1:
612 v = ldub_p(buf + i);
613 break;
614 case 2:
615 v = lduw_p(buf + i);
616 break;
617 case 4:
618 v = (uint32_t)ldl_p(buf + i);
619 break;
620 case 8:
621 v = ldq_p(buf + i);
622 break;
623 }
624 monitor_printf(mon, " ");
625 switch(format) {
626 case 'o':
627 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
628 break;
629 case 'x':
630 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
631 break;
632 case 'u':
633 monitor_printf(mon, "%*" PRIu64, max_digits, v);
634 break;
635 case 'd':
636 monitor_printf(mon, "%*" PRId64, max_digits, v);
637 break;
638 case 'c':
639 monitor_printc(mon, v);
640 break;
641 }
642 i += wsize;
643 }
644 monitor_printf(mon, "\n");
645 addr += l;
646 len -= l;
647 }
648 }
649
650 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
651 {
652 int count = qdict_get_int(qdict, "count");
653 int format = qdict_get_int(qdict, "format");
654 int size = qdict_get_int(qdict, "size");
655 target_long addr = qdict_get_int(qdict, "addr");
656
657 memory_dump(mon, count, format, size, addr, 0);
658 }
659
660 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
661 {
662 int count = qdict_get_int(qdict, "count");
663 int format = qdict_get_int(qdict, "format");
664 int size = qdict_get_int(qdict, "size");
665 hwaddr addr = qdict_get_int(qdict, "addr");
666
667 memory_dump(mon, count, format, size, addr, 1);
668 }
669
670 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
671 {
672 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
673 addr, 1);
674
675 if (!mrs.mr) {
676 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
677 return NULL;
678 }
679
680 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
681 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
682 memory_region_unref(mrs.mr);
683 return NULL;
684 }
685
686 *p_mr = mrs.mr;
687 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
688 }
689
690 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
691 {
692 hwaddr addr = qdict_get_int(qdict, "addr");
693 Error *local_err = NULL;
694 MemoryRegion *mr = NULL;
695 void *ptr;
696
697 ptr = gpa2hva(&mr, addr, &local_err);
698 if (local_err) {
699 error_report_err(local_err);
700 return;
701 }
702
703 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
704 " (%s) is %p\n",
705 addr, mr->name, ptr);
706
707 memory_region_unref(mr);
708 }
709
710 static void hmp_gva2gpa(Monitor *mon, const QDict *qdict)
711 {
712 target_ulong addr = qdict_get_int(qdict, "addr");
713 MemTxAttrs attrs;
714 CPUState *cs = mon_get_cpu();
715 hwaddr gpa;
716
717 if (!cs) {
718 monitor_printf(mon, "No cpu\n");
719 return;
720 }
721
722 gpa = cpu_get_phys_page_attrs_debug(cs, addr & TARGET_PAGE_MASK, &attrs);
723 if (gpa == -1) {
724 monitor_printf(mon, "Unmapped\n");
725 } else {
726 monitor_printf(mon, "gpa: %#" HWADDR_PRIx "\n",
727 gpa + (addr & ~TARGET_PAGE_MASK));
728 }
729 }
730
731 #ifdef CONFIG_LINUX
732 static uint64_t vtop(void *ptr, Error **errp)
733 {
734 uint64_t pinfo;
735 uint64_t ret = -1;
736 uintptr_t addr = (uintptr_t) ptr;
737 uintptr_t pagesize = qemu_real_host_page_size;
738 off_t offset = addr / pagesize * sizeof(pinfo);
739 int fd;
740
741 fd = open("/proc/self/pagemap", O_RDONLY);
742 if (fd == -1) {
743 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
744 return -1;
745 }
746
747 /* Force copy-on-write if necessary. */
748 qatomic_add((uint8_t *)ptr, 0);
749
750 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
751 error_setg_errno(errp, errno, "Cannot read pagemap");
752 goto out;
753 }
754 if ((pinfo & (1ull << 63)) == 0) {
755 error_setg(errp, "Page not present");
756 goto out;
757 }
758 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
759
760 out:
761 close(fd);
762 return ret;
763 }
764
765 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
766 {
767 hwaddr addr = qdict_get_int(qdict, "addr");
768 Error *local_err = NULL;
769 MemoryRegion *mr = NULL;
770 void *ptr;
771 uint64_t physaddr;
772
773 ptr = gpa2hva(&mr, addr, &local_err);
774 if (local_err) {
775 error_report_err(local_err);
776 return;
777 }
778
779 physaddr = vtop(ptr, &local_err);
780 if (local_err) {
781 error_report_err(local_err);
782 } else {
783 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
784 " (%s) is 0x%" PRIx64 "\n",
785 addr, mr->name, (uint64_t) physaddr);
786 }
787
788 memory_region_unref(mr);
789 }
790 #endif
791
792 static void do_print(Monitor *mon, const QDict *qdict)
793 {
794 int format = qdict_get_int(qdict, "format");
795 hwaddr val = qdict_get_int(qdict, "val");
796
797 switch(format) {
798 case 'o':
799 monitor_printf(mon, "%#" HWADDR_PRIo, val);
800 break;
801 case 'x':
802 monitor_printf(mon, "%#" HWADDR_PRIx, val);
803 break;
804 case 'u':
805 monitor_printf(mon, "%" HWADDR_PRIu, val);
806 break;
807 default:
808 case 'd':
809 monitor_printf(mon, "%" HWADDR_PRId, val);
810 break;
811 case 'c':
812 monitor_printc(mon, val);
813 break;
814 }
815 monitor_printf(mon, "\n");
816 }
817
818 static void hmp_sum(Monitor *mon, const QDict *qdict)
819 {
820 uint32_t addr;
821 uint16_t sum;
822 uint32_t start = qdict_get_int(qdict, "start");
823 uint32_t size = qdict_get_int(qdict, "size");
824
825 sum = 0;
826 for(addr = start; addr < (start + size); addr++) {
827 uint8_t val = address_space_ldub(&address_space_memory, addr,
828 MEMTXATTRS_UNSPECIFIED, NULL);
829 /* BSD sum algorithm ('sum' Unix command) */
830 sum = (sum >> 1) | (sum << 15);
831 sum += val;
832 }
833 monitor_printf(mon, "%05d\n", sum);
834 }
835
836 static int mouse_button_state;
837
838 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
839 {
840 int dx, dy, dz, button;
841 const char *dx_str = qdict_get_str(qdict, "dx_str");
842 const char *dy_str = qdict_get_str(qdict, "dy_str");
843 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
844
845 dx = strtol(dx_str, NULL, 0);
846 dy = strtol(dy_str, NULL, 0);
847 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
848 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
849
850 if (dz_str) {
851 dz = strtol(dz_str, NULL, 0);
852 if (dz != 0) {
853 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
854 qemu_input_queue_btn(NULL, button, true);
855 qemu_input_event_sync();
856 qemu_input_queue_btn(NULL, button, false);
857 }
858 }
859 qemu_input_event_sync();
860 }
861
862 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
863 {
864 static uint32_t bmap[INPUT_BUTTON__MAX] = {
865 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
866 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
867 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
868 };
869 int button_state = qdict_get_int(qdict, "button_state");
870
871 if (mouse_button_state == button_state) {
872 return;
873 }
874 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
875 qemu_input_event_sync();
876 mouse_button_state = button_state;
877 }
878
879 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
880 {
881 int size = qdict_get_int(qdict, "size");
882 int addr = qdict_get_int(qdict, "addr");
883 int has_index = qdict_haskey(qdict, "index");
884 uint32_t val;
885 int suffix;
886
887 if (has_index) {
888 int index = qdict_get_int(qdict, "index");
889 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
890 addr++;
891 }
892 addr &= 0xffff;
893
894 switch(size) {
895 default:
896 case 1:
897 val = cpu_inb(addr);
898 suffix = 'b';
899 break;
900 case 2:
901 val = cpu_inw(addr);
902 suffix = 'w';
903 break;
904 case 4:
905 val = cpu_inl(addr);
906 suffix = 'l';
907 break;
908 }
909 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
910 suffix, addr, size * 2, val);
911 }
912
913 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
914 {
915 int size = qdict_get_int(qdict, "size");
916 int addr = qdict_get_int(qdict, "addr");
917 int val = qdict_get_int(qdict, "val");
918
919 addr &= IOPORTS_MASK;
920
921 switch (size) {
922 default:
923 case 1:
924 cpu_outb(addr, val);
925 break;
926 case 2:
927 cpu_outw(addr, val);
928 break;
929 case 4:
930 cpu_outl(addr, val);
931 break;
932 }
933 }
934
935 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
936 {
937 Error *local_err = NULL;
938 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
939
940 qemu_boot_set(bootdevice, &local_err);
941 if (local_err) {
942 error_report_err(local_err);
943 } else {
944 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
945 }
946 }
947
948 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
949 {
950 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
951 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
952 bool owner = qdict_get_try_bool(qdict, "owner", false);
953 bool disabled = qdict_get_try_bool(qdict, "disabled", false);
954
955 mtree_info(flatview, dispatch_tree, owner, disabled);
956 }
957
958 #ifdef CONFIG_PROFILER
959
960 int64_t dev_time;
961
962 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
963 {
964 static int64_t last_cpu_exec_time;
965 int64_t cpu_exec_time;
966 int64_t delta;
967
968 cpu_exec_time = tcg_cpu_exec_time();
969 delta = cpu_exec_time - last_cpu_exec_time;
970
971 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
972 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
973 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
974 delta, delta / (double)NANOSECONDS_PER_SECOND);
975 last_cpu_exec_time = cpu_exec_time;
976 dev_time = 0;
977 }
978 #else
979 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
980 {
981 monitor_printf(mon, "Internal profiler not compiled\n");
982 }
983 #endif
984
985 /* Capture support */
986 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
987
988 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
989 {
990 int i;
991 CaptureState *s;
992
993 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
994 monitor_printf(mon, "[%d]: ", i);
995 s->ops.info (s->opaque);
996 }
997 }
998
999 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1000 {
1001 int i;
1002 int n = qdict_get_int(qdict, "n");
1003 CaptureState *s;
1004
1005 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1006 if (i == n) {
1007 s->ops.destroy (s->opaque);
1008 QLIST_REMOVE (s, entries);
1009 g_free (s);
1010 return;
1011 }
1012 }
1013 }
1014
1015 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1016 {
1017 const char *path = qdict_get_str(qdict, "path");
1018 int freq = qdict_get_try_int(qdict, "freq", 44100);
1019 int bits = qdict_get_try_int(qdict, "bits", 16);
1020 int nchannels = qdict_get_try_int(qdict, "nchannels", 2);
1021 const char *audiodev = qdict_get_str(qdict, "audiodev");
1022 CaptureState *s;
1023 AudioState *as = audio_state_by_name(audiodev);
1024
1025 if (!as) {
1026 monitor_printf(mon, "Audiodev '%s' not found\n", audiodev);
1027 return;
1028 }
1029
1030 s = g_malloc0 (sizeof (*s));
1031
1032 if (wav_start_capture(as, s, path, freq, bits, nchannels)) {
1033 monitor_printf(mon, "Failed to add wave capture\n");
1034 g_free (s);
1035 return;
1036 }
1037 QLIST_INSERT_HEAD (&capture_head, s, entries);
1038 }
1039
1040 static QAuthZList *find_auth(Monitor *mon, const char *name)
1041 {
1042 Object *obj;
1043 Object *container;
1044
1045 container = object_get_objects_root();
1046 obj = object_resolve_path_component(container, name);
1047 if (!obj) {
1048 monitor_printf(mon, "acl: unknown list '%s'\n", name);
1049 return NULL;
1050 }
1051
1052 return QAUTHZ_LIST(obj);
1053 }
1054
1055 static bool warn_acl;
1056 static void hmp_warn_acl(void)
1057 {
1058 if (warn_acl) {
1059 return;
1060 }
1061 error_report("The acl_show, acl_reset, acl_policy, acl_add, acl_remove "
1062 "commands are deprecated with no replacement. Authorization "
1063 "for VNC should be performed using the pluggable QAuthZ "
1064 "objects");
1065 warn_acl = true;
1066 }
1067
1068 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1069 {
1070 const char *aclname = qdict_get_str(qdict, "aclname");
1071 QAuthZList *auth = find_auth(mon, aclname);
1072 QAuthZListRuleList *rules;
1073 size_t i = 0;
1074
1075 hmp_warn_acl();
1076
1077 if (!auth) {
1078 return;
1079 }
1080
1081 monitor_printf(mon, "policy: %s\n",
1082 QAuthZListPolicy_str(auth->policy));
1083
1084 rules = auth->rules;
1085 while (rules) {
1086 QAuthZListRule *rule = rules->value;
1087 i++;
1088 monitor_printf(mon, "%zu: %s %s\n", i,
1089 QAuthZListPolicy_str(rule->policy),
1090 rule->match);
1091 rules = rules->next;
1092 }
1093 }
1094
1095 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1096 {
1097 const char *aclname = qdict_get_str(qdict, "aclname");
1098 QAuthZList *auth = find_auth(mon, aclname);
1099
1100 hmp_warn_acl();
1101
1102 if (!auth) {
1103 return;
1104 }
1105
1106 auth->policy = QAUTHZ_LIST_POLICY_DENY;
1107 qapi_free_QAuthZListRuleList(auth->rules);
1108 auth->rules = NULL;
1109 monitor_printf(mon, "acl: removed all rules\n");
1110 }
1111
1112 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1113 {
1114 const char *aclname = qdict_get_str(qdict, "aclname");
1115 const char *policy = qdict_get_str(qdict, "policy");
1116 QAuthZList *auth = find_auth(mon, aclname);
1117 int val;
1118 Error *err = NULL;
1119
1120 hmp_warn_acl();
1121
1122 if (!auth) {
1123 return;
1124 }
1125
1126 val = qapi_enum_parse(&QAuthZListPolicy_lookup,
1127 policy,
1128 QAUTHZ_LIST_POLICY_DENY,
1129 &err);
1130 if (err) {
1131 error_free(err);
1132 monitor_printf(mon, "acl: unknown policy '%s', "
1133 "expected 'deny' or 'allow'\n", policy);
1134 } else {
1135 auth->policy = val;
1136 if (auth->policy == QAUTHZ_LIST_POLICY_ALLOW) {
1137 monitor_printf(mon, "acl: policy set to 'allow'\n");
1138 } else {
1139 monitor_printf(mon, "acl: policy set to 'deny'\n");
1140 }
1141 }
1142 }
1143
1144 static QAuthZListFormat hmp_acl_get_format(const char *match)
1145 {
1146 if (strchr(match, '*')) {
1147 return QAUTHZ_LIST_FORMAT_GLOB;
1148 } else {
1149 return QAUTHZ_LIST_FORMAT_EXACT;
1150 }
1151 }
1152
1153 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1154 {
1155 const char *aclname = qdict_get_str(qdict, "aclname");
1156 const char *match = qdict_get_str(qdict, "match");
1157 const char *policystr = qdict_get_str(qdict, "policy");
1158 int has_index = qdict_haskey(qdict, "index");
1159 int index = qdict_get_try_int(qdict, "index", -1);
1160 QAuthZList *auth = find_auth(mon, aclname);
1161 Error *err = NULL;
1162 QAuthZListPolicy policy;
1163 QAuthZListFormat format;
1164 size_t i = 0;
1165
1166 hmp_warn_acl();
1167
1168 if (!auth) {
1169 return;
1170 }
1171
1172 policy = qapi_enum_parse(&QAuthZListPolicy_lookup,
1173 policystr,
1174 QAUTHZ_LIST_POLICY_DENY,
1175 &err);
1176 if (err) {
1177 error_free(err);
1178 monitor_printf(mon, "acl: unknown policy '%s', "
1179 "expected 'deny' or 'allow'\n", policystr);
1180 return;
1181 }
1182
1183 format = hmp_acl_get_format(match);
1184
1185 if (has_index && index == 0) {
1186 monitor_printf(mon, "acl: unable to add acl entry\n");
1187 return;
1188 }
1189
1190 if (has_index) {
1191 i = qauthz_list_insert_rule(auth, match, policy,
1192 format, index - 1, &err);
1193 } else {
1194 i = qauthz_list_append_rule(auth, match, policy,
1195 format, &err);
1196 }
1197 if (err) {
1198 monitor_printf(mon, "acl: unable to add rule: %s",
1199 error_get_pretty(err));
1200 error_free(err);
1201 } else {
1202 monitor_printf(mon, "acl: added rule at position %zu\n", i + 1);
1203 }
1204 }
1205
1206 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1207 {
1208 const char *aclname = qdict_get_str(qdict, "aclname");
1209 const char *match = qdict_get_str(qdict, "match");
1210 QAuthZList *auth = find_auth(mon, aclname);
1211 ssize_t i = 0;
1212
1213 hmp_warn_acl();
1214
1215 if (!auth) {
1216 return;
1217 }
1218
1219 i = qauthz_list_delete_rule(auth, match);
1220 if (i >= 0) {
1221 monitor_printf(mon, "acl: removed rule at position %zu\n", i + 1);
1222 } else {
1223 monitor_printf(mon, "acl: no matching acl entry\n");
1224 }
1225 }
1226
1227 void qmp_getfd(const char *fdname, Error **errp)
1228 {
1229 Monitor *cur_mon = monitor_cur();
1230 mon_fd_t *monfd;
1231 int fd, tmp_fd;
1232
1233 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
1234 if (fd == -1) {
1235 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1236 return;
1237 }
1238
1239 if (qemu_isdigit(fdname[0])) {
1240 close(fd);
1241 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1242 "a name not starting with a digit");
1243 return;
1244 }
1245
1246 QEMU_LOCK_GUARD(&cur_mon->mon_lock);
1247 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1248 if (strcmp(monfd->name, fdname) != 0) {
1249 continue;
1250 }
1251
1252 tmp_fd = monfd->fd;
1253 monfd->fd = fd;
1254 /* Make sure close() is outside critical section */
1255 close(tmp_fd);
1256 return;
1257 }
1258
1259 monfd = g_malloc0(sizeof(mon_fd_t));
1260 monfd->name = g_strdup(fdname);
1261 monfd->fd = fd;
1262
1263 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1264 }
1265
1266 void qmp_closefd(const char *fdname, Error **errp)
1267 {
1268 Monitor *cur_mon = monitor_cur();
1269 mon_fd_t *monfd;
1270 int tmp_fd;
1271
1272 qemu_mutex_lock(&cur_mon->mon_lock);
1273 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1274 if (strcmp(monfd->name, fdname) != 0) {
1275 continue;
1276 }
1277
1278 QLIST_REMOVE(monfd, next);
1279 tmp_fd = monfd->fd;
1280 g_free(monfd->name);
1281 g_free(monfd);
1282 qemu_mutex_unlock(&cur_mon->mon_lock);
1283 /* Make sure close() is outside critical section */
1284 close(tmp_fd);
1285 return;
1286 }
1287
1288 qemu_mutex_unlock(&cur_mon->mon_lock);
1289 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1290 }
1291
1292 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1293 {
1294 mon_fd_t *monfd;
1295
1296 QEMU_LOCK_GUARD(&mon->mon_lock);
1297 QLIST_FOREACH(monfd, &mon->fds, next) {
1298 int fd;
1299
1300 if (strcmp(monfd->name, fdname) != 0) {
1301 continue;
1302 }
1303
1304 fd = monfd->fd;
1305
1306 /* caller takes ownership of fd */
1307 QLIST_REMOVE(monfd, next);
1308 g_free(monfd->name);
1309 g_free(monfd);
1310
1311 return fd;
1312 }
1313
1314 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1315 return -1;
1316 }
1317
1318 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1319 {
1320 MonFdsetFd *mon_fdset_fd;
1321 MonFdsetFd *mon_fdset_fd_next;
1322
1323 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1324 if ((mon_fdset_fd->removed ||
1325 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1326 runstate_is_running()) {
1327 close(mon_fdset_fd->fd);
1328 g_free(mon_fdset_fd->opaque);
1329 QLIST_REMOVE(mon_fdset_fd, next);
1330 g_free(mon_fdset_fd);
1331 }
1332 }
1333
1334 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
1335 QLIST_REMOVE(mon_fdset, next);
1336 g_free(mon_fdset);
1337 }
1338 }
1339
1340 void monitor_fdsets_cleanup(void)
1341 {
1342 MonFdset *mon_fdset;
1343 MonFdset *mon_fdset_next;
1344
1345 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1346 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1347 monitor_fdset_cleanup(mon_fdset);
1348 }
1349 }
1350
1351 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1352 const char *opaque, Error **errp)
1353 {
1354 int fd;
1355 Monitor *mon = monitor_cur();
1356 AddfdInfo *fdinfo;
1357
1358 fd = qemu_chr_fe_get_msgfd(&mon->chr);
1359 if (fd == -1) {
1360 error_setg(errp, QERR_FD_NOT_SUPPLIED);
1361 goto error;
1362 }
1363
1364 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1365 has_opaque, opaque, errp);
1366 if (fdinfo) {
1367 return fdinfo;
1368 }
1369
1370 error:
1371 if (fd != -1) {
1372 close(fd);
1373 }
1374 return NULL;
1375 }
1376
1377 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1378 {
1379 MonFdset *mon_fdset;
1380 MonFdsetFd *mon_fdset_fd;
1381 char fd_str[60];
1382
1383 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1384 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1385 if (mon_fdset->id != fdset_id) {
1386 continue;
1387 }
1388 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1389 if (has_fd) {
1390 if (mon_fdset_fd->fd != fd) {
1391 continue;
1392 }
1393 mon_fdset_fd->removed = true;
1394 break;
1395 } else {
1396 mon_fdset_fd->removed = true;
1397 }
1398 }
1399 if (has_fd && !mon_fdset_fd) {
1400 goto error;
1401 }
1402 monitor_fdset_cleanup(mon_fdset);
1403 return;
1404 }
1405
1406 error:
1407 if (has_fd) {
1408 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1409 fdset_id, fd);
1410 } else {
1411 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1412 }
1413 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
1414 }
1415
1416 FdsetInfoList *qmp_query_fdsets(Error **errp)
1417 {
1418 MonFdset *mon_fdset;
1419 MonFdsetFd *mon_fdset_fd;
1420 FdsetInfoList *fdset_list = NULL;
1421
1422 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1423 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1424 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
1425 FdsetFdInfoList *fdsetfd_list = NULL;
1426
1427 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
1428 fdset_info->value->fdset_id = mon_fdset->id;
1429
1430 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1431 FdsetFdInfoList *fdsetfd_info;
1432
1433 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
1434 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
1435 fdsetfd_info->value->fd = mon_fdset_fd->fd;
1436 if (mon_fdset_fd->opaque) {
1437 fdsetfd_info->value->has_opaque = true;
1438 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
1439 } else {
1440 fdsetfd_info->value->has_opaque = false;
1441 }
1442
1443 fdsetfd_info->next = fdsetfd_list;
1444 fdsetfd_list = fdsetfd_info;
1445 }
1446
1447 fdset_info->value->fds = fdsetfd_list;
1448
1449 fdset_info->next = fdset_list;
1450 fdset_list = fdset_info;
1451 }
1452
1453 return fdset_list;
1454 }
1455
1456 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
1457 bool has_opaque, const char *opaque,
1458 Error **errp)
1459 {
1460 MonFdset *mon_fdset = NULL;
1461 MonFdsetFd *mon_fdset_fd;
1462 AddfdInfo *fdinfo;
1463
1464 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1465 if (has_fdset_id) {
1466 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1467 /* Break if match found or match impossible due to ordering by ID */
1468 if (fdset_id <= mon_fdset->id) {
1469 if (fdset_id < mon_fdset->id) {
1470 mon_fdset = NULL;
1471 }
1472 break;
1473 }
1474 }
1475 }
1476
1477 if (mon_fdset == NULL) {
1478 int64_t fdset_id_prev = -1;
1479 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
1480
1481 if (has_fdset_id) {
1482 if (fdset_id < 0) {
1483 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
1484 "a non-negative value");
1485 return NULL;
1486 }
1487 /* Use specified fdset ID */
1488 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1489 mon_fdset_cur = mon_fdset;
1490 if (fdset_id < mon_fdset_cur->id) {
1491 break;
1492 }
1493 }
1494 } else {
1495 /* Use first available fdset ID */
1496 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1497 mon_fdset_cur = mon_fdset;
1498 if (fdset_id_prev == mon_fdset_cur->id - 1) {
1499 fdset_id_prev = mon_fdset_cur->id;
1500 continue;
1501 }
1502 break;
1503 }
1504 }
1505
1506 mon_fdset = g_malloc0(sizeof(*mon_fdset));
1507 if (has_fdset_id) {
1508 mon_fdset->id = fdset_id;
1509 } else {
1510 mon_fdset->id = fdset_id_prev + 1;
1511 }
1512
1513 /* The fdset list is ordered by fdset ID */
1514 if (!mon_fdset_cur) {
1515 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
1516 } else if (mon_fdset->id < mon_fdset_cur->id) {
1517 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
1518 } else {
1519 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
1520 }
1521 }
1522
1523 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
1524 mon_fdset_fd->fd = fd;
1525 mon_fdset_fd->removed = false;
1526 if (has_opaque) {
1527 mon_fdset_fd->opaque = g_strdup(opaque);
1528 }
1529 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
1530
1531 fdinfo = g_malloc0(sizeof(*fdinfo));
1532 fdinfo->fdset_id = mon_fdset->id;
1533 fdinfo->fd = mon_fdset_fd->fd;
1534
1535 return fdinfo;
1536 }
1537
1538 int monitor_fdset_dup_fd_add(int64_t fdset_id, int flags)
1539 {
1540 #ifdef _WIN32
1541 return -ENOENT;
1542 #else
1543 MonFdset *mon_fdset;
1544
1545 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1546 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1547 MonFdsetFd *mon_fdset_fd;
1548 MonFdsetFd *mon_fdset_fd_dup;
1549 int fd = -1;
1550 int dup_fd;
1551 int mon_fd_flags;
1552
1553 if (mon_fdset->id != fdset_id) {
1554 continue;
1555 }
1556
1557 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1558 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
1559 if (mon_fd_flags == -1) {
1560 return -1;
1561 }
1562
1563 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
1564 fd = mon_fdset_fd->fd;
1565 break;
1566 }
1567 }
1568
1569 if (fd == -1) {
1570 errno = EACCES;
1571 return -1;
1572 }
1573
1574 dup_fd = qemu_dup_flags(fd, flags);
1575 if (dup_fd == -1) {
1576 return -1;
1577 }
1578
1579 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
1580 mon_fdset_fd_dup->fd = dup_fd;
1581 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
1582 return dup_fd;
1583 }
1584
1585 errno = ENOENT;
1586 return -1;
1587 #endif
1588 }
1589
1590 static int64_t monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
1591 {
1592 MonFdset *mon_fdset;
1593 MonFdsetFd *mon_fdset_fd_dup;
1594
1595 QEMU_LOCK_GUARD(&mon_fdsets_lock);
1596 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1597 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
1598 if (mon_fdset_fd_dup->fd == dup_fd) {
1599 if (remove) {
1600 QLIST_REMOVE(mon_fdset_fd_dup, next);
1601 g_free(mon_fdset_fd_dup);
1602 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
1603 monitor_fdset_cleanup(mon_fdset);
1604 }
1605 return -1;
1606 } else {
1607 return mon_fdset->id;
1608 }
1609 }
1610 }
1611 }
1612
1613 return -1;
1614 }
1615
1616 int64_t monitor_fdset_dup_fd_find(int dup_fd)
1617 {
1618 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
1619 }
1620
1621 void monitor_fdset_dup_fd_remove(int dup_fd)
1622 {
1623 monitor_fdset_dup_fd_find_remove(dup_fd, true);
1624 }
1625
1626 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
1627 {
1628 int fd;
1629 Error *local_err = NULL;
1630
1631 if (!qemu_isdigit(fdname[0]) && mon) {
1632 fd = monitor_get_fd(mon, fdname, &local_err);
1633 } else {
1634 fd = qemu_parse_fd(fdname);
1635 if (fd == -1) {
1636 error_setg(&local_err, "Invalid file descriptor number '%s'",
1637 fdname);
1638 }
1639 }
1640 if (local_err) {
1641 error_propagate(errp, local_err);
1642 assert(fd == -1);
1643 } else {
1644 assert(fd != -1);
1645 }
1646
1647 return fd;
1648 }
1649
1650 /* Please update hmp-commands.hx when adding or changing commands */
1651 static HMPCommand hmp_info_cmds[] = {
1652 #include "hmp-commands-info.h"
1653 { NULL, NULL, },
1654 };
1655
1656 /* hmp_cmds and hmp_info_cmds would be sorted at runtime */
1657 HMPCommand hmp_cmds[] = {
1658 #include "hmp-commands.h"
1659 { NULL, NULL, },
1660 };
1661
1662 /*
1663 * Set @pval to the value in the register identified by @name.
1664 * return 0 if OK, -1 if not found
1665 */
1666 int get_monitor_def(int64_t *pval, const char *name)
1667 {
1668 const MonitorDef *md = target_monitor_defs();
1669 CPUState *cs = mon_get_cpu();
1670 void *ptr;
1671 uint64_t tmp = 0;
1672 int ret;
1673
1674 if (cs == NULL || md == NULL) {
1675 return -1;
1676 }
1677
1678 for(; md->name != NULL; md++) {
1679 if (hmp_compare_cmd(name, md->name)) {
1680 if (md->get_value) {
1681 *pval = md->get_value(md, md->offset);
1682 } else {
1683 CPUArchState *env = mon_get_cpu_env();
1684 ptr = (uint8_t *)env + md->offset;
1685 switch(md->type) {
1686 case MD_I32:
1687 *pval = *(int32_t *)ptr;
1688 break;
1689 case MD_TLONG:
1690 *pval = *(target_long *)ptr;
1691 break;
1692 default:
1693 *pval = 0;
1694 break;
1695 }
1696 }
1697 return 0;
1698 }
1699 }
1700
1701 ret = target_get_monitor_def(cs, name, &tmp);
1702 if (!ret) {
1703 *pval = (target_long) tmp;
1704 }
1705
1706 return ret;
1707 }
1708
1709 static void add_completion_option(ReadLineState *rs, const char *str,
1710 const char *option)
1711 {
1712 if (!str || !option) {
1713 return;
1714 }
1715 if (!strncmp(option, str, strlen(str))) {
1716 readline_add_completion(rs, option);
1717 }
1718 }
1719
1720 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1721 {
1722 size_t len;
1723 ChardevBackendInfoList *list, *start;
1724
1725 if (nb_args != 2) {
1726 return;
1727 }
1728 len = strlen(str);
1729 readline_set_completion_index(rs, len);
1730
1731 start = list = qmp_query_chardev_backends(NULL);
1732 while (list) {
1733 const char *chr_name = list->value->name;
1734
1735 if (!strncmp(chr_name, str, len)) {
1736 readline_add_completion(rs, chr_name);
1737 }
1738 list = list->next;
1739 }
1740 qapi_free_ChardevBackendInfoList(start);
1741 }
1742
1743 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1744 {
1745 size_t len;
1746 int i;
1747
1748 if (nb_args != 2) {
1749 return;
1750 }
1751 len = strlen(str);
1752 readline_set_completion_index(rs, len);
1753 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
1754 add_completion_option(rs, str, NetClientDriver_str(i));
1755 }
1756 }
1757
1758 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
1759 {
1760 GSList *list, *elt;
1761 size_t len;
1762
1763 if (nb_args != 2) {
1764 return;
1765 }
1766
1767 len = strlen(str);
1768 readline_set_completion_index(rs, len);
1769 list = elt = object_class_get_list(TYPE_DEVICE, false);
1770 while (elt) {
1771 const char *name;
1772 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
1773 TYPE_DEVICE);
1774 name = object_class_get_name(OBJECT_CLASS(dc));
1775
1776 if (dc->user_creatable
1777 && !strncmp(name, str, len)) {
1778 readline_add_completion(rs, name);
1779 }
1780 elt = elt->next;
1781 }
1782 g_slist_free(list);
1783 }
1784
1785 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
1786 {
1787 GSList *list, *elt;
1788 size_t len;
1789
1790 if (nb_args != 2) {
1791 return;
1792 }
1793
1794 len = strlen(str);
1795 readline_set_completion_index(rs, len);
1796 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
1797 while (elt) {
1798 const char *name;
1799
1800 name = object_class_get_name(OBJECT_CLASS(elt->data));
1801 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
1802 readline_add_completion(rs, name);
1803 }
1804 elt = elt->next;
1805 }
1806 g_slist_free(list);
1807 }
1808
1809 static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
1810 {
1811 GSList **list = opaque;
1812 DeviceState *dev = (DeviceState *)object_dynamic_cast(obj, TYPE_DEVICE);
1813
1814 if (dev == NULL) {
1815 return 0;
1816 }
1817
1818 if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
1819 *list = g_slist_append(*list, dev);
1820 }
1821
1822 return 0;
1823 }
1824
1825 static GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
1826 {
1827 GSList *list = NULL;
1828
1829 object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
1830
1831 return list;
1832 }
1833
1834 static void peripheral_device_del_completion(ReadLineState *rs,
1835 const char *str, size_t len)
1836 {
1837 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
1838 GSList *list, *item;
1839
1840 list = qdev_build_hotpluggable_device_list(peripheral);
1841 if (!list) {
1842 return;
1843 }
1844
1845 for (item = list; item; item = g_slist_next(item)) {
1846 DeviceState *dev = item->data;
1847
1848 if (dev->id && !strncmp(str, dev->id, len)) {
1849 readline_add_completion(rs, dev->id);
1850 }
1851 }
1852
1853 g_slist_free(list);
1854 }
1855
1856 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
1857 {
1858 size_t len;
1859 ChardevInfoList *list, *start;
1860
1861 if (nb_args != 2) {
1862 return;
1863 }
1864 len = strlen(str);
1865 readline_set_completion_index(rs, len);
1866
1867 start = list = qmp_query_chardev(NULL);
1868 while (list) {
1869 ChardevInfo *chr = list->value;
1870
1871 if (!strncmp(chr->label, str, len)) {
1872 readline_add_completion(rs, chr->label);
1873 }
1874 list = list->next;
1875 }
1876 qapi_free_ChardevInfoList(start);
1877 }
1878
1879 static void ringbuf_completion(ReadLineState *rs, const char *str)
1880 {
1881 size_t len;
1882 ChardevInfoList *list, *start;
1883
1884 len = strlen(str);
1885 readline_set_completion_index(rs, len);
1886
1887 start = list = qmp_query_chardev(NULL);
1888 while (list) {
1889 ChardevInfo *chr_info = list->value;
1890
1891 if (!strncmp(chr_info->label, str, len)) {
1892 Chardev *chr = qemu_chr_find(chr_info->label);
1893 if (chr && CHARDEV_IS_RINGBUF(chr)) {
1894 readline_add_completion(rs, chr_info->label);
1895 }
1896 }
1897 list = list->next;
1898 }
1899 qapi_free_ChardevInfoList(start);
1900 }
1901
1902 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
1903 {
1904 if (nb_args != 2) {
1905 return;
1906 }
1907 ringbuf_completion(rs, str);
1908 }
1909
1910 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
1911 {
1912 size_t len;
1913
1914 if (nb_args != 2) {
1915 return;
1916 }
1917
1918 len = strlen(str);
1919 readline_set_completion_index(rs, len);
1920 peripheral_device_del_completion(rs, str, len);
1921 }
1922
1923 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
1924 {
1925 ObjectPropertyInfoList *list, *start;
1926 size_t len;
1927
1928 if (nb_args != 2) {
1929 return;
1930 }
1931 len = strlen(str);
1932 readline_set_completion_index(rs, len);
1933
1934 start = list = qmp_qom_list("/objects", NULL);
1935 while (list) {
1936 ObjectPropertyInfo *info = list->value;
1937
1938 if (!strncmp(info->type, "child<", 5)
1939 && !strncmp(info->name, str, len)) {
1940 readline_add_completion(rs, info->name);
1941 }
1942 list = list->next;
1943 }
1944 qapi_free_ObjectPropertyInfoList(start);
1945 }
1946
1947 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
1948 {
1949 int i;
1950 char *sep;
1951 size_t len;
1952
1953 if (nb_args != 2) {
1954 return;
1955 }
1956 sep = strrchr(str, '-');
1957 if (sep) {
1958 str = sep + 1;
1959 }
1960 len = strlen(str);
1961 readline_set_completion_index(rs, len);
1962 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
1963 if (!strncmp(str, QKeyCode_str(i), len)) {
1964 readline_add_completion(rs, QKeyCode_str(i));
1965 }
1966 }
1967 }
1968
1969 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
1970 {
1971 size_t len;
1972
1973 len = strlen(str);
1974 readline_set_completion_index(rs, len);
1975 if (nb_args == 2) {
1976 NetClientState *ncs[MAX_QUEUE_NUM];
1977 int count, i;
1978 count = qemu_find_net_clients_except(NULL, ncs,
1979 NET_CLIENT_DRIVER_NONE,
1980 MAX_QUEUE_NUM);
1981 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
1982 const char *name = ncs[i]->name;
1983 if (!strncmp(str, name, len)) {
1984 readline_add_completion(rs, name);
1985 }
1986 }
1987 } else if (nb_args == 3) {
1988 add_completion_option(rs, str, "on");
1989 add_completion_option(rs, str, "off");
1990 }
1991 }
1992
1993 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
1994 {
1995 int len, count, i;
1996 NetClientState *ncs[MAX_QUEUE_NUM];
1997
1998 if (nb_args != 2) {
1999 return;
2000 }
2001
2002 len = strlen(str);
2003 readline_set_completion_index(rs, len);
2004 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
2005 MAX_QUEUE_NUM);
2006 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
2007 const char *name = ncs[i]->name;
2008 if (strncmp(str, name, len)) {
2009 continue;
2010 }
2011 if (ncs[i]->is_netdev) {
2012 readline_add_completion(rs, name);
2013 }
2014 }
2015 }
2016
2017 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
2018 {
2019 size_t len;
2020
2021 len = strlen(str);
2022 readline_set_completion_index(rs, len);
2023 if (nb_args == 2) {
2024 TraceEventIter iter;
2025 TraceEvent *ev;
2026 char *pattern = g_strdup_printf("%s*", str);
2027 trace_event_iter_init(&iter, pattern);
2028 while ((ev = trace_event_iter_next(&iter)) != NULL) {
2029 readline_add_completion(rs, trace_event_get_name(ev));
2030 }
2031 g_free(pattern);
2032 }
2033 }
2034
2035 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
2036 {
2037 size_t len;
2038
2039 len = strlen(str);
2040 readline_set_completion_index(rs, len);
2041 if (nb_args == 2) {
2042 TraceEventIter iter;
2043 TraceEvent *ev;
2044 char *pattern = g_strdup_printf("%s*", str);
2045 trace_event_iter_init(&iter, pattern);
2046 while ((ev = trace_event_iter_next(&iter)) != NULL) {
2047 readline_add_completion(rs, trace_event_get_name(ev));
2048 }
2049 g_free(pattern);
2050 } else if (nb_args == 3) {
2051 add_completion_option(rs, str, "on");
2052 add_completion_option(rs, str, "off");
2053 }
2054 }
2055
2056 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
2057 {
2058 int i;
2059
2060 if (nb_args != 2) {
2061 return;
2062 }
2063 readline_set_completion_index(rs, strlen(str));
2064 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
2065 add_completion_option(rs, str, WatchdogAction_str(i));
2066 }
2067 }
2068
2069 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
2070 const char *str)
2071 {
2072 size_t len;
2073
2074 len = strlen(str);
2075 readline_set_completion_index(rs, len);
2076 if (nb_args == 2) {
2077 int i;
2078 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
2079 const char *name = MigrationCapability_str(i);
2080 if (!strncmp(str, name, len)) {
2081 readline_add_completion(rs, name);
2082 }
2083 }
2084 } else if (nb_args == 3) {
2085 add_completion_option(rs, str, "on");
2086 add_completion_option(rs, str, "off");
2087 }
2088 }
2089
2090 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
2091 const char *str)
2092 {
2093 size_t len;
2094
2095 len = strlen(str);
2096 readline_set_completion_index(rs, len);
2097 if (nb_args == 2) {
2098 int i;
2099 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
2100 const char *name = MigrationParameter_str(i);
2101 if (!strncmp(str, name, len)) {
2102 readline_add_completion(rs, name);
2103 }
2104 }
2105 }
2106 }
2107
2108 static void vm_completion(ReadLineState *rs, const char *str)
2109 {
2110 size_t len;
2111 BlockDriverState *bs;
2112 BdrvNextIterator it;
2113
2114 len = strlen(str);
2115 readline_set_completion_index(rs, len);
2116
2117 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
2118 SnapshotInfoList *snapshots, *snapshot;
2119 AioContext *ctx = bdrv_get_aio_context(bs);
2120 bool ok = false;
2121
2122 aio_context_acquire(ctx);
2123 if (bdrv_can_snapshot(bs)) {
2124 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
2125 }
2126 aio_context_release(ctx);
2127 if (!ok) {
2128 continue;
2129 }
2130
2131 snapshot = snapshots;
2132 while (snapshot) {
2133 char *completion = snapshot->value->name;
2134 if (!strncmp(str, completion, len)) {
2135 readline_add_completion(rs, completion);
2136 }
2137 completion = snapshot->value->id;
2138 if (!strncmp(str, completion, len)) {
2139 readline_add_completion(rs, completion);
2140 }
2141 snapshot = snapshot->next;
2142 }
2143 qapi_free_SnapshotInfoList(snapshots);
2144 }
2145
2146 }
2147
2148 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
2149 {
2150 if (nb_args == 2) {
2151 vm_completion(rs, str);
2152 }
2153 }
2154
2155 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
2156 {
2157 if (nb_args == 2) {
2158 vm_completion(rs, str);
2159 }
2160 }
2161
2162 static int
2163 compare_mon_cmd(const void *a, const void *b)
2164 {
2165 return strcmp(((const HMPCommand *)a)->name,
2166 ((const HMPCommand *)b)->name);
2167 }
2168
2169 static void sortcmdlist(void)
2170 {
2171 qsort(hmp_cmds, ARRAY_SIZE(hmp_cmds) - 1,
2172 sizeof(*hmp_cmds),
2173 compare_mon_cmd);
2174 qsort(hmp_info_cmds, ARRAY_SIZE(hmp_info_cmds) - 1,
2175 sizeof(*hmp_info_cmds),
2176 compare_mon_cmd);
2177 }
2178
2179 void monitor_init_globals(void)
2180 {
2181 monitor_init_globals_core();
2182 monitor_init_qmp_commands();
2183 sortcmdlist();
2184 qemu_mutex_init(&mon_fdsets_lock);
2185 }