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