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