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