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