]> git.proxmox.com Git - mirror_qemu.git/blob - monitor.c
job: Add Job.aio_context
[mirror_qemu.git] / monitor.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 <dirent.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-fe.h"
38 #include "chardev/char-io.h"
39 #include "chardev/char-mux.h"
40 #include "ui/qemu-spice.h"
41 #include "sysemu/numa.h"
42 #include "monitor/monitor.h"
43 #include "qemu/config-file.h"
44 #include "qemu/readline.h"
45 #include "ui/console.h"
46 #include "ui/input.h"
47 #include "sysemu/blockdev.h"
48 #include "sysemu/block-backend.h"
49 #include "audio/audio.h"
50 #include "disas/disas.h"
51 #include "sysemu/balloon.h"
52 #include "qemu/timer.h"
53 #include "sysemu/hw_accel.h"
54 #include "qemu/acl.h"
55 #include "sysemu/tpm.h"
56 #include "qapi/qmp/qdict.h"
57 #include "qapi/qmp/qerror.h"
58 #include "qapi/qmp/qnum.h"
59 #include "qapi/qmp/qstring.h"
60 #include "qapi/qmp/qjson.h"
61 #include "qapi/qmp/json-streamer.h"
62 #include "qapi/qmp/json-parser.h"
63 #include "qapi/qmp/qlist.h"
64 #include "qom/object_interfaces.h"
65 #include "trace-root.h"
66 #include "trace/control.h"
67 #include "monitor/hmp-target.h"
68 #ifdef CONFIG_TRACE_SIMPLE
69 #include "trace/simple.h"
70 #endif
71 #include "exec/memory.h"
72 #include "exec/exec-all.h"
73 #include "qemu/log.h"
74 #include "qemu/option.h"
75 #include "hmp.h"
76 #include "qemu/thread.h"
77 #include "block/qapi.h"
78 #include "qapi/qapi-commands.h"
79 #include "qapi/qapi-events.h"
80 #include "qapi/error.h"
81 #include "qapi/qmp-event.h"
82 #include "qapi/qapi-introspect.h"
83 #include "sysemu/qtest.h"
84 #include "sysemu/cpus.h"
85 #include "sysemu/iothread.h"
86 #include "qemu/cutils.h"
87
88 #if defined(TARGET_S390X)
89 #include "hw/s390x/storage-keys.h"
90 #include "hw/s390x/storage-attributes.h"
91 #endif
92
93 /*
94 * Supported types:
95 *
96 * 'F' filename
97 * 'B' block device name
98 * 's' string (accept optional quote)
99 * 'S' it just appends the rest of the string (accept optional quote)
100 * 'O' option string of the form NAME=VALUE,...
101 * parsed according to QemuOptsList given by its name
102 * Example: 'device:O' uses qemu_device_opts.
103 * Restriction: only lists with empty desc are supported
104 * TODO lift the restriction
105 * 'i' 32 bit integer
106 * 'l' target long (32 or 64 bit)
107 * 'M' Non-negative target long (32 or 64 bit), in user mode the
108 * value is multiplied by 2^20 (think Mebibyte)
109 * 'o' octets (aka bytes)
110 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
111 * K, k suffix, which multiplies the value by 2^60 for suffixes E
112 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
113 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
114 * 'T' double
115 * user mode accepts an optional ms, us, ns suffix,
116 * which divides the value by 1e3, 1e6, 1e9, respectively
117 * '/' optional gdb-like print format (like "/10x")
118 *
119 * '?' optional type (for all types, except '/')
120 * '.' other form of optional type (for 'i' and 'l')
121 * 'b' boolean
122 * user mode accepts "on" or "off"
123 * '-' optional parameter (eg. '-f')
124 *
125 */
126
127 typedef struct mon_cmd_t {
128 const char *name;
129 const char *args_type;
130 const char *params;
131 const char *help;
132 void (*cmd)(Monitor *mon, const QDict *qdict);
133 /* @sub_table is a list of 2nd level of commands. If it does not exist,
134 * cmd should be used. If it exists, sub_table[?].cmd should be
135 * used, and cmd of 1st level plays the role of help function.
136 */
137 struct mon_cmd_t *sub_table;
138 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
139 } mon_cmd_t;
140
141 /* file descriptors passed via SCM_RIGHTS */
142 typedef struct mon_fd_t mon_fd_t;
143 struct mon_fd_t {
144 char *name;
145 int fd;
146 QLIST_ENTRY(mon_fd_t) next;
147 };
148
149 /* file descriptor associated with a file descriptor set */
150 typedef struct MonFdsetFd MonFdsetFd;
151 struct MonFdsetFd {
152 int fd;
153 bool removed;
154 char *opaque;
155 QLIST_ENTRY(MonFdsetFd) next;
156 };
157
158 /* file descriptor set containing fds passed via SCM_RIGHTS */
159 typedef struct MonFdset MonFdset;
160 struct MonFdset {
161 int64_t id;
162 QLIST_HEAD(, MonFdsetFd) fds;
163 QLIST_HEAD(, MonFdsetFd) dup_fds;
164 QLIST_ENTRY(MonFdset) next;
165 };
166
167 typedef struct {
168 JSONMessageParser parser;
169 /*
170 * When a client connects, we're in capabilities negotiation mode.
171 * When command qmp_capabilities succeeds, we go into command
172 * mode.
173 */
174 QmpCommandList *commands;
175 bool qmp_caps[QMP_CAPABILITY__MAX];
176 /*
177 * Protects qmp request/response queue. Please take monitor_lock
178 * first when used together.
179 */
180 QemuMutex qmp_queue_lock;
181 /* Input queue that holds all the parsed QMP requests */
182 GQueue *qmp_requests;
183 /* Output queue contains all the QMP responses in order */
184 GQueue *qmp_responses;
185 } MonitorQMP;
186
187 /*
188 * To prevent flooding clients, events can be throttled. The
189 * throttling is calculated globally, rather than per-Monitor
190 * instance.
191 */
192 typedef struct MonitorQAPIEventState {
193 QAPIEvent event; /* Throttling state for this event type and... */
194 QDict *data; /* ... data, see qapi_event_throttle_equal() */
195 QEMUTimer *timer; /* Timer for handling delayed events */
196 QDict *qdict; /* Delayed event (if any) */
197 } MonitorQAPIEventState;
198
199 typedef struct {
200 int64_t rate; /* Minimum time (in ns) between two events */
201 } MonitorQAPIEventConf;
202
203 struct Monitor {
204 CharBackend chr;
205 int reset_seen;
206 int flags;
207 int suspend_cnt; /* Needs to be accessed atomically */
208 bool skip_flush;
209 bool use_io_thr;
210
211 /* We can't access guest memory when holding the lock */
212 QemuMutex out_lock;
213 QString *outbuf;
214 guint out_watch;
215
216 /* Read under either BQL or out_lock, written with BQL+out_lock. */
217 int mux_out;
218
219 ReadLineState *rs;
220 MonitorQMP qmp;
221 gchar *mon_cpu_path;
222 BlockCompletionFunc *password_completion_cb;
223 void *password_opaque;
224 mon_cmd_t *cmd_table;
225 QLIST_HEAD(,mon_fd_t) fds;
226 QTAILQ_ENTRY(Monitor) entry;
227 };
228
229 /* Let's add monitor global variables to this struct. */
230 static struct {
231 IOThread *mon_iothread;
232 /* Bottom half to dispatch the requests received from IO thread */
233 QEMUBH *qmp_dispatcher_bh;
234 /* Bottom half to deliver the responses back to clients */
235 QEMUBH *qmp_respond_bh;
236 } mon_global;
237
238 struct QMPRequest {
239 /* Owner of the request */
240 Monitor *mon;
241 /* "id" field of the request */
242 QObject *id;
243 /* Request object to be handled */
244 QObject *req;
245 /*
246 * Whether we need to resume the monitor afterward. This flag is
247 * used to emulate the old QMP server behavior that the current
248 * command must be completed before execution of the next one.
249 */
250 bool need_resume;
251 };
252 typedef struct QMPRequest QMPRequest;
253
254 /* QMP checker flags */
255 #define QMP_ACCEPT_UNKNOWNS 1
256
257 /* Protects mon_list, monitor_event_state. */
258 static QemuMutex monitor_lock;
259
260 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
261 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
262 static int mon_refcount;
263
264 static mon_cmd_t mon_cmds[];
265 static mon_cmd_t info_cmds[];
266
267 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
268
269 Monitor *cur_mon;
270
271 static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
272
273 static void monitor_command_cb(void *opaque, const char *cmdline,
274 void *readline_opaque);
275
276 /**
277 * Is @mon a QMP monitor?
278 */
279 static inline bool monitor_is_qmp(const Monitor *mon)
280 {
281 return (mon->flags & MONITOR_USE_CONTROL);
282 }
283
284 /**
285 * Whether @mon is using readline? Note: not all HMP monitors use
286 * readline, e.g., gdbserver has a non-interactive HMP monitor, so
287 * readline is not used there.
288 */
289 static inline bool monitor_uses_readline(const Monitor *mon)
290 {
291 return mon->flags & MONITOR_USE_READLINE;
292 }
293
294 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
295 {
296 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
297 }
298
299 /**
300 * Is the current monitor, if any, a QMP monitor?
301 */
302 bool monitor_cur_is_qmp(void)
303 {
304 return cur_mon && monitor_is_qmp(cur_mon);
305 }
306
307 void monitor_read_command(Monitor *mon, int show_prompt)
308 {
309 if (!mon->rs)
310 return;
311
312 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
313 if (show_prompt)
314 readline_show_prompt(mon->rs);
315 }
316
317 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
318 void *opaque)
319 {
320 if (mon->rs) {
321 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
322 /* prompt is printed on return from the command handler */
323 return 0;
324 } else {
325 monitor_printf(mon, "terminal does not support password prompting\n");
326 return -ENOTTY;
327 }
328 }
329
330 static void qmp_request_free(QMPRequest *req)
331 {
332 qobject_unref(req->id);
333 qobject_unref(req->req);
334 g_free(req);
335 }
336
337 /* Must with the mon->qmp.qmp_queue_lock held */
338 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
339 {
340 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
341 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
342 }
343 }
344
345 /* Must with the mon->qmp.qmp_queue_lock held */
346 static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
347 {
348 while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
349 qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
350 }
351 }
352
353 static void monitor_qmp_cleanup_queues(Monitor *mon)
354 {
355 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
356 monitor_qmp_cleanup_req_queue_locked(mon);
357 monitor_qmp_cleanup_resp_queue_locked(mon);
358 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
359 }
360
361
362 static void monitor_flush_locked(Monitor *mon);
363
364 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
365 void *opaque)
366 {
367 Monitor *mon = opaque;
368
369 qemu_mutex_lock(&mon->out_lock);
370 mon->out_watch = 0;
371 monitor_flush_locked(mon);
372 qemu_mutex_unlock(&mon->out_lock);
373 return FALSE;
374 }
375
376 /* Called with mon->out_lock held. */
377 static void monitor_flush_locked(Monitor *mon)
378 {
379 int rc;
380 size_t len;
381 const char *buf;
382
383 if (mon->skip_flush) {
384 return;
385 }
386
387 buf = qstring_get_str(mon->outbuf);
388 len = qstring_get_length(mon->outbuf);
389
390 if (len && !mon->mux_out) {
391 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
392 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
393 /* all flushed or error */
394 qobject_unref(mon->outbuf);
395 mon->outbuf = qstring_new();
396 return;
397 }
398 if (rc > 0) {
399 /* partial write */
400 QString *tmp = qstring_from_str(buf + rc);
401 qobject_unref(mon->outbuf);
402 mon->outbuf = tmp;
403 }
404 if (mon->out_watch == 0) {
405 mon->out_watch =
406 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
407 monitor_unblocked, mon);
408 }
409 }
410 }
411
412 void monitor_flush(Monitor *mon)
413 {
414 qemu_mutex_lock(&mon->out_lock);
415 monitor_flush_locked(mon);
416 qemu_mutex_unlock(&mon->out_lock);
417 }
418
419 /* flush at every end of line */
420 static void monitor_puts(Monitor *mon, const char *str)
421 {
422 char c;
423
424 qemu_mutex_lock(&mon->out_lock);
425 for(;;) {
426 c = *str++;
427 if (c == '\0')
428 break;
429 if (c == '\n') {
430 qstring_append_chr(mon->outbuf, '\r');
431 }
432 qstring_append_chr(mon->outbuf, c);
433 if (c == '\n') {
434 monitor_flush_locked(mon);
435 }
436 }
437 qemu_mutex_unlock(&mon->out_lock);
438 }
439
440 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
441 {
442 char *buf;
443
444 if (!mon)
445 return;
446
447 if (monitor_is_qmp(mon)) {
448 return;
449 }
450
451 buf = g_strdup_vprintf(fmt, ap);
452 monitor_puts(mon, buf);
453 g_free(buf);
454 }
455
456 void monitor_printf(Monitor *mon, const char *fmt, ...)
457 {
458 va_list ap;
459 va_start(ap, fmt);
460 monitor_vprintf(mon, fmt, ap);
461 va_end(ap);
462 }
463
464 int monitor_fprintf(FILE *stream, const char *fmt, ...)
465 {
466 va_list ap;
467 va_start(ap, fmt);
468 monitor_vprintf((Monitor *)stream, fmt, ap);
469 va_end(ap);
470 return 0;
471 }
472
473 static void monitor_json_emitter_raw(Monitor *mon,
474 QObject *data)
475 {
476 QString *json;
477
478 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
479 qobject_to_json(data);
480 assert(json != NULL);
481
482 qstring_append_chr(json, '\n');
483 monitor_puts(mon, qstring_get_str(json));
484
485 qobject_unref(json);
486 }
487
488 static void monitor_json_emitter(Monitor *mon, QObject *data)
489 {
490 if (mon->use_io_thr) {
491 /*
492 * If using IO thread, we need to queue the item so that IO
493 * thread will do the rest for us. Take refcount so that
494 * caller won't free the data (which will be finally freed in
495 * responder thread).
496 */
497 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
498 g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
499 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
500 qemu_bh_schedule(mon_global.qmp_respond_bh);
501 } else {
502 /*
503 * If not using monitor IO thread, then we are in main thread.
504 * Do the emission right away.
505 */
506 monitor_json_emitter_raw(mon, data);
507 }
508 }
509
510 struct QMPResponse {
511 Monitor *mon;
512 QObject *data;
513 };
514 typedef struct QMPResponse QMPResponse;
515
516 /*
517 * Return one QMPResponse. The response is only valid if
518 * response.data is not NULL.
519 */
520 static QMPResponse monitor_qmp_response_pop_one(void)
521 {
522 Monitor *mon;
523 QObject *data = NULL;
524
525 qemu_mutex_lock(&monitor_lock);
526 QTAILQ_FOREACH(mon, &mon_list, entry) {
527 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
528 data = g_queue_pop_head(mon->qmp.qmp_responses);
529 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
530 if (data) {
531 break;
532 }
533 }
534 qemu_mutex_unlock(&monitor_lock);
535 return (QMPResponse) { .mon = mon, .data = data };
536 }
537
538 static void monitor_qmp_bh_responder(void *opaque)
539 {
540 QMPResponse response;
541
542 while (true) {
543 response = monitor_qmp_response_pop_one();
544 if (!response.data) {
545 break;
546 }
547 monitor_json_emitter_raw(response.mon, response.data);
548 qobject_unref(response.data);
549 }
550 }
551
552 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
553 /* Limit guest-triggerable events to 1 per second */
554 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
555 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
556 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
557 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
558 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
559 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
560 };
561
562 GHashTable *monitor_qapi_event_state;
563
564 /*
565 * Emits the event to every monitor instance, @event is only used for trace
566 * Called with monitor_lock held.
567 */
568 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
569 {
570 Monitor *mon;
571
572 trace_monitor_protocol_event_emit(event, qdict);
573 QTAILQ_FOREACH(mon, &mon_list, entry) {
574 if (monitor_is_qmp(mon)
575 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
576 monitor_json_emitter(mon, QOBJECT(qdict));
577 }
578 }
579 }
580
581 static void monitor_qapi_event_handler(void *opaque);
582
583 /*
584 * Queue a new event for emission to Monitor instances,
585 * applying any rate limiting if required.
586 */
587 static void
588 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
589 {
590 MonitorQAPIEventConf *evconf;
591 MonitorQAPIEventState *evstate;
592
593 assert(event < QAPI_EVENT__MAX);
594 evconf = &monitor_qapi_event_conf[event];
595 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
596
597 qemu_mutex_lock(&monitor_lock);
598
599 if (!evconf->rate) {
600 /* Unthrottled event */
601 monitor_qapi_event_emit(event, qdict);
602 } else {
603 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
604 MonitorQAPIEventState key = { .event = event, .data = data };
605
606 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
607 assert(!evstate || timer_pending(evstate->timer));
608
609 if (evstate) {
610 /*
611 * Timer is pending for (at least) evconf->rate ns after
612 * last send. Store event for sending when timer fires,
613 * replacing a prior stored event if any.
614 */
615 qobject_unref(evstate->qdict);
616 evstate->qdict = qobject_ref(qdict);
617 } else {
618 /*
619 * Last send was (at least) evconf->rate ns ago.
620 * Send immediately, and arm the timer to call
621 * monitor_qapi_event_handler() in evconf->rate ns. Any
622 * events arriving before then will be delayed until then.
623 */
624 int64_t now = qemu_clock_get_ns(event_clock_type);
625
626 monitor_qapi_event_emit(event, qdict);
627
628 evstate = g_new(MonitorQAPIEventState, 1);
629 evstate->event = event;
630 evstate->data = qobject_ref(data);
631 evstate->qdict = NULL;
632 evstate->timer = timer_new_ns(event_clock_type,
633 monitor_qapi_event_handler,
634 evstate);
635 g_hash_table_add(monitor_qapi_event_state, evstate);
636 timer_mod_ns(evstate->timer, now + evconf->rate);
637 }
638 }
639
640 qemu_mutex_unlock(&monitor_lock);
641 }
642
643 /*
644 * This function runs evconf->rate ns after sending a throttled
645 * event.
646 * If another event has since been stored, send it.
647 */
648 static void monitor_qapi_event_handler(void *opaque)
649 {
650 MonitorQAPIEventState *evstate = opaque;
651 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
652
653 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
654 qemu_mutex_lock(&monitor_lock);
655
656 if (evstate->qdict) {
657 int64_t now = qemu_clock_get_ns(event_clock_type);
658
659 monitor_qapi_event_emit(evstate->event, evstate->qdict);
660 qobject_unref(evstate->qdict);
661 evstate->qdict = NULL;
662 timer_mod_ns(evstate->timer, now + evconf->rate);
663 } else {
664 g_hash_table_remove(monitor_qapi_event_state, evstate);
665 qobject_unref(evstate->data);
666 timer_free(evstate->timer);
667 g_free(evstate);
668 }
669
670 qemu_mutex_unlock(&monitor_lock);
671 }
672
673 static unsigned int qapi_event_throttle_hash(const void *key)
674 {
675 const MonitorQAPIEventState *evstate = key;
676 unsigned int hash = evstate->event * 255;
677
678 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
679 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
680 }
681
682 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
683 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
684 }
685
686 return hash;
687 }
688
689 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
690 {
691 const MonitorQAPIEventState *eva = a;
692 const MonitorQAPIEventState *evb = b;
693
694 if (eva->event != evb->event) {
695 return FALSE;
696 }
697
698 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
699 return !strcmp(qdict_get_str(eva->data, "id"),
700 qdict_get_str(evb->data, "id"));
701 }
702
703 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
704 return !strcmp(qdict_get_str(eva->data, "node-name"),
705 qdict_get_str(evb->data, "node-name"));
706 }
707
708 return TRUE;
709 }
710
711 static void monitor_qapi_event_init(void)
712 {
713 if (qtest_enabled()) {
714 event_clock_type = QEMU_CLOCK_VIRTUAL;
715 }
716
717 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
718 qapi_event_throttle_equal);
719 qmp_event_set_func_emit(monitor_qapi_event_queue);
720 }
721
722 static void handle_hmp_command(Monitor *mon, const char *cmdline);
723
724 static void monitor_data_init(Monitor *mon, bool skip_flush,
725 bool use_io_thr)
726 {
727 memset(mon, 0, sizeof(Monitor));
728 qemu_mutex_init(&mon->out_lock);
729 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
730 mon->outbuf = qstring_new();
731 /* Use *mon_cmds by default. */
732 mon->cmd_table = mon_cmds;
733 mon->skip_flush = skip_flush;
734 mon->use_io_thr = use_io_thr;
735 mon->qmp.qmp_requests = g_queue_new();
736 mon->qmp.qmp_responses = g_queue_new();
737 }
738
739 static void monitor_data_destroy(Monitor *mon)
740 {
741 g_free(mon->mon_cpu_path);
742 qemu_chr_fe_deinit(&mon->chr, false);
743 if (monitor_is_qmp(mon)) {
744 json_message_parser_destroy(&mon->qmp.parser);
745 }
746 readline_free(mon->rs);
747 qobject_unref(mon->outbuf);
748 qemu_mutex_destroy(&mon->out_lock);
749 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
750 monitor_qmp_cleanup_req_queue_locked(mon);
751 monitor_qmp_cleanup_resp_queue_locked(mon);
752 g_queue_free(mon->qmp.qmp_requests);
753 g_queue_free(mon->qmp.qmp_responses);
754 }
755
756 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
757 int64_t cpu_index, Error **errp)
758 {
759 char *output = NULL;
760 Monitor *old_mon, hmp;
761
762 monitor_data_init(&hmp, true, false);
763
764 old_mon = cur_mon;
765 cur_mon = &hmp;
766
767 if (has_cpu_index) {
768 int ret = monitor_set_cpu(cpu_index);
769 if (ret < 0) {
770 cur_mon = old_mon;
771 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
772 "a CPU number");
773 goto out;
774 }
775 }
776
777 handle_hmp_command(&hmp, command_line);
778 cur_mon = old_mon;
779
780 qemu_mutex_lock(&hmp.out_lock);
781 if (qstring_get_length(hmp.outbuf) > 0) {
782 output = g_strdup(qstring_get_str(hmp.outbuf));
783 } else {
784 output = g_strdup("");
785 }
786 qemu_mutex_unlock(&hmp.out_lock);
787
788 out:
789 monitor_data_destroy(&hmp);
790 return output;
791 }
792
793 static int compare_cmd(const char *name, const char *list)
794 {
795 const char *p, *pstart;
796 int len;
797 len = strlen(name);
798 p = list;
799 for(;;) {
800 pstart = p;
801 p = strchr(p, '|');
802 if (!p)
803 p = pstart + strlen(pstart);
804 if ((p - pstart) == len && !memcmp(pstart, name, len))
805 return 1;
806 if (*p == '\0')
807 break;
808 p++;
809 }
810 return 0;
811 }
812
813 static int get_str(char *buf, int buf_size, const char **pp)
814 {
815 const char *p;
816 char *q;
817 int c;
818
819 q = buf;
820 p = *pp;
821 while (qemu_isspace(*p)) {
822 p++;
823 }
824 if (*p == '\0') {
825 fail:
826 *q = '\0';
827 *pp = p;
828 return -1;
829 }
830 if (*p == '\"') {
831 p++;
832 while (*p != '\0' && *p != '\"') {
833 if (*p == '\\') {
834 p++;
835 c = *p++;
836 switch (c) {
837 case 'n':
838 c = '\n';
839 break;
840 case 'r':
841 c = '\r';
842 break;
843 case '\\':
844 case '\'':
845 case '\"':
846 break;
847 default:
848 printf("unsupported escape code: '\\%c'\n", c);
849 goto fail;
850 }
851 if ((q - buf) < buf_size - 1) {
852 *q++ = c;
853 }
854 } else {
855 if ((q - buf) < buf_size - 1) {
856 *q++ = *p;
857 }
858 p++;
859 }
860 }
861 if (*p != '\"') {
862 printf("unterminated string\n");
863 goto fail;
864 }
865 p++;
866 } else {
867 while (*p != '\0' && !qemu_isspace(*p)) {
868 if ((q - buf) < buf_size - 1) {
869 *q++ = *p;
870 }
871 p++;
872 }
873 }
874 *q = '\0';
875 *pp = p;
876 return 0;
877 }
878
879 #define MAX_ARGS 16
880
881 static void free_cmdline_args(char **args, int nb_args)
882 {
883 int i;
884
885 assert(nb_args <= MAX_ARGS);
886
887 for (i = 0; i < nb_args; i++) {
888 g_free(args[i]);
889 }
890
891 }
892
893 /*
894 * Parse the command line to get valid args.
895 * @cmdline: command line to be parsed.
896 * @pnb_args: location to store the number of args, must NOT be NULL.
897 * @args: location to store the args, which should be freed by caller, must
898 * NOT be NULL.
899 *
900 * Returns 0 on success, negative on failure.
901 *
902 * NOTE: this parser is an approximate form of the real command parser. Number
903 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
904 * return with failure.
905 */
906 static int parse_cmdline(const char *cmdline,
907 int *pnb_args, char **args)
908 {
909 const char *p;
910 int nb_args, ret;
911 char buf[1024];
912
913 p = cmdline;
914 nb_args = 0;
915 for (;;) {
916 while (qemu_isspace(*p)) {
917 p++;
918 }
919 if (*p == '\0') {
920 break;
921 }
922 if (nb_args >= MAX_ARGS) {
923 goto fail;
924 }
925 ret = get_str(buf, sizeof(buf), &p);
926 if (ret < 0) {
927 goto fail;
928 }
929 args[nb_args] = g_strdup(buf);
930 nb_args++;
931 }
932 *pnb_args = nb_args;
933 return 0;
934
935 fail:
936 free_cmdline_args(args, nb_args);
937 return -1;
938 }
939
940 static void help_cmd_dump_one(Monitor *mon,
941 const mon_cmd_t *cmd,
942 char **prefix_args,
943 int prefix_args_nb)
944 {
945 int i;
946
947 for (i = 0; i < prefix_args_nb; i++) {
948 monitor_printf(mon, "%s ", prefix_args[i]);
949 }
950 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
951 }
952
953 /* @args[@arg_index] is the valid command need to find in @cmds */
954 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
955 char **args, int nb_args, int arg_index)
956 {
957 const mon_cmd_t *cmd;
958
959 /* No valid arg need to compare with, dump all in *cmds */
960 if (arg_index >= nb_args) {
961 for (cmd = cmds; cmd->name != NULL; cmd++) {
962 help_cmd_dump_one(mon, cmd, args, arg_index);
963 }
964 return;
965 }
966
967 /* Find one entry to dump */
968 for (cmd = cmds; cmd->name != NULL; cmd++) {
969 if (compare_cmd(args[arg_index], cmd->name)) {
970 if (cmd->sub_table) {
971 /* continue with next arg */
972 help_cmd_dump(mon, cmd->sub_table,
973 args, nb_args, arg_index + 1);
974 } else {
975 help_cmd_dump_one(mon, cmd, args, arg_index);
976 }
977 break;
978 }
979 }
980 }
981
982 static void help_cmd(Monitor *mon, const char *name)
983 {
984 char *args[MAX_ARGS];
985 int nb_args = 0;
986
987 /* 1. parse user input */
988 if (name) {
989 /* special case for log, directly dump and return */
990 if (!strcmp(name, "log")) {
991 const QEMULogItem *item;
992 monitor_printf(mon, "Log items (comma separated):\n");
993 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
994 for (item = qemu_log_items; item->mask != 0; item++) {
995 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
996 }
997 return;
998 }
999
1000 if (parse_cmdline(name, &nb_args, args) < 0) {
1001 return;
1002 }
1003 }
1004
1005 /* 2. dump the contents according to parsed args */
1006 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1007
1008 free_cmdline_args(args, nb_args);
1009 }
1010
1011 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1012 {
1013 help_cmd(mon, qdict_get_try_str(qdict, "name"));
1014 }
1015
1016 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1017 {
1018 const char *tp_name = qdict_get_str(qdict, "name");
1019 bool new_state = qdict_get_bool(qdict, "option");
1020 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1021 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1022 Error *local_err = NULL;
1023
1024 if (vcpu < 0) {
1025 monitor_printf(mon, "argument vcpu must be positive");
1026 return;
1027 }
1028
1029 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1030 if (local_err) {
1031 error_report_err(local_err);
1032 }
1033 }
1034
1035 #ifdef CONFIG_TRACE_SIMPLE
1036 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1037 {
1038 const char *op = qdict_get_try_str(qdict, "op");
1039 const char *arg = qdict_get_try_str(qdict, "arg");
1040
1041 if (!op) {
1042 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1043 } else if (!strcmp(op, "on")) {
1044 st_set_trace_file_enabled(true);
1045 } else if (!strcmp(op, "off")) {
1046 st_set_trace_file_enabled(false);
1047 } else if (!strcmp(op, "flush")) {
1048 st_flush_trace_buffer();
1049 } else if (!strcmp(op, "set")) {
1050 if (arg) {
1051 st_set_trace_file(arg);
1052 }
1053 } else {
1054 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1055 help_cmd(mon, "trace-file");
1056 }
1057 }
1058 #endif
1059
1060 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1061 {
1062 help_cmd(mon, "info");
1063 }
1064
1065 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1066 {
1067 CommandInfoList *info, **list = opaque;
1068
1069 if (!cmd->enabled) {
1070 return;
1071 }
1072
1073 info = g_malloc0(sizeof(*info));
1074 info->value = g_malloc0(sizeof(*info->value));
1075 info->value->name = g_strdup(cmd->name);
1076 info->next = *list;
1077 *list = info;
1078 }
1079
1080 CommandInfoList *qmp_query_commands(Error **errp)
1081 {
1082 CommandInfoList *list = NULL;
1083
1084 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1085
1086 return list;
1087 }
1088
1089 EventInfoList *qmp_query_events(Error **errp)
1090 {
1091 EventInfoList *info, *ev_list = NULL;
1092 QAPIEvent e;
1093
1094 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1095 const char *event_name = QAPIEvent_str(e);
1096 assert(event_name != NULL);
1097 info = g_malloc0(sizeof(*info));
1098 info->value = g_malloc0(sizeof(*info->value));
1099 info->value->name = g_strdup(event_name);
1100
1101 info->next = ev_list;
1102 ev_list = info;
1103 }
1104
1105 return ev_list;
1106 }
1107
1108 /*
1109 * Minor hack: generated marshalling suppressed for this command
1110 * ('gen': false in the schema) so we can parse the JSON string
1111 * directly into QObject instead of first parsing it with
1112 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1113 * to QObject with generated output marshallers, every time. Instead,
1114 * we do it in test-qobject-input-visitor.c, just to make sure
1115 * qapi-gen.py's output actually conforms to the schema.
1116 */
1117 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1118 Error **errp)
1119 {
1120 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1121 }
1122
1123 /*
1124 * We used to define commands in qmp-commands.hx in addition to the
1125 * QAPI schema. This permitted defining some of them only in certain
1126 * configurations. query-commands has always reflected that (good,
1127 * because it lets QMP clients figure out what's actually available),
1128 * while query-qmp-schema never did (not so good). This function is a
1129 * hack to keep the configuration-specific commands defined exactly as
1130 * before, even though qmp-commands.hx is gone.
1131 *
1132 * FIXME Educate the QAPI schema on configuration-specific commands,
1133 * and drop this hack.
1134 */
1135 static void qmp_unregister_commands_hack(void)
1136 {
1137 #ifndef CONFIG_SPICE
1138 qmp_unregister_command(&qmp_commands, "query-spice");
1139 #endif
1140 #ifndef CONFIG_REPLICATION
1141 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1142 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1143 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1144 #endif
1145 #ifndef TARGET_I386
1146 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1147 qmp_unregister_command(&qmp_commands, "query-sev");
1148 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1149 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1150 #endif
1151 #ifndef TARGET_S390X
1152 qmp_unregister_command(&qmp_commands, "dump-skeys");
1153 #endif
1154 #ifndef TARGET_ARM
1155 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1156 #endif
1157 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1158 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1159 #endif
1160 #if !defined(TARGET_S390X)
1161 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1162 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1163 #endif
1164 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1165 && !defined(TARGET_S390X)
1166 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1167 #endif
1168 }
1169
1170 static void monitor_init_qmp_commands(void)
1171 {
1172 /*
1173 * Two command lists:
1174 * - qmp_commands contains all QMP commands
1175 * - qmp_cap_negotiation_commands contains just
1176 * "qmp_capabilities", to enforce capability negotiation
1177 */
1178
1179 qmp_init_marshal(&qmp_commands);
1180
1181 qmp_register_command(&qmp_commands, "query-qmp-schema",
1182 qmp_query_qmp_schema,
1183 QCO_NO_OPTIONS);
1184 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1185 QCO_NO_OPTIONS);
1186 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1187 QCO_NO_OPTIONS);
1188
1189 qmp_unregister_commands_hack();
1190
1191 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1192 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1193 qmp_marshal_qmp_capabilities, QCO_NO_OPTIONS);
1194 }
1195
1196 static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
1197 {
1198 return mon->qmp.qmp_caps[cap];
1199 }
1200
1201 static bool qmp_oob_enabled(Monitor *mon)
1202 {
1203 return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
1204 }
1205
1206 static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
1207 Error **errp)
1208 {
1209 for (; list; list = list->next) {
1210 assert(list->value < QMP_CAPABILITY__MAX);
1211 switch (list->value) {
1212 case QMP_CAPABILITY_OOB:
1213 if (!mon->use_io_thr) {
1214 /*
1215 * Out-Of-Band only works with monitors that are
1216 * running on dedicated IOThread.
1217 */
1218 error_setg(errp, "This monitor does not support "
1219 "Out-Of-Band (OOB)");
1220 return;
1221 }
1222 break;
1223 default:
1224 break;
1225 }
1226 }
1227 }
1228
1229 /* This function should only be called after capabilities are checked. */
1230 static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
1231 {
1232 for (; list; list = list->next) {
1233 mon->qmp.qmp_caps[list->value] = true;
1234 }
1235 }
1236
1237 /*
1238 * Return true if check successful, or false otherwise. When false is
1239 * returned, detailed error will be in errp if provided.
1240 */
1241 static bool qmp_cmd_oob_check(Monitor *mon, QDict *req, Error **errp)
1242 {
1243 const char *command;
1244 QmpCommand *cmd;
1245
1246 command = qdict_get_try_str(req, "execute");
1247 if (!command) {
1248 error_setg(errp, "Command field 'execute' missing");
1249 return false;
1250 }
1251
1252 cmd = qmp_find_command(mon->qmp.commands, command);
1253 if (!cmd) {
1254 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
1255 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1256 "Expecting capabilities negotiation "
1257 "with 'qmp_capabilities'");
1258 } else {
1259 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1260 "The command %s has not been found", command);
1261 }
1262 return false;
1263 }
1264
1265 if (qmp_is_oob(req)) {
1266 if (!qmp_oob_enabled(mon)) {
1267 error_setg(errp, "Please enable Out-Of-Band first "
1268 "for the session during capabilities negotiation");
1269 return false;
1270 }
1271 if (!(cmd->options & QCO_ALLOW_OOB)) {
1272 error_setg(errp, "The command %s does not support OOB",
1273 command);
1274 return false;
1275 }
1276 }
1277
1278 return true;
1279 }
1280
1281 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1282 Error **errp)
1283 {
1284 Error *local_err = NULL;
1285
1286 if (cur_mon->qmp.commands == &qmp_commands) {
1287 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1288 "Capabilities negotiation is already complete, command "
1289 "ignored");
1290 return;
1291 }
1292
1293 /* Enable QMP capabilities provided by the client if applicable. */
1294 if (has_enable) {
1295 qmp_caps_check(cur_mon, enable, &local_err);
1296 if (local_err) {
1297 /*
1298 * Failed check on any of the capabilities will fail the
1299 * entire command (and thus not apply any of the other
1300 * capabilities that were also requested).
1301 */
1302 error_propagate(errp, local_err);
1303 return;
1304 }
1305 qmp_caps_apply(cur_mon, enable);
1306 }
1307
1308 cur_mon->qmp.commands = &qmp_commands;
1309 }
1310
1311 /* set the current CPU defined by the user */
1312 int monitor_set_cpu(int cpu_index)
1313 {
1314 CPUState *cpu;
1315
1316 cpu = qemu_get_cpu(cpu_index);
1317 if (cpu == NULL) {
1318 return -1;
1319 }
1320 g_free(cur_mon->mon_cpu_path);
1321 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1322 return 0;
1323 }
1324
1325 static CPUState *mon_get_cpu_sync(bool synchronize)
1326 {
1327 CPUState *cpu;
1328
1329 if (cur_mon->mon_cpu_path) {
1330 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1331 TYPE_CPU, NULL);
1332 if (!cpu) {
1333 g_free(cur_mon->mon_cpu_path);
1334 cur_mon->mon_cpu_path = NULL;
1335 }
1336 }
1337 if (!cur_mon->mon_cpu_path) {
1338 if (!first_cpu) {
1339 return NULL;
1340 }
1341 monitor_set_cpu(first_cpu->cpu_index);
1342 cpu = first_cpu;
1343 }
1344 if (synchronize) {
1345 cpu_synchronize_state(cpu);
1346 }
1347 return cpu;
1348 }
1349
1350 CPUState *mon_get_cpu(void)
1351 {
1352 return mon_get_cpu_sync(true);
1353 }
1354
1355 CPUArchState *mon_get_cpu_env(void)
1356 {
1357 CPUState *cs = mon_get_cpu();
1358
1359 return cs ? cs->env_ptr : NULL;
1360 }
1361
1362 int monitor_get_cpu_index(void)
1363 {
1364 CPUState *cs = mon_get_cpu_sync(false);
1365
1366 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1367 }
1368
1369 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1370 {
1371 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1372 CPUState *cs;
1373
1374 if (all_cpus) {
1375 CPU_FOREACH(cs) {
1376 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1377 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1378 }
1379 } else {
1380 cs = mon_get_cpu();
1381
1382 if (!cs) {
1383 monitor_printf(mon, "No CPU available\n");
1384 return;
1385 }
1386
1387 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1388 }
1389 }
1390
1391 #ifdef CONFIG_TCG
1392 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1393 {
1394 if (!tcg_enabled()) {
1395 error_report("JIT information is only available with accel=tcg");
1396 return;
1397 }
1398
1399 dump_exec_info((FILE *)mon, monitor_fprintf);
1400 dump_drift_info((FILE *)mon, monitor_fprintf);
1401 }
1402
1403 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1404 {
1405 dump_opcount_info((FILE *)mon, monitor_fprintf);
1406 }
1407 #endif
1408
1409 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1410 {
1411 int i;
1412 const char *str;
1413
1414 if (!mon->rs)
1415 return;
1416 i = 0;
1417 for(;;) {
1418 str = readline_get_history(mon->rs, i);
1419 if (!str)
1420 break;
1421 monitor_printf(mon, "%d: '%s'\n", i, str);
1422 i++;
1423 }
1424 }
1425
1426 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1427 {
1428 CPUState *cs = mon_get_cpu();
1429
1430 if (!cs) {
1431 monitor_printf(mon, "No CPU available\n");
1432 return;
1433 }
1434 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1435 }
1436
1437 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1438 {
1439 const char *name = qdict_get_try_str(qdict, "name");
1440 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1441 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1442 TraceEventInfoList *events;
1443 TraceEventInfoList *elem;
1444 Error *local_err = NULL;
1445
1446 if (name == NULL) {
1447 name = "*";
1448 }
1449 if (vcpu < 0) {
1450 monitor_printf(mon, "argument vcpu must be positive");
1451 return;
1452 }
1453
1454 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1455 if (local_err) {
1456 error_report_err(local_err);
1457 return;
1458 }
1459
1460 for (elem = events; elem != NULL; elem = elem->next) {
1461 monitor_printf(mon, "%s : state %u\n",
1462 elem->value->name,
1463 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1464 }
1465 qapi_free_TraceEventInfoList(events);
1466 }
1467
1468 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1469 bool has_port, int64_t port,
1470 bool has_tls_port, int64_t tls_port,
1471 bool has_cert_subject, const char *cert_subject,
1472 Error **errp)
1473 {
1474 if (strcmp(protocol, "spice") == 0) {
1475 if (!qemu_using_spice(errp)) {
1476 return;
1477 }
1478
1479 if (!has_port && !has_tls_port) {
1480 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1481 return;
1482 }
1483
1484 if (qemu_spice_migrate_info(hostname,
1485 has_port ? port : -1,
1486 has_tls_port ? tls_port : -1,
1487 cert_subject)) {
1488 error_setg(errp, QERR_UNDEFINED_ERROR);
1489 return;
1490 }
1491 return;
1492 }
1493
1494 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1495 }
1496
1497 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1498 {
1499 Error *err = NULL;
1500
1501 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1502 if (err) {
1503 error_report_err(err);
1504 }
1505 }
1506
1507 static void hmp_log(Monitor *mon, const QDict *qdict)
1508 {
1509 int mask;
1510 const char *items = qdict_get_str(qdict, "items");
1511
1512 if (!strcmp(items, "none")) {
1513 mask = 0;
1514 } else {
1515 mask = qemu_str_to_log_mask(items);
1516 if (!mask) {
1517 help_cmd(mon, "log");
1518 return;
1519 }
1520 }
1521 qemu_set_log(mask);
1522 }
1523
1524 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1525 {
1526 const char *option = qdict_get_try_str(qdict, "option");
1527 if (!option || !strcmp(option, "on")) {
1528 singlestep = 1;
1529 } else if (!strcmp(option, "off")) {
1530 singlestep = 0;
1531 } else {
1532 monitor_printf(mon, "unexpected option %s\n", option);
1533 }
1534 }
1535
1536 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1537 {
1538 const char *device = qdict_get_try_str(qdict, "device");
1539 if (!device)
1540 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1541 if (gdbserver_start(device) < 0) {
1542 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1543 device);
1544 } else if (strcmp(device, "none") == 0) {
1545 monitor_printf(mon, "Disabled gdbserver\n");
1546 } else {
1547 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1548 device);
1549 }
1550 }
1551
1552 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1553 {
1554 const char *action = qdict_get_str(qdict, "action");
1555 if (select_watchdog_action(action) == -1) {
1556 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1557 }
1558 }
1559
1560 static void monitor_printc(Monitor *mon, int c)
1561 {
1562 monitor_printf(mon, "'");
1563 switch(c) {
1564 case '\'':
1565 monitor_printf(mon, "\\'");
1566 break;
1567 case '\\':
1568 monitor_printf(mon, "\\\\");
1569 break;
1570 case '\n':
1571 monitor_printf(mon, "\\n");
1572 break;
1573 case '\r':
1574 monitor_printf(mon, "\\r");
1575 break;
1576 default:
1577 if (c >= 32 && c <= 126) {
1578 monitor_printf(mon, "%c", c);
1579 } else {
1580 monitor_printf(mon, "\\x%02x", c);
1581 }
1582 break;
1583 }
1584 monitor_printf(mon, "'");
1585 }
1586
1587 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1588 hwaddr addr, int is_physical)
1589 {
1590 int l, line_size, i, max_digits, len;
1591 uint8_t buf[16];
1592 uint64_t v;
1593 CPUState *cs = mon_get_cpu();
1594
1595 if (!cs && (format == 'i' || !is_physical)) {
1596 monitor_printf(mon, "Can not dump without CPU\n");
1597 return;
1598 }
1599
1600 if (format == 'i') {
1601 monitor_disas(mon, cs, addr, count, is_physical);
1602 return;
1603 }
1604
1605 len = wsize * count;
1606 if (wsize == 1)
1607 line_size = 8;
1608 else
1609 line_size = 16;
1610 max_digits = 0;
1611
1612 switch(format) {
1613 case 'o':
1614 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1615 break;
1616 default:
1617 case 'x':
1618 max_digits = (wsize * 8) / 4;
1619 break;
1620 case 'u':
1621 case 'd':
1622 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1623 break;
1624 case 'c':
1625 wsize = 1;
1626 break;
1627 }
1628
1629 while (len > 0) {
1630 if (is_physical)
1631 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1632 else
1633 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1634 l = len;
1635 if (l > line_size)
1636 l = line_size;
1637 if (is_physical) {
1638 cpu_physical_memory_read(addr, buf, l);
1639 } else {
1640 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1641 monitor_printf(mon, " Cannot access memory\n");
1642 break;
1643 }
1644 }
1645 i = 0;
1646 while (i < l) {
1647 switch(wsize) {
1648 default:
1649 case 1:
1650 v = ldub_p(buf + i);
1651 break;
1652 case 2:
1653 v = lduw_p(buf + i);
1654 break;
1655 case 4:
1656 v = (uint32_t)ldl_p(buf + i);
1657 break;
1658 case 8:
1659 v = ldq_p(buf + i);
1660 break;
1661 }
1662 monitor_printf(mon, " ");
1663 switch(format) {
1664 case 'o':
1665 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1666 break;
1667 case 'x':
1668 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1669 break;
1670 case 'u':
1671 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1672 break;
1673 case 'd':
1674 monitor_printf(mon, "%*" PRId64, max_digits, v);
1675 break;
1676 case 'c':
1677 monitor_printc(mon, v);
1678 break;
1679 }
1680 i += wsize;
1681 }
1682 monitor_printf(mon, "\n");
1683 addr += l;
1684 len -= l;
1685 }
1686 }
1687
1688 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1689 {
1690 int count = qdict_get_int(qdict, "count");
1691 int format = qdict_get_int(qdict, "format");
1692 int size = qdict_get_int(qdict, "size");
1693 target_long addr = qdict_get_int(qdict, "addr");
1694
1695 memory_dump(mon, count, format, size, addr, 0);
1696 }
1697
1698 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1699 {
1700 int count = qdict_get_int(qdict, "count");
1701 int format = qdict_get_int(qdict, "format");
1702 int size = qdict_get_int(qdict, "size");
1703 hwaddr addr = qdict_get_int(qdict, "addr");
1704
1705 memory_dump(mon, count, format, size, addr, 1);
1706 }
1707
1708 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1709 {
1710 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1711 addr, 1);
1712
1713 if (!mrs.mr) {
1714 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1715 return NULL;
1716 }
1717
1718 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1719 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1720 memory_region_unref(mrs.mr);
1721 return NULL;
1722 }
1723
1724 *p_mr = mrs.mr;
1725 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1726 }
1727
1728 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1729 {
1730 hwaddr addr = qdict_get_int(qdict, "addr");
1731 Error *local_err = NULL;
1732 MemoryRegion *mr = NULL;
1733 void *ptr;
1734
1735 ptr = gpa2hva(&mr, addr, &local_err);
1736 if (local_err) {
1737 error_report_err(local_err);
1738 return;
1739 }
1740
1741 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1742 " (%s) is %p\n",
1743 addr, mr->name, ptr);
1744
1745 memory_region_unref(mr);
1746 }
1747
1748 #ifdef CONFIG_LINUX
1749 static uint64_t vtop(void *ptr, Error **errp)
1750 {
1751 uint64_t pinfo;
1752 uint64_t ret = -1;
1753 uintptr_t addr = (uintptr_t) ptr;
1754 uintptr_t pagesize = getpagesize();
1755 off_t offset = addr / pagesize * sizeof(pinfo);
1756 int fd;
1757
1758 fd = open("/proc/self/pagemap", O_RDONLY);
1759 if (fd == -1) {
1760 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1761 return -1;
1762 }
1763
1764 /* Force copy-on-write if necessary. */
1765 atomic_add((uint8_t *)ptr, 0);
1766
1767 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1768 error_setg_errno(errp, errno, "Cannot read pagemap");
1769 goto out;
1770 }
1771 if ((pinfo & (1ull << 63)) == 0) {
1772 error_setg(errp, "Page not present");
1773 goto out;
1774 }
1775 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1776
1777 out:
1778 close(fd);
1779 return ret;
1780 }
1781
1782 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1783 {
1784 hwaddr addr = qdict_get_int(qdict, "addr");
1785 Error *local_err = NULL;
1786 MemoryRegion *mr = NULL;
1787 void *ptr;
1788 uint64_t physaddr;
1789
1790 ptr = gpa2hva(&mr, addr, &local_err);
1791 if (local_err) {
1792 error_report_err(local_err);
1793 return;
1794 }
1795
1796 physaddr = vtop(ptr, &local_err);
1797 if (local_err) {
1798 error_report_err(local_err);
1799 } else {
1800 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1801 " (%s) is 0x%" PRIx64 "\n",
1802 addr, mr->name, (uint64_t) physaddr);
1803 }
1804
1805 memory_region_unref(mr);
1806 }
1807 #endif
1808
1809 static void do_print(Monitor *mon, const QDict *qdict)
1810 {
1811 int format = qdict_get_int(qdict, "format");
1812 hwaddr val = qdict_get_int(qdict, "val");
1813
1814 switch(format) {
1815 case 'o':
1816 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1817 break;
1818 case 'x':
1819 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1820 break;
1821 case 'u':
1822 monitor_printf(mon, "%" HWADDR_PRIu, val);
1823 break;
1824 default:
1825 case 'd':
1826 monitor_printf(mon, "%" HWADDR_PRId, val);
1827 break;
1828 case 'c':
1829 monitor_printc(mon, val);
1830 break;
1831 }
1832 monitor_printf(mon, "\n");
1833 }
1834
1835 static void hmp_sum(Monitor *mon, const QDict *qdict)
1836 {
1837 uint32_t addr;
1838 uint16_t sum;
1839 uint32_t start = qdict_get_int(qdict, "start");
1840 uint32_t size = qdict_get_int(qdict, "size");
1841
1842 sum = 0;
1843 for(addr = start; addr < (start + size); addr++) {
1844 uint8_t val = address_space_ldub(&address_space_memory, addr,
1845 MEMTXATTRS_UNSPECIFIED, NULL);
1846 /* BSD sum algorithm ('sum' Unix command) */
1847 sum = (sum >> 1) | (sum << 15);
1848 sum += val;
1849 }
1850 monitor_printf(mon, "%05d\n", sum);
1851 }
1852
1853 static int mouse_button_state;
1854
1855 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1856 {
1857 int dx, dy, dz, button;
1858 const char *dx_str = qdict_get_str(qdict, "dx_str");
1859 const char *dy_str = qdict_get_str(qdict, "dy_str");
1860 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1861
1862 dx = strtol(dx_str, NULL, 0);
1863 dy = strtol(dy_str, NULL, 0);
1864 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1865 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1866
1867 if (dz_str) {
1868 dz = strtol(dz_str, NULL, 0);
1869 if (dz != 0) {
1870 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1871 qemu_input_queue_btn(NULL, button, true);
1872 qemu_input_event_sync();
1873 qemu_input_queue_btn(NULL, button, false);
1874 }
1875 }
1876 qemu_input_event_sync();
1877 }
1878
1879 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1880 {
1881 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1882 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1883 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1884 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1885 };
1886 int button_state = qdict_get_int(qdict, "button_state");
1887
1888 if (mouse_button_state == button_state) {
1889 return;
1890 }
1891 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1892 qemu_input_event_sync();
1893 mouse_button_state = button_state;
1894 }
1895
1896 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1897 {
1898 int size = qdict_get_int(qdict, "size");
1899 int addr = qdict_get_int(qdict, "addr");
1900 int has_index = qdict_haskey(qdict, "index");
1901 uint32_t val;
1902 int suffix;
1903
1904 if (has_index) {
1905 int index = qdict_get_int(qdict, "index");
1906 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1907 addr++;
1908 }
1909 addr &= 0xffff;
1910
1911 switch(size) {
1912 default:
1913 case 1:
1914 val = cpu_inb(addr);
1915 suffix = 'b';
1916 break;
1917 case 2:
1918 val = cpu_inw(addr);
1919 suffix = 'w';
1920 break;
1921 case 4:
1922 val = cpu_inl(addr);
1923 suffix = 'l';
1924 break;
1925 }
1926 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1927 suffix, addr, size * 2, val);
1928 }
1929
1930 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1931 {
1932 int size = qdict_get_int(qdict, "size");
1933 int addr = qdict_get_int(qdict, "addr");
1934 int val = qdict_get_int(qdict, "val");
1935
1936 addr &= IOPORTS_MASK;
1937
1938 switch (size) {
1939 default:
1940 case 1:
1941 cpu_outb(addr, val);
1942 break;
1943 case 2:
1944 cpu_outw(addr, val);
1945 break;
1946 case 4:
1947 cpu_outl(addr, val);
1948 break;
1949 }
1950 }
1951
1952 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1953 {
1954 Error *local_err = NULL;
1955 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1956
1957 qemu_boot_set(bootdevice, &local_err);
1958 if (local_err) {
1959 error_report_err(local_err);
1960 } else {
1961 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1962 }
1963 }
1964
1965 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1966 {
1967 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1968 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1969
1970 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
1971 }
1972
1973 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1974 {
1975 int i;
1976 NumaNodeMem *node_mem;
1977 CpuInfoList *cpu_list, *cpu;
1978
1979 cpu_list = qmp_query_cpus(&error_abort);
1980 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1981
1982 query_numa_node_mem(node_mem);
1983 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1984 for (i = 0; i < nb_numa_nodes; i++) {
1985 monitor_printf(mon, "node %d cpus:", i);
1986 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1987 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1988 cpu->value->props->node_id == i) {
1989 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1990 }
1991 }
1992 monitor_printf(mon, "\n");
1993 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1994 node_mem[i].node_mem >> 20);
1995 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1996 node_mem[i].node_plugged_mem >> 20);
1997 }
1998 qapi_free_CpuInfoList(cpu_list);
1999 g_free(node_mem);
2000 }
2001
2002 #ifdef CONFIG_PROFILER
2003
2004 int64_t tcg_time;
2005 int64_t dev_time;
2006
2007 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2008 {
2009 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2010 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
2011 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2012 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
2013 tcg_time = 0;
2014 dev_time = 0;
2015 }
2016 #else
2017 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2018 {
2019 monitor_printf(mon, "Internal profiler not compiled\n");
2020 }
2021 #endif
2022
2023 /* Capture support */
2024 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2025
2026 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2027 {
2028 int i;
2029 CaptureState *s;
2030
2031 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2032 monitor_printf(mon, "[%d]: ", i);
2033 s->ops.info (s->opaque);
2034 }
2035 }
2036
2037 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2038 {
2039 int i;
2040 int n = qdict_get_int(qdict, "n");
2041 CaptureState *s;
2042
2043 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2044 if (i == n) {
2045 s->ops.destroy (s->opaque);
2046 QLIST_REMOVE (s, entries);
2047 g_free (s);
2048 return;
2049 }
2050 }
2051 }
2052
2053 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2054 {
2055 const char *path = qdict_get_str(qdict, "path");
2056 int has_freq = qdict_haskey(qdict, "freq");
2057 int freq = qdict_get_try_int(qdict, "freq", -1);
2058 int has_bits = qdict_haskey(qdict, "bits");
2059 int bits = qdict_get_try_int(qdict, "bits", -1);
2060 int has_channels = qdict_haskey(qdict, "nchannels");
2061 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2062 CaptureState *s;
2063
2064 s = g_malloc0 (sizeof (*s));
2065
2066 freq = has_freq ? freq : 44100;
2067 bits = has_bits ? bits : 16;
2068 nchannels = has_channels ? nchannels : 2;
2069
2070 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2071 monitor_printf(mon, "Failed to add wave capture\n");
2072 g_free (s);
2073 return;
2074 }
2075 QLIST_INSERT_HEAD (&capture_head, s, entries);
2076 }
2077
2078 static qemu_acl *find_acl(Monitor *mon, const char *name)
2079 {
2080 qemu_acl *acl = qemu_acl_find(name);
2081
2082 if (!acl) {
2083 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2084 }
2085 return acl;
2086 }
2087
2088 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2089 {
2090 const char *aclname = qdict_get_str(qdict, "aclname");
2091 qemu_acl *acl = find_acl(mon, aclname);
2092 qemu_acl_entry *entry;
2093 int i = 0;
2094
2095 if (acl) {
2096 monitor_printf(mon, "policy: %s\n",
2097 acl->defaultDeny ? "deny" : "allow");
2098 QTAILQ_FOREACH(entry, &acl->entries, next) {
2099 i++;
2100 monitor_printf(mon, "%d: %s %s\n", i,
2101 entry->deny ? "deny" : "allow", entry->match);
2102 }
2103 }
2104 }
2105
2106 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2107 {
2108 const char *aclname = qdict_get_str(qdict, "aclname");
2109 qemu_acl *acl = find_acl(mon, aclname);
2110
2111 if (acl) {
2112 qemu_acl_reset(acl);
2113 monitor_printf(mon, "acl: removed all rules\n");
2114 }
2115 }
2116
2117 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2118 {
2119 const char *aclname = qdict_get_str(qdict, "aclname");
2120 const char *policy = qdict_get_str(qdict, "policy");
2121 qemu_acl *acl = find_acl(mon, aclname);
2122
2123 if (acl) {
2124 if (strcmp(policy, "allow") == 0) {
2125 acl->defaultDeny = 0;
2126 monitor_printf(mon, "acl: policy set to 'allow'\n");
2127 } else if (strcmp(policy, "deny") == 0) {
2128 acl->defaultDeny = 1;
2129 monitor_printf(mon, "acl: policy set to 'deny'\n");
2130 } else {
2131 monitor_printf(mon, "acl: unknown policy '%s', "
2132 "expected 'deny' or 'allow'\n", policy);
2133 }
2134 }
2135 }
2136
2137 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2138 {
2139 const char *aclname = qdict_get_str(qdict, "aclname");
2140 const char *match = qdict_get_str(qdict, "match");
2141 const char *policy = qdict_get_str(qdict, "policy");
2142 int has_index = qdict_haskey(qdict, "index");
2143 int index = qdict_get_try_int(qdict, "index", -1);
2144 qemu_acl *acl = find_acl(mon, aclname);
2145 int deny, ret;
2146
2147 if (acl) {
2148 if (strcmp(policy, "allow") == 0) {
2149 deny = 0;
2150 } else if (strcmp(policy, "deny") == 0) {
2151 deny = 1;
2152 } else {
2153 monitor_printf(mon, "acl: unknown policy '%s', "
2154 "expected 'deny' or 'allow'\n", policy);
2155 return;
2156 }
2157 if (has_index)
2158 ret = qemu_acl_insert(acl, deny, match, index);
2159 else
2160 ret = qemu_acl_append(acl, deny, match);
2161 if (ret < 0)
2162 monitor_printf(mon, "acl: unable to add acl entry\n");
2163 else
2164 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2165 }
2166 }
2167
2168 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2169 {
2170 const char *aclname = qdict_get_str(qdict, "aclname");
2171 const char *match = qdict_get_str(qdict, "match");
2172 qemu_acl *acl = find_acl(mon, aclname);
2173 int ret;
2174
2175 if (acl) {
2176 ret = qemu_acl_remove(acl, match);
2177 if (ret < 0)
2178 monitor_printf(mon, "acl: no matching acl entry\n");
2179 else
2180 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2181 }
2182 }
2183
2184 void qmp_getfd(const char *fdname, Error **errp)
2185 {
2186 mon_fd_t *monfd;
2187 int fd;
2188
2189 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2190 if (fd == -1) {
2191 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2192 return;
2193 }
2194
2195 if (qemu_isdigit(fdname[0])) {
2196 close(fd);
2197 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2198 "a name not starting with a digit");
2199 return;
2200 }
2201
2202 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2203 if (strcmp(monfd->name, fdname) != 0) {
2204 continue;
2205 }
2206
2207 close(monfd->fd);
2208 monfd->fd = fd;
2209 return;
2210 }
2211
2212 monfd = g_malloc0(sizeof(mon_fd_t));
2213 monfd->name = g_strdup(fdname);
2214 monfd->fd = fd;
2215
2216 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2217 }
2218
2219 void qmp_closefd(const char *fdname, Error **errp)
2220 {
2221 mon_fd_t *monfd;
2222
2223 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2224 if (strcmp(monfd->name, fdname) != 0) {
2225 continue;
2226 }
2227
2228 QLIST_REMOVE(monfd, next);
2229 close(monfd->fd);
2230 g_free(monfd->name);
2231 g_free(monfd);
2232 return;
2233 }
2234
2235 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2236 }
2237
2238 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2239 {
2240 mon_fd_t *monfd;
2241
2242 QLIST_FOREACH(monfd, &mon->fds, next) {
2243 int fd;
2244
2245 if (strcmp(monfd->name, fdname) != 0) {
2246 continue;
2247 }
2248
2249 fd = monfd->fd;
2250
2251 /* caller takes ownership of fd */
2252 QLIST_REMOVE(monfd, next);
2253 g_free(monfd->name);
2254 g_free(monfd);
2255
2256 return fd;
2257 }
2258
2259 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2260 return -1;
2261 }
2262
2263 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2264 {
2265 MonFdsetFd *mon_fdset_fd;
2266 MonFdsetFd *mon_fdset_fd_next;
2267
2268 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2269 if ((mon_fdset_fd->removed ||
2270 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2271 runstate_is_running()) {
2272 close(mon_fdset_fd->fd);
2273 g_free(mon_fdset_fd->opaque);
2274 QLIST_REMOVE(mon_fdset_fd, next);
2275 g_free(mon_fdset_fd);
2276 }
2277 }
2278
2279 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2280 QLIST_REMOVE(mon_fdset, next);
2281 g_free(mon_fdset);
2282 }
2283 }
2284
2285 static void monitor_fdsets_cleanup(void)
2286 {
2287 MonFdset *mon_fdset;
2288 MonFdset *mon_fdset_next;
2289
2290 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2291 monitor_fdset_cleanup(mon_fdset);
2292 }
2293 }
2294
2295 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2296 const char *opaque, Error **errp)
2297 {
2298 int fd;
2299 Monitor *mon = cur_mon;
2300 AddfdInfo *fdinfo;
2301
2302 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2303 if (fd == -1) {
2304 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2305 goto error;
2306 }
2307
2308 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2309 has_opaque, opaque, errp);
2310 if (fdinfo) {
2311 return fdinfo;
2312 }
2313
2314 error:
2315 if (fd != -1) {
2316 close(fd);
2317 }
2318 return NULL;
2319 }
2320
2321 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2322 {
2323 MonFdset *mon_fdset;
2324 MonFdsetFd *mon_fdset_fd;
2325 char fd_str[60];
2326
2327 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2328 if (mon_fdset->id != fdset_id) {
2329 continue;
2330 }
2331 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2332 if (has_fd) {
2333 if (mon_fdset_fd->fd != fd) {
2334 continue;
2335 }
2336 mon_fdset_fd->removed = true;
2337 break;
2338 } else {
2339 mon_fdset_fd->removed = true;
2340 }
2341 }
2342 if (has_fd && !mon_fdset_fd) {
2343 goto error;
2344 }
2345 monitor_fdset_cleanup(mon_fdset);
2346 return;
2347 }
2348
2349 error:
2350 if (has_fd) {
2351 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2352 fdset_id, fd);
2353 } else {
2354 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2355 }
2356 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2357 }
2358
2359 FdsetInfoList *qmp_query_fdsets(Error **errp)
2360 {
2361 MonFdset *mon_fdset;
2362 MonFdsetFd *mon_fdset_fd;
2363 FdsetInfoList *fdset_list = NULL;
2364
2365 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2366 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2367 FdsetFdInfoList *fdsetfd_list = NULL;
2368
2369 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2370 fdset_info->value->fdset_id = mon_fdset->id;
2371
2372 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2373 FdsetFdInfoList *fdsetfd_info;
2374
2375 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2376 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2377 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2378 if (mon_fdset_fd->opaque) {
2379 fdsetfd_info->value->has_opaque = true;
2380 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2381 } else {
2382 fdsetfd_info->value->has_opaque = false;
2383 }
2384
2385 fdsetfd_info->next = fdsetfd_list;
2386 fdsetfd_list = fdsetfd_info;
2387 }
2388
2389 fdset_info->value->fds = fdsetfd_list;
2390
2391 fdset_info->next = fdset_list;
2392 fdset_list = fdset_info;
2393 }
2394
2395 return fdset_list;
2396 }
2397
2398 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2399 bool has_opaque, const char *opaque,
2400 Error **errp)
2401 {
2402 MonFdset *mon_fdset = NULL;
2403 MonFdsetFd *mon_fdset_fd;
2404 AddfdInfo *fdinfo;
2405
2406 if (has_fdset_id) {
2407 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2408 /* Break if match found or match impossible due to ordering by ID */
2409 if (fdset_id <= mon_fdset->id) {
2410 if (fdset_id < mon_fdset->id) {
2411 mon_fdset = NULL;
2412 }
2413 break;
2414 }
2415 }
2416 }
2417
2418 if (mon_fdset == NULL) {
2419 int64_t fdset_id_prev = -1;
2420 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2421
2422 if (has_fdset_id) {
2423 if (fdset_id < 0) {
2424 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2425 "a non-negative value");
2426 return NULL;
2427 }
2428 /* Use specified fdset ID */
2429 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2430 mon_fdset_cur = mon_fdset;
2431 if (fdset_id < mon_fdset_cur->id) {
2432 break;
2433 }
2434 }
2435 } else {
2436 /* Use first available fdset ID */
2437 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2438 mon_fdset_cur = mon_fdset;
2439 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2440 fdset_id_prev = mon_fdset_cur->id;
2441 continue;
2442 }
2443 break;
2444 }
2445 }
2446
2447 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2448 if (has_fdset_id) {
2449 mon_fdset->id = fdset_id;
2450 } else {
2451 mon_fdset->id = fdset_id_prev + 1;
2452 }
2453
2454 /* The fdset list is ordered by fdset ID */
2455 if (!mon_fdset_cur) {
2456 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2457 } else if (mon_fdset->id < mon_fdset_cur->id) {
2458 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2459 } else {
2460 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2461 }
2462 }
2463
2464 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2465 mon_fdset_fd->fd = fd;
2466 mon_fdset_fd->removed = false;
2467 if (has_opaque) {
2468 mon_fdset_fd->opaque = g_strdup(opaque);
2469 }
2470 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2471
2472 fdinfo = g_malloc0(sizeof(*fdinfo));
2473 fdinfo->fdset_id = mon_fdset->id;
2474 fdinfo->fd = mon_fdset_fd->fd;
2475
2476 return fdinfo;
2477 }
2478
2479 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2480 {
2481 #ifndef _WIN32
2482 MonFdset *mon_fdset;
2483 MonFdsetFd *mon_fdset_fd;
2484 int mon_fd_flags;
2485
2486 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2487 if (mon_fdset->id != fdset_id) {
2488 continue;
2489 }
2490 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2491 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2492 if (mon_fd_flags == -1) {
2493 return -1;
2494 }
2495
2496 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2497 return mon_fdset_fd->fd;
2498 }
2499 }
2500 errno = EACCES;
2501 return -1;
2502 }
2503 #endif
2504
2505 errno = ENOENT;
2506 return -1;
2507 }
2508
2509 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2510 {
2511 MonFdset *mon_fdset;
2512 MonFdsetFd *mon_fdset_fd_dup;
2513
2514 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2515 if (mon_fdset->id != fdset_id) {
2516 continue;
2517 }
2518 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2519 if (mon_fdset_fd_dup->fd == dup_fd) {
2520 return -1;
2521 }
2522 }
2523 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2524 mon_fdset_fd_dup->fd = dup_fd;
2525 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2526 return 0;
2527 }
2528 return -1;
2529 }
2530
2531 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2532 {
2533 MonFdset *mon_fdset;
2534 MonFdsetFd *mon_fdset_fd_dup;
2535
2536 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2537 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2538 if (mon_fdset_fd_dup->fd == dup_fd) {
2539 if (remove) {
2540 QLIST_REMOVE(mon_fdset_fd_dup, next);
2541 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2542 monitor_fdset_cleanup(mon_fdset);
2543 }
2544 return -1;
2545 } else {
2546 return mon_fdset->id;
2547 }
2548 }
2549 }
2550 }
2551 return -1;
2552 }
2553
2554 int monitor_fdset_dup_fd_find(int dup_fd)
2555 {
2556 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2557 }
2558
2559 void monitor_fdset_dup_fd_remove(int dup_fd)
2560 {
2561 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2562 }
2563
2564 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2565 {
2566 int fd;
2567 Error *local_err = NULL;
2568
2569 if (!qemu_isdigit(fdname[0]) && mon) {
2570 fd = monitor_get_fd(mon, fdname, &local_err);
2571 } else {
2572 fd = qemu_parse_fd(fdname);
2573 if (fd == -1) {
2574 error_setg(&local_err, "Invalid file descriptor number '%s'",
2575 fdname);
2576 }
2577 }
2578 if (local_err) {
2579 error_propagate(errp, local_err);
2580 assert(fd == -1);
2581 } else {
2582 assert(fd != -1);
2583 }
2584
2585 return fd;
2586 }
2587
2588 /* Please update hmp-commands.hx when adding or changing commands */
2589 static mon_cmd_t info_cmds[] = {
2590 #include "hmp-commands-info.h"
2591 { NULL, NULL, },
2592 };
2593
2594 /* mon_cmds and info_cmds would be sorted at runtime */
2595 static mon_cmd_t mon_cmds[] = {
2596 #include "hmp-commands.h"
2597 { NULL, NULL, },
2598 };
2599
2600 /*******************************************************************/
2601
2602 static const char *pch;
2603 static sigjmp_buf expr_env;
2604
2605
2606 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2607 expr_error(Monitor *mon, const char *fmt, ...)
2608 {
2609 va_list ap;
2610 va_start(ap, fmt);
2611 monitor_vprintf(mon, fmt, ap);
2612 monitor_printf(mon, "\n");
2613 va_end(ap);
2614 siglongjmp(expr_env, 1);
2615 }
2616
2617 /* return 0 if OK, -1 if not found */
2618 static int get_monitor_def(target_long *pval, const char *name)
2619 {
2620 const MonitorDef *md = target_monitor_defs();
2621 CPUState *cs = mon_get_cpu();
2622 void *ptr;
2623 uint64_t tmp = 0;
2624 int ret;
2625
2626 if (cs == NULL || md == NULL) {
2627 return -1;
2628 }
2629
2630 for(; md->name != NULL; md++) {
2631 if (compare_cmd(name, md->name)) {
2632 if (md->get_value) {
2633 *pval = md->get_value(md, md->offset);
2634 } else {
2635 CPUArchState *env = mon_get_cpu_env();
2636 ptr = (uint8_t *)env + md->offset;
2637 switch(md->type) {
2638 case MD_I32:
2639 *pval = *(int32_t *)ptr;
2640 break;
2641 case MD_TLONG:
2642 *pval = *(target_long *)ptr;
2643 break;
2644 default:
2645 *pval = 0;
2646 break;
2647 }
2648 }
2649 return 0;
2650 }
2651 }
2652
2653 ret = target_get_monitor_def(cs, name, &tmp);
2654 if (!ret) {
2655 *pval = (target_long) tmp;
2656 }
2657
2658 return ret;
2659 }
2660
2661 static void next(void)
2662 {
2663 if (*pch != '\0') {
2664 pch++;
2665 while (qemu_isspace(*pch))
2666 pch++;
2667 }
2668 }
2669
2670 static int64_t expr_sum(Monitor *mon);
2671
2672 static int64_t expr_unary(Monitor *mon)
2673 {
2674 int64_t n;
2675 char *p;
2676 int ret;
2677
2678 switch(*pch) {
2679 case '+':
2680 next();
2681 n = expr_unary(mon);
2682 break;
2683 case '-':
2684 next();
2685 n = -expr_unary(mon);
2686 break;
2687 case '~':
2688 next();
2689 n = ~expr_unary(mon);
2690 break;
2691 case '(':
2692 next();
2693 n = expr_sum(mon);
2694 if (*pch != ')') {
2695 expr_error(mon, "')' expected");
2696 }
2697 next();
2698 break;
2699 case '\'':
2700 pch++;
2701 if (*pch == '\0')
2702 expr_error(mon, "character constant expected");
2703 n = *pch;
2704 pch++;
2705 if (*pch != '\'')
2706 expr_error(mon, "missing terminating \' character");
2707 next();
2708 break;
2709 case '$':
2710 {
2711 char buf[128], *q;
2712 target_long reg=0;
2713
2714 pch++;
2715 q = buf;
2716 while ((*pch >= 'a' && *pch <= 'z') ||
2717 (*pch >= 'A' && *pch <= 'Z') ||
2718 (*pch >= '0' && *pch <= '9') ||
2719 *pch == '_' || *pch == '.') {
2720 if ((q - buf) < sizeof(buf) - 1)
2721 *q++ = *pch;
2722 pch++;
2723 }
2724 while (qemu_isspace(*pch))
2725 pch++;
2726 *q = 0;
2727 ret = get_monitor_def(&reg, buf);
2728 if (ret < 0)
2729 expr_error(mon, "unknown register");
2730 n = reg;
2731 }
2732 break;
2733 case '\0':
2734 expr_error(mon, "unexpected end of expression");
2735 n = 0;
2736 break;
2737 default:
2738 errno = 0;
2739 n = strtoull(pch, &p, 0);
2740 if (errno == ERANGE) {
2741 expr_error(mon, "number too large");
2742 }
2743 if (pch == p) {
2744 expr_error(mon, "invalid char '%c' in expression", *p);
2745 }
2746 pch = p;
2747 while (qemu_isspace(*pch))
2748 pch++;
2749 break;
2750 }
2751 return n;
2752 }
2753
2754
2755 static int64_t expr_prod(Monitor *mon)
2756 {
2757 int64_t val, val2;
2758 int op;
2759
2760 val = expr_unary(mon);
2761 for(;;) {
2762 op = *pch;
2763 if (op != '*' && op != '/' && op != '%')
2764 break;
2765 next();
2766 val2 = expr_unary(mon);
2767 switch(op) {
2768 default:
2769 case '*':
2770 val *= val2;
2771 break;
2772 case '/':
2773 case '%':
2774 if (val2 == 0)
2775 expr_error(mon, "division by zero");
2776 if (op == '/')
2777 val /= val2;
2778 else
2779 val %= val2;
2780 break;
2781 }
2782 }
2783 return val;
2784 }
2785
2786 static int64_t expr_logic(Monitor *mon)
2787 {
2788 int64_t val, val2;
2789 int op;
2790
2791 val = expr_prod(mon);
2792 for(;;) {
2793 op = *pch;
2794 if (op != '&' && op != '|' && op != '^')
2795 break;
2796 next();
2797 val2 = expr_prod(mon);
2798 switch(op) {
2799 default:
2800 case '&':
2801 val &= val2;
2802 break;
2803 case '|':
2804 val |= val2;
2805 break;
2806 case '^':
2807 val ^= val2;
2808 break;
2809 }
2810 }
2811 return val;
2812 }
2813
2814 static int64_t expr_sum(Monitor *mon)
2815 {
2816 int64_t val, val2;
2817 int op;
2818
2819 val = expr_logic(mon);
2820 for(;;) {
2821 op = *pch;
2822 if (op != '+' && op != '-')
2823 break;
2824 next();
2825 val2 = expr_logic(mon);
2826 if (op == '+')
2827 val += val2;
2828 else
2829 val -= val2;
2830 }
2831 return val;
2832 }
2833
2834 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2835 {
2836 pch = *pp;
2837 if (sigsetjmp(expr_env, 0)) {
2838 *pp = pch;
2839 return -1;
2840 }
2841 while (qemu_isspace(*pch))
2842 pch++;
2843 *pval = expr_sum(mon);
2844 *pp = pch;
2845 return 0;
2846 }
2847
2848 static int get_double(Monitor *mon, double *pval, const char **pp)
2849 {
2850 const char *p = *pp;
2851 char *tailp;
2852 double d;
2853
2854 d = strtod(p, &tailp);
2855 if (tailp == p) {
2856 monitor_printf(mon, "Number expected\n");
2857 return -1;
2858 }
2859 if (d != d || d - d != 0) {
2860 /* NaN or infinity */
2861 monitor_printf(mon, "Bad number\n");
2862 return -1;
2863 }
2864 *pval = d;
2865 *pp = tailp;
2866 return 0;
2867 }
2868
2869 /*
2870 * Store the command-name in cmdname, and return a pointer to
2871 * the remaining of the command string.
2872 */
2873 static const char *get_command_name(const char *cmdline,
2874 char *cmdname, size_t nlen)
2875 {
2876 size_t len;
2877 const char *p, *pstart;
2878
2879 p = cmdline;
2880 while (qemu_isspace(*p))
2881 p++;
2882 if (*p == '\0')
2883 return NULL;
2884 pstart = p;
2885 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2886 p++;
2887 len = p - pstart;
2888 if (len > nlen - 1)
2889 len = nlen - 1;
2890 memcpy(cmdname, pstart, len);
2891 cmdname[len] = '\0';
2892 return p;
2893 }
2894
2895 /**
2896 * Read key of 'type' into 'key' and return the current
2897 * 'type' pointer.
2898 */
2899 static char *key_get_info(const char *type, char **key)
2900 {
2901 size_t len;
2902 char *p, *str;
2903
2904 if (*type == ',')
2905 type++;
2906
2907 p = strchr(type, ':');
2908 if (!p) {
2909 *key = NULL;
2910 return NULL;
2911 }
2912 len = p - type;
2913
2914 str = g_malloc(len + 1);
2915 memcpy(str, type, len);
2916 str[len] = '\0';
2917
2918 *key = str;
2919 return ++p;
2920 }
2921
2922 static int default_fmt_format = 'x';
2923 static int default_fmt_size = 4;
2924
2925 static int is_valid_option(const char *c, const char *typestr)
2926 {
2927 char option[3];
2928
2929 option[0] = '-';
2930 option[1] = *c;
2931 option[2] = '\0';
2932
2933 typestr = strstr(typestr, option);
2934 return (typestr != NULL);
2935 }
2936
2937 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2938 const char *cmdname)
2939 {
2940 const mon_cmd_t *cmd;
2941
2942 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2943 if (compare_cmd(cmdname, cmd->name)) {
2944 return cmd;
2945 }
2946 }
2947
2948 return NULL;
2949 }
2950
2951 /*
2952 * Parse command name from @cmdp according to command table @table.
2953 * If blank, return NULL.
2954 * Else, if no valid command can be found, report to @mon, and return
2955 * NULL.
2956 * Else, change @cmdp to point right behind the name, and return its
2957 * command table entry.
2958 * Do not assume the return value points into @table! It doesn't when
2959 * the command is found in a sub-command table.
2960 */
2961 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2962 const char *cmdp_start,
2963 const char **cmdp,
2964 mon_cmd_t *table)
2965 {
2966 const char *p;
2967 const mon_cmd_t *cmd;
2968 char cmdname[256];
2969
2970 /* extract the command name */
2971 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2972 if (!p)
2973 return NULL;
2974
2975 cmd = search_dispatch_table(table, cmdname);
2976 if (!cmd) {
2977 monitor_printf(mon, "unknown command: '%.*s'\n",
2978 (int)(p - cmdp_start), cmdp_start);
2979 return NULL;
2980 }
2981
2982 /* filter out following useless space */
2983 while (qemu_isspace(*p)) {
2984 p++;
2985 }
2986
2987 *cmdp = p;
2988 /* search sub command */
2989 if (cmd->sub_table != NULL && *p != '\0') {
2990 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
2991 }
2992
2993 return cmd;
2994 }
2995
2996 /*
2997 * Parse arguments for @cmd.
2998 * If it can't be parsed, report to @mon, and return NULL.
2999 * Else, insert command arguments into a QDict, and return it.
3000 * Note: On success, caller has to free the QDict structure.
3001 */
3002
3003 static QDict *monitor_parse_arguments(Monitor *mon,
3004 const char **endp,
3005 const mon_cmd_t *cmd)
3006 {
3007 const char *typestr;
3008 char *key;
3009 int c;
3010 const char *p = *endp;
3011 char buf[1024];
3012 QDict *qdict = qdict_new();
3013
3014 /* parse the parameters */
3015 typestr = cmd->args_type;
3016 for(;;) {
3017 typestr = key_get_info(typestr, &key);
3018 if (!typestr)
3019 break;
3020 c = *typestr;
3021 typestr++;
3022 switch(c) {
3023 case 'F':
3024 case 'B':
3025 case 's':
3026 {
3027 int ret;
3028
3029 while (qemu_isspace(*p))
3030 p++;
3031 if (*typestr == '?') {
3032 typestr++;
3033 if (*p == '\0') {
3034 /* no optional string: NULL argument */
3035 break;
3036 }
3037 }
3038 ret = get_str(buf, sizeof(buf), &p);
3039 if (ret < 0) {
3040 switch(c) {
3041 case 'F':
3042 monitor_printf(mon, "%s: filename expected\n",
3043 cmd->name);
3044 break;
3045 case 'B':
3046 monitor_printf(mon, "%s: block device name expected\n",
3047 cmd->name);
3048 break;
3049 default:
3050 monitor_printf(mon, "%s: string expected\n", cmd->name);
3051 break;
3052 }
3053 goto fail;
3054 }
3055 qdict_put_str(qdict, key, buf);
3056 }
3057 break;
3058 case 'O':
3059 {
3060 QemuOptsList *opts_list;
3061 QemuOpts *opts;
3062
3063 opts_list = qemu_find_opts(key);
3064 if (!opts_list || opts_list->desc->name) {
3065 goto bad_type;
3066 }
3067 while (qemu_isspace(*p)) {
3068 p++;
3069 }
3070 if (!*p)
3071 break;
3072 if (get_str(buf, sizeof(buf), &p) < 0) {
3073 goto fail;
3074 }
3075 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3076 if (!opts) {
3077 goto fail;
3078 }
3079 qemu_opts_to_qdict(opts, qdict);
3080 qemu_opts_del(opts);
3081 }
3082 break;
3083 case '/':
3084 {
3085 int count, format, size;
3086
3087 while (qemu_isspace(*p))
3088 p++;
3089 if (*p == '/') {
3090 /* format found */
3091 p++;
3092 count = 1;
3093 if (qemu_isdigit(*p)) {
3094 count = 0;
3095 while (qemu_isdigit(*p)) {
3096 count = count * 10 + (*p - '0');
3097 p++;
3098 }
3099 }
3100 size = -1;
3101 format = -1;
3102 for(;;) {
3103 switch(*p) {
3104 case 'o':
3105 case 'd':
3106 case 'u':
3107 case 'x':
3108 case 'i':
3109 case 'c':
3110 format = *p++;
3111 break;
3112 case 'b':
3113 size = 1;
3114 p++;
3115 break;
3116 case 'h':
3117 size = 2;
3118 p++;
3119 break;
3120 case 'w':
3121 size = 4;
3122 p++;
3123 break;
3124 case 'g':
3125 case 'L':
3126 size = 8;
3127 p++;
3128 break;
3129 default:
3130 goto next;
3131 }
3132 }
3133 next:
3134 if (*p != '\0' && !qemu_isspace(*p)) {
3135 monitor_printf(mon, "invalid char in format: '%c'\n",
3136 *p);
3137 goto fail;
3138 }
3139 if (format < 0)
3140 format = default_fmt_format;
3141 if (format != 'i') {
3142 /* for 'i', not specifying a size gives -1 as size */
3143 if (size < 0)
3144 size = default_fmt_size;
3145 default_fmt_size = size;
3146 }
3147 default_fmt_format = format;
3148 } else {
3149 count = 1;
3150 format = default_fmt_format;
3151 if (format != 'i') {
3152 size = default_fmt_size;
3153 } else {
3154 size = -1;
3155 }
3156 }
3157 qdict_put_int(qdict, "count", count);
3158 qdict_put_int(qdict, "format", format);
3159 qdict_put_int(qdict, "size", size);
3160 }
3161 break;
3162 case 'i':
3163 case 'l':
3164 case 'M':
3165 {
3166 int64_t val;
3167
3168 while (qemu_isspace(*p))
3169 p++;
3170 if (*typestr == '?' || *typestr == '.') {
3171 if (*typestr == '?') {
3172 if (*p == '\0') {
3173 typestr++;
3174 break;
3175 }
3176 } else {
3177 if (*p == '.') {
3178 p++;
3179 while (qemu_isspace(*p))
3180 p++;
3181 } else {
3182 typestr++;
3183 break;
3184 }
3185 }
3186 typestr++;
3187 }
3188 if (get_expr(mon, &val, &p))
3189 goto fail;
3190 /* Check if 'i' is greater than 32-bit */
3191 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3192 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3193 monitor_printf(mon, "integer is for 32-bit values\n");
3194 goto fail;
3195 } else if (c == 'M') {
3196 if (val < 0) {
3197 monitor_printf(mon, "enter a positive value\n");
3198 goto fail;
3199 }
3200 val <<= 20;
3201 }
3202 qdict_put_int(qdict, key, val);
3203 }
3204 break;
3205 case 'o':
3206 {
3207 int ret;
3208 uint64_t val;
3209 char *end;
3210
3211 while (qemu_isspace(*p)) {
3212 p++;
3213 }
3214 if (*typestr == '?') {
3215 typestr++;
3216 if (*p == '\0') {
3217 break;
3218 }
3219 }
3220 ret = qemu_strtosz_MiB(p, &end, &val);
3221 if (ret < 0 || val > INT64_MAX) {
3222 monitor_printf(mon, "invalid size\n");
3223 goto fail;
3224 }
3225 qdict_put_int(qdict, key, val);
3226 p = end;
3227 }
3228 break;
3229 case 'T':
3230 {
3231 double val;
3232
3233 while (qemu_isspace(*p))
3234 p++;
3235 if (*typestr == '?') {
3236 typestr++;
3237 if (*p == '\0') {
3238 break;
3239 }
3240 }
3241 if (get_double(mon, &val, &p) < 0) {
3242 goto fail;
3243 }
3244 if (p[0] && p[1] == 's') {
3245 switch (*p) {
3246 case 'm':
3247 val /= 1e3; p += 2; break;
3248 case 'u':
3249 val /= 1e6; p += 2; break;
3250 case 'n':
3251 val /= 1e9; p += 2; break;
3252 }
3253 }
3254 if (*p && !qemu_isspace(*p)) {
3255 monitor_printf(mon, "Unknown unit suffix\n");
3256 goto fail;
3257 }
3258 qdict_put(qdict, key, qnum_from_double(val));
3259 }
3260 break;
3261 case 'b':
3262 {
3263 const char *beg;
3264 bool val;
3265
3266 while (qemu_isspace(*p)) {
3267 p++;
3268 }
3269 beg = p;
3270 while (qemu_isgraph(*p)) {
3271 p++;
3272 }
3273 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3274 val = true;
3275 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3276 val = false;
3277 } else {
3278 monitor_printf(mon, "Expected 'on' or 'off'\n");
3279 goto fail;
3280 }
3281 qdict_put_bool(qdict, key, val);
3282 }
3283 break;
3284 case '-':
3285 {
3286 const char *tmp = p;
3287 int skip_key = 0;
3288 /* option */
3289
3290 c = *typestr++;
3291 if (c == '\0')
3292 goto bad_type;
3293 while (qemu_isspace(*p))
3294 p++;
3295 if (*p == '-') {
3296 p++;
3297 if(c != *p) {
3298 if(!is_valid_option(p, typestr)) {
3299
3300 monitor_printf(mon, "%s: unsupported option -%c\n",
3301 cmd->name, *p);
3302 goto fail;
3303 } else {
3304 skip_key = 1;
3305 }
3306 }
3307 if(skip_key) {
3308 p = tmp;
3309 } else {
3310 /* has option */
3311 p++;
3312 qdict_put_bool(qdict, key, true);
3313 }
3314 }
3315 }
3316 break;
3317 case 'S':
3318 {
3319 /* package all remaining string */
3320 int len;
3321
3322 while (qemu_isspace(*p)) {
3323 p++;
3324 }
3325 if (*typestr == '?') {
3326 typestr++;
3327 if (*p == '\0') {
3328 /* no remaining string: NULL argument */
3329 break;
3330 }
3331 }
3332 len = strlen(p);
3333 if (len <= 0) {
3334 monitor_printf(mon, "%s: string expected\n",
3335 cmd->name);
3336 goto fail;
3337 }
3338 qdict_put_str(qdict, key, p);
3339 p += len;
3340 }
3341 break;
3342 default:
3343 bad_type:
3344 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3345 goto fail;
3346 }
3347 g_free(key);
3348 key = NULL;
3349 }
3350 /* check that all arguments were parsed */
3351 while (qemu_isspace(*p))
3352 p++;
3353 if (*p != '\0') {
3354 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3355 cmd->name);
3356 goto fail;
3357 }
3358
3359 return qdict;
3360
3361 fail:
3362 qobject_unref(qdict);
3363 g_free(key);
3364 return NULL;
3365 }
3366
3367 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3368 {
3369 QDict *qdict;
3370 const mon_cmd_t *cmd;
3371
3372 trace_handle_hmp_command(mon, cmdline);
3373
3374 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3375 if (!cmd) {
3376 return;
3377 }
3378
3379 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3380 if (!qdict) {
3381 monitor_printf(mon, "Try \"help %s\" for more information\n",
3382 cmd->name);
3383 return;
3384 }
3385
3386 cmd->cmd(mon, qdict);
3387 qobject_unref(qdict);
3388 }
3389
3390 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3391 {
3392 const char *p, *pstart;
3393 char cmd[128];
3394 int len;
3395
3396 p = list;
3397 for(;;) {
3398 pstart = p;
3399 p = strchr(p, '|');
3400 if (!p)
3401 p = pstart + strlen(pstart);
3402 len = p - pstart;
3403 if (len > sizeof(cmd) - 2)
3404 len = sizeof(cmd) - 2;
3405 memcpy(cmd, pstart, len);
3406 cmd[len] = '\0';
3407 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3408 readline_add_completion(mon->rs, cmd);
3409 }
3410 if (*p == '\0')
3411 break;
3412 p++;
3413 }
3414 }
3415
3416 static void file_completion(Monitor *mon, const char *input)
3417 {
3418 DIR *ffs;
3419 struct dirent *d;
3420 char path[1024];
3421 char file[1024], file_prefix[1024];
3422 int input_path_len;
3423 const char *p;
3424
3425 p = strrchr(input, '/');
3426 if (!p) {
3427 input_path_len = 0;
3428 pstrcpy(file_prefix, sizeof(file_prefix), input);
3429 pstrcpy(path, sizeof(path), ".");
3430 } else {
3431 input_path_len = p - input + 1;
3432 memcpy(path, input, input_path_len);
3433 if (input_path_len > sizeof(path) - 1)
3434 input_path_len = sizeof(path) - 1;
3435 path[input_path_len] = '\0';
3436 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3437 }
3438
3439 ffs = opendir(path);
3440 if (!ffs)
3441 return;
3442 for(;;) {
3443 struct stat sb;
3444 d = readdir(ffs);
3445 if (!d)
3446 break;
3447
3448 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3449 continue;
3450 }
3451
3452 if (strstart(d->d_name, file_prefix, NULL)) {
3453 memcpy(file, input, input_path_len);
3454 if (input_path_len < sizeof(file))
3455 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3456 d->d_name);
3457 /* stat the file to find out if it's a directory.
3458 * In that case add a slash to speed up typing long paths
3459 */
3460 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3461 pstrcat(file, sizeof(file), "/");
3462 }
3463 readline_add_completion(mon->rs, file);
3464 }
3465 }
3466 closedir(ffs);
3467 }
3468
3469 static const char *next_arg_type(const char *typestr)
3470 {
3471 const char *p = strchr(typestr, ':');
3472 return (p != NULL ? ++p : typestr);
3473 }
3474
3475 static void add_completion_option(ReadLineState *rs, const char *str,
3476 const char *option)
3477 {
3478 if (!str || !option) {
3479 return;
3480 }
3481 if (!strncmp(option, str, strlen(str))) {
3482 readline_add_completion(rs, option);
3483 }
3484 }
3485
3486 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3487 {
3488 size_t len;
3489 ChardevBackendInfoList *list, *start;
3490
3491 if (nb_args != 2) {
3492 return;
3493 }
3494 len = strlen(str);
3495 readline_set_completion_index(rs, len);
3496
3497 start = list = qmp_query_chardev_backends(NULL);
3498 while (list) {
3499 const char *chr_name = list->value->name;
3500
3501 if (!strncmp(chr_name, str, len)) {
3502 readline_add_completion(rs, chr_name);
3503 }
3504 list = list->next;
3505 }
3506 qapi_free_ChardevBackendInfoList(start);
3507 }
3508
3509 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3510 {
3511 size_t len;
3512 int i;
3513
3514 if (nb_args != 2) {
3515 return;
3516 }
3517 len = strlen(str);
3518 readline_set_completion_index(rs, len);
3519 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3520 add_completion_option(rs, str, NetClientDriver_str(i));
3521 }
3522 }
3523
3524 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3525 {
3526 GSList *list, *elt;
3527 size_t len;
3528
3529 if (nb_args != 2) {
3530 return;
3531 }
3532
3533 len = strlen(str);
3534 readline_set_completion_index(rs, len);
3535 list = elt = object_class_get_list(TYPE_DEVICE, false);
3536 while (elt) {
3537 const char *name;
3538 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3539 TYPE_DEVICE);
3540 name = object_class_get_name(OBJECT_CLASS(dc));
3541
3542 if (dc->user_creatable
3543 && !strncmp(name, str, len)) {
3544 readline_add_completion(rs, name);
3545 }
3546 elt = elt->next;
3547 }
3548 g_slist_free(list);
3549 }
3550
3551 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3552 {
3553 GSList *list, *elt;
3554 size_t len;
3555
3556 if (nb_args != 2) {
3557 return;
3558 }
3559
3560 len = strlen(str);
3561 readline_set_completion_index(rs, len);
3562 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3563 while (elt) {
3564 const char *name;
3565
3566 name = object_class_get_name(OBJECT_CLASS(elt->data));
3567 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3568 readline_add_completion(rs, name);
3569 }
3570 elt = elt->next;
3571 }
3572 g_slist_free(list);
3573 }
3574
3575 static void peripheral_device_del_completion(ReadLineState *rs,
3576 const char *str, size_t len)
3577 {
3578 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3579 GSList *list, *item;
3580
3581 list = qdev_build_hotpluggable_device_list(peripheral);
3582 if (!list) {
3583 return;
3584 }
3585
3586 for (item = list; item; item = g_slist_next(item)) {
3587 DeviceState *dev = item->data;
3588
3589 if (dev->id && !strncmp(str, dev->id, len)) {
3590 readline_add_completion(rs, dev->id);
3591 }
3592 }
3593
3594 g_slist_free(list);
3595 }
3596
3597 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3598 {
3599 size_t len;
3600 ChardevInfoList *list, *start;
3601
3602 if (nb_args != 2) {
3603 return;
3604 }
3605 len = strlen(str);
3606 readline_set_completion_index(rs, len);
3607
3608 start = list = qmp_query_chardev(NULL);
3609 while (list) {
3610 ChardevInfo *chr = list->value;
3611
3612 if (!strncmp(chr->label, str, len)) {
3613 readline_add_completion(rs, chr->label);
3614 }
3615 list = list->next;
3616 }
3617 qapi_free_ChardevInfoList(start);
3618 }
3619
3620 static void ringbuf_completion(ReadLineState *rs, const char *str)
3621 {
3622 size_t len;
3623 ChardevInfoList *list, *start;
3624
3625 len = strlen(str);
3626 readline_set_completion_index(rs, len);
3627
3628 start = list = qmp_query_chardev(NULL);
3629 while (list) {
3630 ChardevInfo *chr_info = list->value;
3631
3632 if (!strncmp(chr_info->label, str, len)) {
3633 Chardev *chr = qemu_chr_find(chr_info->label);
3634 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3635 readline_add_completion(rs, chr_info->label);
3636 }
3637 }
3638 list = list->next;
3639 }
3640 qapi_free_ChardevInfoList(start);
3641 }
3642
3643 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3644 {
3645 if (nb_args != 2) {
3646 return;
3647 }
3648 ringbuf_completion(rs, str);
3649 }
3650
3651 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3652 {
3653 size_t len;
3654
3655 if (nb_args != 2) {
3656 return;
3657 }
3658
3659 len = strlen(str);
3660 readline_set_completion_index(rs, len);
3661 peripheral_device_del_completion(rs, str, len);
3662 }
3663
3664 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3665 {
3666 ObjectPropertyInfoList *list, *start;
3667 size_t len;
3668
3669 if (nb_args != 2) {
3670 return;
3671 }
3672 len = strlen(str);
3673 readline_set_completion_index(rs, len);
3674
3675 start = list = qmp_qom_list("/objects", NULL);
3676 while (list) {
3677 ObjectPropertyInfo *info = list->value;
3678
3679 if (!strncmp(info->type, "child<", 5)
3680 && !strncmp(info->name, str, len)) {
3681 readline_add_completion(rs, info->name);
3682 }
3683 list = list->next;
3684 }
3685 qapi_free_ObjectPropertyInfoList(start);
3686 }
3687
3688 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3689 {
3690 int i;
3691 char *sep;
3692 size_t len;
3693
3694 if (nb_args != 2) {
3695 return;
3696 }
3697 sep = strrchr(str, '-');
3698 if (sep) {
3699 str = sep + 1;
3700 }
3701 len = strlen(str);
3702 readline_set_completion_index(rs, len);
3703 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3704 if (!strncmp(str, QKeyCode_str(i), len)) {
3705 readline_add_completion(rs, QKeyCode_str(i));
3706 }
3707 }
3708 }
3709
3710 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3711 {
3712 size_t len;
3713
3714 len = strlen(str);
3715 readline_set_completion_index(rs, len);
3716 if (nb_args == 2) {
3717 NetClientState *ncs[MAX_QUEUE_NUM];
3718 int count, i;
3719 count = qemu_find_net_clients_except(NULL, ncs,
3720 NET_CLIENT_DRIVER_NONE,
3721 MAX_QUEUE_NUM);
3722 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3723 const char *name = ncs[i]->name;
3724 if (!strncmp(str, name, len)) {
3725 readline_add_completion(rs, name);
3726 }
3727 }
3728 } else if (nb_args == 3) {
3729 add_completion_option(rs, str, "on");
3730 add_completion_option(rs, str, "off");
3731 }
3732 }
3733
3734 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3735 {
3736 int len, count, i;
3737 NetClientState *ncs[MAX_QUEUE_NUM];
3738
3739 if (nb_args != 2) {
3740 return;
3741 }
3742
3743 len = strlen(str);
3744 readline_set_completion_index(rs, len);
3745 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3746 MAX_QUEUE_NUM);
3747 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3748 QemuOpts *opts;
3749 const char *name = ncs[i]->name;
3750 if (strncmp(str, name, len)) {
3751 continue;
3752 }
3753 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3754 if (opts) {
3755 readline_add_completion(rs, name);
3756 }
3757 }
3758 }
3759
3760 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3761 {
3762 size_t len;
3763
3764 len = strlen(str);
3765 readline_set_completion_index(rs, len);
3766 if (nb_args == 2) {
3767 TraceEventIter iter;
3768 TraceEvent *ev;
3769 char *pattern = g_strdup_printf("%s*", str);
3770 trace_event_iter_init(&iter, pattern);
3771 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3772 readline_add_completion(rs, trace_event_get_name(ev));
3773 }
3774 g_free(pattern);
3775 }
3776 }
3777
3778 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3779 {
3780 size_t len;
3781
3782 len = strlen(str);
3783 readline_set_completion_index(rs, len);
3784 if (nb_args == 2) {
3785 TraceEventIter iter;
3786 TraceEvent *ev;
3787 char *pattern = g_strdup_printf("%s*", str);
3788 trace_event_iter_init(&iter, pattern);
3789 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3790 readline_add_completion(rs, trace_event_get_name(ev));
3791 }
3792 g_free(pattern);
3793 } else if (nb_args == 3) {
3794 add_completion_option(rs, str, "on");
3795 add_completion_option(rs, str, "off");
3796 }
3797 }
3798
3799 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3800 {
3801 int i;
3802
3803 if (nb_args != 2) {
3804 return;
3805 }
3806 readline_set_completion_index(rs, strlen(str));
3807 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3808 add_completion_option(rs, str, WatchdogAction_str(i));
3809 }
3810 }
3811
3812 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3813 const char *str)
3814 {
3815 size_t len;
3816
3817 len = strlen(str);
3818 readline_set_completion_index(rs, len);
3819 if (nb_args == 2) {
3820 int i;
3821 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3822 const char *name = MigrationCapability_str(i);
3823 if (!strncmp(str, name, len)) {
3824 readline_add_completion(rs, name);
3825 }
3826 }
3827 } else if (nb_args == 3) {
3828 add_completion_option(rs, str, "on");
3829 add_completion_option(rs, str, "off");
3830 }
3831 }
3832
3833 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3834 const char *str)
3835 {
3836 size_t len;
3837
3838 len = strlen(str);
3839 readline_set_completion_index(rs, len);
3840 if (nb_args == 2) {
3841 int i;
3842 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3843 const char *name = MigrationParameter_str(i);
3844 if (!strncmp(str, name, len)) {
3845 readline_add_completion(rs, name);
3846 }
3847 }
3848 }
3849 }
3850
3851 static void vm_completion(ReadLineState *rs, const char *str)
3852 {
3853 size_t len;
3854 BlockDriverState *bs;
3855 BdrvNextIterator it;
3856
3857 len = strlen(str);
3858 readline_set_completion_index(rs, len);
3859
3860 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3861 SnapshotInfoList *snapshots, *snapshot;
3862 AioContext *ctx = bdrv_get_aio_context(bs);
3863 bool ok = false;
3864
3865 aio_context_acquire(ctx);
3866 if (bdrv_can_snapshot(bs)) {
3867 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3868 }
3869 aio_context_release(ctx);
3870 if (!ok) {
3871 continue;
3872 }
3873
3874 snapshot = snapshots;
3875 while (snapshot) {
3876 char *completion = snapshot->value->name;
3877 if (!strncmp(str, completion, len)) {
3878 readline_add_completion(rs, completion);
3879 }
3880 completion = snapshot->value->id;
3881 if (!strncmp(str, completion, len)) {
3882 readline_add_completion(rs, completion);
3883 }
3884 snapshot = snapshot->next;
3885 }
3886 qapi_free_SnapshotInfoList(snapshots);
3887 }
3888
3889 }
3890
3891 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3892 {
3893 if (nb_args == 2) {
3894 vm_completion(rs, str);
3895 }
3896 }
3897
3898 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3899 {
3900 if (nb_args == 2) {
3901 vm_completion(rs, str);
3902 }
3903 }
3904
3905 static void monitor_find_completion_by_table(Monitor *mon,
3906 const mon_cmd_t *cmd_table,
3907 char **args,
3908 int nb_args)
3909 {
3910 const char *cmdname;
3911 int i;
3912 const char *ptype, *old_ptype, *str, *name;
3913 const mon_cmd_t *cmd;
3914 BlockBackend *blk = NULL;
3915
3916 if (nb_args <= 1) {
3917 /* command completion */
3918 if (nb_args == 0)
3919 cmdname = "";
3920 else
3921 cmdname = args[0];
3922 readline_set_completion_index(mon->rs, strlen(cmdname));
3923 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3924 cmd_completion(mon, cmdname, cmd->name);
3925 }
3926 } else {
3927 /* find the command */
3928 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3929 if (compare_cmd(args[0], cmd->name)) {
3930 break;
3931 }
3932 }
3933 if (!cmd->name) {
3934 return;
3935 }
3936
3937 if (cmd->sub_table) {
3938 /* do the job again */
3939 monitor_find_completion_by_table(mon, cmd->sub_table,
3940 &args[1], nb_args - 1);
3941 return;
3942 }
3943 if (cmd->command_completion) {
3944 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3945 return;
3946 }
3947
3948 ptype = next_arg_type(cmd->args_type);
3949 for(i = 0; i < nb_args - 2; i++) {
3950 if (*ptype != '\0') {
3951 ptype = next_arg_type(ptype);
3952 while (*ptype == '?')
3953 ptype = next_arg_type(ptype);
3954 }
3955 }
3956 str = args[nb_args - 1];
3957 old_ptype = NULL;
3958 while (*ptype == '-' && old_ptype != ptype) {
3959 old_ptype = ptype;
3960 ptype = next_arg_type(ptype);
3961 }
3962 switch(*ptype) {
3963 case 'F':
3964 /* file completion */
3965 readline_set_completion_index(mon->rs, strlen(str));
3966 file_completion(mon, str);
3967 break;
3968 case 'B':
3969 /* block device name completion */
3970 readline_set_completion_index(mon->rs, strlen(str));
3971 while ((blk = blk_next(blk)) != NULL) {
3972 name = blk_name(blk);
3973 if (str[0] == '\0' ||
3974 !strncmp(name, str, strlen(str))) {
3975 readline_add_completion(mon->rs, name);
3976 }
3977 }
3978 break;
3979 case 's':
3980 case 'S':
3981 if (!strcmp(cmd->name, "help|?")) {
3982 monitor_find_completion_by_table(mon, cmd_table,
3983 &args[1], nb_args - 1);
3984 }
3985 break;
3986 default:
3987 break;
3988 }
3989 }
3990 }
3991
3992 static void monitor_find_completion(void *opaque,
3993 const char *cmdline)
3994 {
3995 Monitor *mon = opaque;
3996 char *args[MAX_ARGS];
3997 int nb_args, len;
3998
3999 /* 1. parse the cmdline */
4000 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4001 return;
4002 }
4003
4004 /* if the line ends with a space, it means we want to complete the
4005 next arg */
4006 len = strlen(cmdline);
4007 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4008 if (nb_args >= MAX_ARGS) {
4009 goto cleanup;
4010 }
4011 args[nb_args++] = g_strdup("");
4012 }
4013
4014 /* 2. auto complete according to args */
4015 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4016
4017 cleanup:
4018 free_cmdline_args(args, nb_args);
4019 }
4020
4021 static int monitor_can_read(void *opaque)
4022 {
4023 Monitor *mon = opaque;
4024
4025 return !atomic_mb_read(&mon->suspend_cnt);
4026 }
4027
4028 /*
4029 * 1. This function takes ownership of rsp, err, and id.
4030 * 2. rsp, err, and id may be NULL.
4031 * 3. If err != NULL then rsp must be NULL.
4032 */
4033 static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
4034 Error *err, QObject *id)
4035 {
4036 QDict *qdict = NULL;
4037
4038 if (err) {
4039 assert(!rsp);
4040 qdict = qdict_new();
4041 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
4042 error_free(err);
4043 rsp = QOBJECT(qdict);
4044 }
4045
4046 if (rsp) {
4047 if (id) {
4048 qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
4049 }
4050
4051 monitor_json_emitter(mon, rsp);
4052 }
4053
4054 qobject_unref(id);
4055 qobject_unref(rsp);
4056 }
4057
4058 /*
4059 * Dispatch one single QMP request. The function will free the req_obj
4060 * and objects inside it before return.
4061 */
4062 static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
4063 {
4064 Monitor *mon, *old_mon;
4065 QObject *req, *rsp = NULL, *id;
4066 bool need_resume;
4067
4068 req = req_obj->req;
4069 mon = req_obj->mon;
4070 id = req_obj->id;
4071 need_resume = req_obj->need_resume;
4072
4073 g_free(req_obj);
4074
4075 if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4076 QString *req_json = qobject_to_json(req);
4077 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4078 qobject_unref(req_json);
4079 }
4080
4081 old_mon = cur_mon;
4082 cur_mon = mon;
4083
4084 rsp = qmp_dispatch(mon->qmp.commands, req);
4085
4086 cur_mon = old_mon;
4087
4088 /* Respond if necessary */
4089 monitor_qmp_respond(mon, rsp, NULL, id);
4090
4091 /* This pairs with the monitor_suspend() in handle_qmp_command(). */
4092 if (need_resume) {
4093 monitor_resume(mon);
4094 }
4095
4096 qobject_unref(req);
4097 }
4098
4099 /*
4100 * Pop one QMP request from monitor queues, return NULL if not found.
4101 * We are using round-robin fashion to pop the request, to avoid
4102 * processing commands only on a very busy monitor. To achieve that,
4103 * when we process one request on a specific monitor, we put that
4104 * monitor to the end of mon_list queue.
4105 */
4106 static QMPRequest *monitor_qmp_requests_pop_one(void)
4107 {
4108 QMPRequest *req_obj = NULL;
4109 Monitor *mon;
4110
4111 qemu_mutex_lock(&monitor_lock);
4112
4113 QTAILQ_FOREACH(mon, &mon_list, entry) {
4114 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4115 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4116 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4117 if (req_obj) {
4118 break;
4119 }
4120 }
4121
4122 if (req_obj) {
4123 /*
4124 * We found one request on the monitor. Degrade this monitor's
4125 * priority to lowest by re-inserting it to end of queue.
4126 */
4127 QTAILQ_REMOVE(&mon_list, mon, entry);
4128 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4129 }
4130
4131 qemu_mutex_unlock(&monitor_lock);
4132
4133 return req_obj;
4134 }
4135
4136 static void monitor_qmp_bh_dispatcher(void *data)
4137 {
4138 QMPRequest *req_obj = monitor_qmp_requests_pop_one();
4139
4140 if (req_obj) {
4141 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4142 monitor_qmp_dispatch_one(req_obj);
4143 /* Reschedule instead of looping so the main loop stays responsive */
4144 qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4145 }
4146 }
4147
4148 #define QMP_REQ_QUEUE_LEN_MAX (8)
4149
4150 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
4151 {
4152 QObject *req, *id = NULL;
4153 QDict *qdict = NULL;
4154 MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
4155 Monitor *mon = container_of(mon_qmp, Monitor, qmp);
4156 Error *err = NULL;
4157 QMPRequest *req_obj;
4158
4159 req = json_parser_parse_err(tokens, NULL, &err);
4160 if (!req && !err) {
4161 /* json_parser_parse_err() sucks: can fail without setting @err */
4162 error_setg(&err, QERR_JSON_PARSING);
4163 }
4164 if (err) {
4165 goto err;
4166 }
4167
4168 /* Check against the request in general layout */
4169 qdict = qmp_dispatch_check_obj(req, &err);
4170 if (!qdict) {
4171 goto err;
4172 }
4173
4174 /* Check against OOB specific */
4175 if (!qmp_cmd_oob_check(mon, qdict, &err)) {
4176 goto err;
4177 }
4178
4179 id = qdict_get(qdict, "id");
4180
4181 /* When OOB is enabled, the "id" field is mandatory. */
4182 if (qmp_oob_enabled(mon) && !id) {
4183 error_setg(&err, "Out-Of-Band capability requires that "
4184 "every command contains an 'id' field");
4185 goto err;
4186 }
4187
4188 req_obj = g_new0(QMPRequest, 1);
4189 req_obj->mon = mon;
4190 req_obj->id = qobject_ref(id);
4191 req_obj->req = req;
4192 req_obj->need_resume = false;
4193
4194 qdict_del(qdict, "id");
4195
4196 if (qmp_is_oob(qdict)) {
4197 /* Out-Of-Band (OOB) requests are executed directly in parser. */
4198 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
4199 ?: "");
4200 monitor_qmp_dispatch_one(req_obj);
4201 return;
4202 }
4203
4204 /* Protect qmp_requests and fetching its length. */
4205 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4206
4207 /*
4208 * If OOB is not enabled on the current monitor, we'll emulate the
4209 * old behavior that we won't process the current monitor any more
4210 * until it has responded. This helps make sure that as long as
4211 * OOB is not enabled, the server will never drop any command.
4212 */
4213 if (!qmp_oob_enabled(mon)) {
4214 monitor_suspend(mon);
4215 req_obj->need_resume = true;
4216 } else {
4217 /* Drop the request if queue is full. */
4218 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4219 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4220 qapi_event_send_command_dropped(id,
4221 COMMAND_DROP_REASON_QUEUE_FULL,
4222 &error_abort);
4223 qmp_request_free(req_obj);
4224 return;
4225 }
4226 }
4227
4228 /*
4229 * Put the request to the end of queue so that requests will be
4230 * handled in time order. Ownership for req_obj, req, id,
4231 * etc. will be delivered to the handler side.
4232 */
4233 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4234 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4235
4236 /* Kick the dispatcher routine */
4237 qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4238 return;
4239
4240 err:
4241 monitor_qmp_respond(mon, NULL, err, NULL);
4242 qobject_unref(req);
4243 }
4244
4245 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4246 {
4247 Monitor *mon = opaque;
4248
4249 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4250 }
4251
4252 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4253 {
4254 Monitor *old_mon = cur_mon;
4255 int i;
4256
4257 cur_mon = opaque;
4258
4259 if (cur_mon->rs) {
4260 for (i = 0; i < size; i++)
4261 readline_handle_byte(cur_mon->rs, buf[i]);
4262 } else {
4263 if (size == 0 || buf[size - 1] != 0)
4264 monitor_printf(cur_mon, "corrupted command\n");
4265 else
4266 handle_hmp_command(cur_mon, (char *)buf);
4267 }
4268
4269 cur_mon = old_mon;
4270 }
4271
4272 static void monitor_command_cb(void *opaque, const char *cmdline,
4273 void *readline_opaque)
4274 {
4275 Monitor *mon = opaque;
4276
4277 monitor_suspend(mon);
4278 handle_hmp_command(mon, cmdline);
4279 monitor_resume(mon);
4280 }
4281
4282 int monitor_suspend(Monitor *mon)
4283 {
4284 if (monitor_is_hmp_non_interactive(mon)) {
4285 return -ENOTTY;
4286 }
4287
4288 atomic_inc(&mon->suspend_cnt);
4289
4290 if (monitor_is_qmp(mon)) {
4291 /*
4292 * Kick iothread to make sure this takes effect. It'll be
4293 * evaluated again in prepare() of the watch object.
4294 */
4295 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4296 }
4297
4298 trace_monitor_suspend(mon, 1);
4299 return 0;
4300 }
4301
4302 void monitor_resume(Monitor *mon)
4303 {
4304 if (monitor_is_hmp_non_interactive(mon)) {
4305 return;
4306 }
4307
4308 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4309 if (monitor_is_qmp(mon)) {
4310 /*
4311 * For QMP monitors that are running in IOThread, let's
4312 * kick the thread in case it's sleeping.
4313 */
4314 if (mon->use_io_thr) {
4315 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4316 }
4317 } else {
4318 assert(mon->rs);
4319 readline_show_prompt(mon->rs);
4320 }
4321 }
4322 trace_monitor_suspend(mon, -1);
4323 }
4324
4325 static QObject *get_qmp_greeting(Monitor *mon)
4326 {
4327 QList *cap_list = qlist_new();
4328 QObject *ver = NULL;
4329 QMPCapability cap;
4330
4331 qmp_marshal_query_version(NULL, &ver, NULL);
4332
4333 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4334 if (!mon->use_io_thr && cap == QMP_CAPABILITY_OOB) {
4335 /* Monitors that are not using IOThread won't support OOB */
4336 continue;
4337 }
4338 qlist_append_str(cap_list, QMPCapability_str(cap));
4339 }
4340
4341 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
4342 ver, cap_list);
4343 }
4344
4345 static void monitor_qmp_caps_reset(Monitor *mon)
4346 {
4347 memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
4348 }
4349
4350 static void monitor_qmp_event(void *opaque, int event)
4351 {
4352 QObject *data;
4353 Monitor *mon = opaque;
4354
4355 switch (event) {
4356 case CHR_EVENT_OPENED:
4357 mon->qmp.commands = &qmp_cap_negotiation_commands;
4358 monitor_qmp_caps_reset(mon);
4359 data = get_qmp_greeting(mon);
4360 monitor_json_emitter(mon, data);
4361 qobject_unref(data);
4362 mon_refcount++;
4363 break;
4364 case CHR_EVENT_CLOSED:
4365 monitor_qmp_cleanup_queues(mon);
4366 json_message_parser_destroy(&mon->qmp.parser);
4367 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4368 mon_refcount--;
4369 monitor_fdsets_cleanup();
4370 break;
4371 }
4372 }
4373
4374 static void monitor_event(void *opaque, int event)
4375 {
4376 Monitor *mon = opaque;
4377
4378 switch (event) {
4379 case CHR_EVENT_MUX_IN:
4380 qemu_mutex_lock(&mon->out_lock);
4381 mon->mux_out = 0;
4382 qemu_mutex_unlock(&mon->out_lock);
4383 if (mon->reset_seen) {
4384 readline_restart(mon->rs);
4385 monitor_resume(mon);
4386 monitor_flush(mon);
4387 } else {
4388 atomic_mb_set(&mon->suspend_cnt, 0);
4389 }
4390 break;
4391
4392 case CHR_EVENT_MUX_OUT:
4393 if (mon->reset_seen) {
4394 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4395 monitor_printf(mon, "\n");
4396 }
4397 monitor_flush(mon);
4398 monitor_suspend(mon);
4399 } else {
4400 atomic_inc(&mon->suspend_cnt);
4401 }
4402 qemu_mutex_lock(&mon->out_lock);
4403 mon->mux_out = 1;
4404 qemu_mutex_unlock(&mon->out_lock);
4405 break;
4406
4407 case CHR_EVENT_OPENED:
4408 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4409 "information\n", QEMU_VERSION);
4410 if (!mon->mux_out) {
4411 readline_restart(mon->rs);
4412 readline_show_prompt(mon->rs);
4413 }
4414 mon->reset_seen = 1;
4415 mon_refcount++;
4416 break;
4417
4418 case CHR_EVENT_CLOSED:
4419 mon_refcount--;
4420 monitor_fdsets_cleanup();
4421 break;
4422 }
4423 }
4424
4425 static int
4426 compare_mon_cmd(const void *a, const void *b)
4427 {
4428 return strcmp(((const mon_cmd_t *)a)->name,
4429 ((const mon_cmd_t *)b)->name);
4430 }
4431
4432 static void sortcmdlist(void)
4433 {
4434 int array_num;
4435 int elem_size = sizeof(mon_cmd_t);
4436
4437 array_num = sizeof(mon_cmds)/elem_size-1;
4438 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4439
4440 array_num = sizeof(info_cmds)/elem_size-1;
4441 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4442 }
4443
4444 static GMainContext *monitor_get_io_context(void)
4445 {
4446 return iothread_get_g_main_context(mon_global.mon_iothread);
4447 }
4448
4449 static AioContext *monitor_get_aio_context(void)
4450 {
4451 return iothread_get_aio_context(mon_global.mon_iothread);
4452 }
4453
4454 static void monitor_iothread_init(void)
4455 {
4456 mon_global.mon_iothread = iothread_create("mon_iothread",
4457 &error_abort);
4458
4459 /*
4460 * This MUST be on main loop thread since we have commands that
4461 * have assumption to be run on main loop thread. It would be
4462 * nice that one day we can remove this assumption in the future.
4463 */
4464 mon_global.qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4465 monitor_qmp_bh_dispatcher,
4466 NULL);
4467
4468 /*
4469 * Unlike the dispatcher BH, this must be run on the monitor IO
4470 * thread, so that monitors that are using IO thread will make
4471 * sure read/write operations are all done on the IO thread.
4472 */
4473 mon_global.qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4474 monitor_qmp_bh_responder,
4475 NULL);
4476 }
4477
4478 void monitor_init_globals(void)
4479 {
4480 monitor_init_qmp_commands();
4481 monitor_qapi_event_init();
4482 sortcmdlist();
4483 qemu_mutex_init(&monitor_lock);
4484 monitor_iothread_init();
4485 }
4486
4487 /* These functions just adapt the readline interface in a typesafe way. We
4488 * could cast function pointers but that discards compiler checks.
4489 */
4490 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4491 const char *fmt, ...)
4492 {
4493 va_list ap;
4494 va_start(ap, fmt);
4495 monitor_vprintf(opaque, fmt, ap);
4496 va_end(ap);
4497 }
4498
4499 static void monitor_readline_flush(void *opaque)
4500 {
4501 monitor_flush(opaque);
4502 }
4503
4504 /*
4505 * Print to current monitor if we have one, else to stderr.
4506 * TODO should return int, so callers can calculate width, but that
4507 * requires surgery to monitor_vprintf(). Left for another day.
4508 */
4509 void error_vprintf(const char *fmt, va_list ap)
4510 {
4511 if (cur_mon && !monitor_cur_is_qmp()) {
4512 monitor_vprintf(cur_mon, fmt, ap);
4513 } else {
4514 vfprintf(stderr, fmt, ap);
4515 }
4516 }
4517
4518 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4519 {
4520 if (cur_mon && !monitor_cur_is_qmp()) {
4521 monitor_vprintf(cur_mon, fmt, ap);
4522 } else if (!cur_mon) {
4523 vfprintf(stderr, fmt, ap);
4524 }
4525 }
4526
4527 static void monitor_list_append(Monitor *mon)
4528 {
4529 qemu_mutex_lock(&monitor_lock);
4530 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4531 qemu_mutex_unlock(&monitor_lock);
4532 }
4533
4534 static void monitor_qmp_setup_handlers_bh(void *opaque)
4535 {
4536 Monitor *mon = opaque;
4537 GMainContext *context;
4538
4539 if (mon->use_io_thr) {
4540 /*
4541 * When use_io_thr is set, we use the global shared dedicated
4542 * IO thread for this monitor to handle input/output.
4543 */
4544 context = monitor_get_io_context();
4545 /* We should have inited globals before reaching here. */
4546 assert(context);
4547 } else {
4548 /* The default main loop, which is the main thread */
4549 context = NULL;
4550 }
4551
4552 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4553 monitor_qmp_event, NULL, mon, context, true);
4554 monitor_list_append(mon);
4555 }
4556
4557 void monitor_init(Chardev *chr, int flags)
4558 {
4559 Monitor *mon = g_malloc(sizeof(*mon));
4560 bool use_readline = flags & MONITOR_USE_READLINE;
4561 bool use_oob = flags & MONITOR_USE_OOB;
4562
4563 if (use_oob) {
4564 if (CHARDEV_IS_MUX(chr)) {
4565 error_report("Monitor Out-Of-Band is not supported with "
4566 "MUX typed chardev backend");
4567 exit(1);
4568 }
4569 if (use_readline) {
4570 error_report("Monitor Out-Of-band is only supported by QMP");
4571 exit(1);
4572 }
4573 }
4574
4575 monitor_data_init(mon, false, use_oob);
4576
4577 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4578 mon->flags = flags;
4579 if (use_readline) {
4580 mon->rs = readline_init(monitor_readline_printf,
4581 monitor_readline_flush,
4582 mon,
4583 monitor_find_completion);
4584 monitor_read_command(mon, 0);
4585 }
4586
4587 if (monitor_is_qmp(mon)) {
4588 qemu_chr_fe_set_echo(&mon->chr, true);
4589 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4590 if (mon->use_io_thr) {
4591 /*
4592 * Make sure the old iowatch is gone. It's possible when
4593 * e.g. the chardev is in client mode, with wait=on.
4594 */
4595 remove_fd_in_watch(chr);
4596 /*
4597 * We can't call qemu_chr_fe_set_handlers() directly here
4598 * since during the procedure the chardev will be active
4599 * and running in monitor iothread, while we'll still do
4600 * something before returning from it, which is a possible
4601 * race too. To avoid that, we just create a BH to setup
4602 * the handlers.
4603 */
4604 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4605 monitor_qmp_setup_handlers_bh, mon);
4606 /* We'll add this to mon_list in the BH when setup done */
4607 return;
4608 } else {
4609 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4610 monitor_qmp_read, monitor_qmp_event,
4611 NULL, mon, NULL, true);
4612 }
4613 } else {
4614 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4615 monitor_event, NULL, mon, NULL, true);
4616 }
4617
4618 monitor_list_append(mon);
4619 }
4620
4621 void monitor_cleanup(void)
4622 {
4623 Monitor *mon, *next;
4624
4625 /*
4626 * We need to explicitly stop the iothread (but not destroy it),
4627 * cleanup the monitor resources, then destroy the iothread since
4628 * we need to unregister from chardev below in
4629 * monitor_data_destroy(), and chardev is not thread-safe yet
4630 */
4631 iothread_stop(mon_global.mon_iothread);
4632
4633 /*
4634 * After we have IOThread to send responses, it's possible that
4635 * when we stop the IOThread there are still replies queued in the
4636 * responder queue. Flush all of them. Note that even after this
4637 * flush it's still possible that out buffer is not flushed.
4638 * It'll be done in below monitor_flush() as the last resort.
4639 */
4640 monitor_qmp_bh_responder(NULL);
4641
4642 qemu_mutex_lock(&monitor_lock);
4643 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4644 QTAILQ_REMOVE(&mon_list, mon, entry);
4645 monitor_flush(mon);
4646 monitor_data_destroy(mon);
4647 g_free(mon);
4648 }
4649 qemu_mutex_unlock(&monitor_lock);
4650
4651 /* QEMUBHs needs to be deleted before destroying the IOThread. */
4652 qemu_bh_delete(mon_global.qmp_dispatcher_bh);
4653 mon_global.qmp_dispatcher_bh = NULL;
4654 qemu_bh_delete(mon_global.qmp_respond_bh);
4655 mon_global.qmp_respond_bh = NULL;
4656
4657 iothread_destroy(mon_global.mon_iothread);
4658 mon_global.mon_iothread = NULL;
4659 }
4660
4661 QemuOptsList qemu_mon_opts = {
4662 .name = "mon",
4663 .implied_opt_name = "chardev",
4664 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4665 .desc = {
4666 {
4667 .name = "mode",
4668 .type = QEMU_OPT_STRING,
4669 },{
4670 .name = "chardev",
4671 .type = QEMU_OPT_STRING,
4672 },{
4673 .name = "pretty",
4674 .type = QEMU_OPT_BOOL,
4675 },{
4676 .name = "x-oob",
4677 .type = QEMU_OPT_BOOL,
4678 },
4679 { /* end of list */ }
4680 },
4681 };
4682
4683 #ifndef TARGET_I386
4684 void qmp_rtc_reset_reinjection(Error **errp)
4685 {
4686 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4687 }
4688
4689 SevInfo *qmp_query_sev(Error **errp)
4690 {
4691 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4692 return NULL;
4693 }
4694
4695 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4696 {
4697 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4698 return NULL;
4699 }
4700
4701 SevCapability *qmp_query_sev_capabilities(Error **errp)
4702 {
4703 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4704 return NULL;
4705 }
4706 #endif
4707
4708 #ifndef TARGET_S390X
4709 void qmp_dump_skeys(const char *filename, Error **errp)
4710 {
4711 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4712 }
4713 #endif
4714
4715 #ifndef TARGET_ARM
4716 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4717 {
4718 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4719 return NULL;
4720 }
4721 #endif
4722
4723 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4724 {
4725 MachineState *ms = MACHINE(qdev_get_machine());
4726 MachineClass *mc = MACHINE_GET_CLASS(ms);
4727
4728 if (!mc->has_hotpluggable_cpus) {
4729 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4730 return NULL;
4731 }
4732
4733 return machine_query_hotpluggable_cpus(ms);
4734 }