Bug Summary

File:monitor.c
Location:line 1283, column 9
Description:Value stored to 'flags' is never read

Annotated Source Code

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#include <dirent.h>
25#include "hw/hw.h"
26#include "monitor/qdev.h"
27#include "hw/usb.h"
28#include "hw/pcmcia.h"
29#include "hw/i386/pc.h"
30#include "hw/pci/pci.h"
31#include "sysemu/watchdog.h"
32#include "hw/loader.h"
33#include "exec/gdbstub.h"
34#include "net/net.h"
35#include "net/slirp.h"
36#include "sysemu/char.h"
37#include "ui/qemu-spice.h"
38#include "sysemu/sysemu.h"
39#include "monitor/monitor.h"
40#include "monitor/readline.h"
41#include "ui/console.h"
42#include "sysemu/blockdev.h"
43#include "audio/audio.h"
44#include "disas/disas.h"
45#include "sysemu/balloon.h"
46#include "qemu/timer.h"
47#include "migration/migration.h"
48#include "sysemu/kvm.h"
49#include "qemu/acl.h"
50#include "sysemu/tpm.h"
51#include "qapi/qmp/qint.h"
52#include "qapi/qmp/qfloat.h"
53#include "qapi/qmp/qlist.h"
54#include "qapi/qmp/qbool.h"
55#include "qapi/qmp/qstring.h"
56#include "qapi/qmp/qjson.h"
57#include "qapi/qmp/json-streamer.h"
58#include "qapi/qmp/json-parser.h"
59#include "qemu/osdep.h"
60#include "cpu.h"
61#include "trace.h"
62#include "trace/control.h"
63#ifdef CONFIG_TRACE_SIMPLE
64#include "trace/simple.h"
65#endif
66#include "exec/memory.h"
67#include "qmp-commands.h"
68#include "hmp.h"
69#include "qemu/thread.h"
70
71/* for pic/irq_info */
72#if defined(TARGET_SPARC)
73#include "hw/sparc/sun4m.h"
74#endif
75#include "hw/lm32/lm32_pic.h"
76
77//#define DEBUG
78//#define DEBUG_COMPLETION
79
80/*
81 * Supported types:
82 *
83 * 'F' filename
84 * 'B' block device name
85 * 's' string (accept optional quote)
86 * 'S' it just appends the rest of the string (accept optional quote)
87 * 'O' option string of the form NAME=VALUE,...
88 * parsed according to QemuOptsList given by its name
89 * Example: 'device:O' uses qemu_device_opts.
90 * Restriction: only lists with empty desc are supported
91 * TODO lift the restriction
92 * 'i' 32 bit integer
93 * 'l' target long (32 or 64 bit)
94 * 'M' Non-negative target long (32 or 64 bit), in user mode the
95 * value is multiplied by 2^20 (think Mebibyte)
96 * 'o' octets (aka bytes)
97 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
98 * K, k suffix, which multiplies the value by 2^60 for suffixes E
99 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
100 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
101 * 'T' double
102 * user mode accepts an optional ms, us, ns suffix,
103 * which divides the value by 1e3, 1e6, 1e9, respectively
104 * '/' optional gdb-like print format (like "/10x")
105 *
106 * '?' optional type (for all types, except '/')
107 * '.' other form of optional type (for 'i' and 'l')
108 * 'b' boolean
109 * user mode accepts "on" or "off"
110 * '-' optional parameter (eg. '-f')
111 *
112 */
113
114typedef struct MonitorCompletionData MonitorCompletionData;
115struct MonitorCompletionData {
116 Monitor *mon;
117 void (*user_print)(Monitor *mon, const QObject *data);
118};
119
120typedef struct mon_cmd_t {
121 const char *name;
122 const char *args_type;
123 const char *params;
124 const char *help;
125 void (*user_print)(Monitor *mon, const QObject *data);
126 union {
127 void (*cmd)(Monitor *mon, const QDict *qdict);
128 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
129 int (*cmd_async)(Monitor *mon, const QDict *params,
130 MonitorCompletion *cb, void *opaque);
131 } mhandler;
132 int flags;
133 /* @sub_table is a list of 2nd level of commands. If it do not exist,
134 * mhandler should be used. If it exist, sub_table[?].mhandler should be
135 * used, and mhandler of 1st level plays the role of help function.
136 */
137 struct mon_cmd_t *sub_table;
138} mon_cmd_t;
139
140/* file descriptors passed via SCM_RIGHTS */
141typedef struct mon_fd_t mon_fd_t;
142struct mon_fd_t {
143 char *name;
144 int fd;
145 QLIST_ENTRY(mon_fd_t)struct { struct mon_fd_t *le_next; struct mon_fd_t **le_prev;
}
next;
146};
147
148/* file descriptor associated with a file descriptor set */
149typedef struct MonFdsetFd MonFdsetFd;
150struct MonFdsetFd {
151 int fd;
152 bool_Bool removed;
153 char *opaque;
154 QLIST_ENTRY(MonFdsetFd)struct { struct MonFdsetFd *le_next; struct MonFdsetFd **le_prev
; }
next;
155};
156
157/* file descriptor set containing fds passed via SCM_RIGHTS */
158typedef struct MonFdset MonFdset;
159struct MonFdset {
160 int64_t id;
161 QLIST_HEAD(, MonFdsetFd)struct { struct MonFdsetFd *lh_first; } fds;
162 QLIST_HEAD(, MonFdsetFd)struct { struct MonFdsetFd *lh_first; } dup_fds;
163 QLIST_ENTRY(MonFdset)struct { struct MonFdset *le_next; struct MonFdset **le_prev;
}
next;
164};
165
166typedef struct MonitorControl {
167 QObject *id;
168 JSONMessageParser parser;
169 int command_mode;
170} MonitorControl;
171
172/*
173 * To prevent flooding clients, events can be throttled. The
174 * throttling is calculated globally, rather than per-Monitor
175 * instance.
176 */
177typedef struct MonitorEventState {
178 MonitorEvent event; /* Event being tracked */
179 int64_t rate; /* Period over which to throttle. 0 to disable */
180 int64_t last; /* Time at which event was last emitted */
181 QEMUTimer *timer; /* Timer for handling delayed events */
182 QObject *data; /* Event pending delayed dispatch */
183} MonitorEventState;
184
185struct Monitor {
186 CharDriverState *chr;
187 int mux_out;
188 int reset_seen;
189 int flags;
190 int suspend_cnt;
191 bool_Bool skip_flush;
192 QString *outbuf;
193 guint watch;
194 ReadLineState *rs;
195 MonitorControl *mc;
196 CPUState *mon_cpu;
197 BlockDriverCompletionFunc *password_completion_cb;
198 void *password_opaque;
199 mon_cmd_t *cmd_table;
200 QError *error;
201 QLIST_HEAD(,mon_fd_t)struct { struct mon_fd_t *lh_first; } fds;
202 QLIST_ENTRY(Monitor)struct { struct Monitor *le_next; struct Monitor **le_prev; } entry;
203};
204
205/* QMP checker flags */
206#define QMP_ACCEPT_UNKNOWNS1 1
207
208static QLIST_HEAD(mon_list, Monitor)struct mon_list { struct Monitor *lh_first; } mon_list;
209static QLIST_HEAD(mon_fdsets, MonFdset)struct mon_fdsets { struct MonFdset *lh_first; } mon_fdsets;
210static int mon_refcount;
211
212static mon_cmd_t mon_cmds[];
213static mon_cmd_t info_cmds[];
214
215static const mon_cmd_t qmp_cmds[];
216
217Monitor *cur_mon;
218Monitor *default_mon;
219
220static void monitor_command_cb(Monitor *mon, const char *cmdline,
221 void *opaque);
222
223static inline int qmp_cmd_mode(const Monitor *mon)
224{
225 return (mon->mc ? mon->mc->command_mode : 0);
226}
227
228/* Return true if in control mode, false otherwise */
229static inline int monitor_ctrl_mode(const Monitor *mon)
230{
231 return (mon->flags & MONITOR_USE_CONTROL0x04);
232}
233
234/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
235int monitor_cur_is_qmp(void)
236{
237 return cur_mon && monitor_ctrl_mode(cur_mon);
238}
239
240void monitor_read_command(Monitor *mon, int show_prompt)
241{
242 if (!mon->rs)
243 return;
244
245 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL((void*)0));
246 if (show_prompt)
247 readline_show_prompt(mon->rs);
248}
249
250int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
251 void *opaque)
252{
253 if (monitor_ctrl_mode(mon)) {
254 qerror_report(QERR_MISSING_PARAMETERERROR_CLASS_GENERIC_ERROR, "Parameter '%s' is missing", "password");
255 return -EINVAL22;
256 } else if (mon->rs) {
257 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
258 /* prompt is printed on return from the command handler */
259 return 0;
260 } else {
261 monitor_printf(mon, "terminal does not support password prompting\n");
262 return -ENOTTY25;
263 }
264}
265
266static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
267 void *opaque)
268{
269 Monitor *mon = opaque;
270
271 mon->watch = 0;
272 monitor_flush(mon);
273 return FALSE0;
274}
275
276void monitor_flush(Monitor *mon)
277{
278 int rc;
279 size_t len;
280 const char *buf;
281
282 if (mon->skip_flush) {
283 return;
284 }
285
286 buf = qstring_get_str(mon->outbuf);
287 len = qstring_get_length(mon->outbuf);
288
289 if (len && !mon->mux_out) {
290 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
291 if (rc == len) {
292 /* all flushed */
293 QDECREF(mon->outbuf)qobject_decref(mon->outbuf ? (&(mon->outbuf)->base
) : ((void*)0))
;
294 mon->outbuf = qstring_new();
295 return;
296 }
297 if (rc > 0) {
298 /* partinal write */
299 QString *tmp = qstring_from_str(buf + rc);
300 QDECREF(mon->outbuf)qobject_decref(mon->outbuf ? (&(mon->outbuf)->base
) : ((void*)0))
;
301 mon->outbuf = tmp;
302 }
303 if (mon->watch == 0) {
304 mon->watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT,
305 monitor_unblocked, mon);
306 }
307 }
308}
309
310/* flush at every end of line */
311static void monitor_puts(Monitor *mon, const char *str)
312{
313 char c;
314
315 for(;;) {
316 c = *str++;
317 if (c == '\0')
318 break;
319 if (c == '\n') {
320 qstring_append_chr(mon->outbuf, '\r');
321 }
322 qstring_append_chr(mon->outbuf, c);
323 if (c == '\n') {
324 monitor_flush(mon);
325 }
326 }
327}
328
329void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
330{
331 char *buf;
332
333 if (!mon)
334 return;
335
336 if (monitor_ctrl_mode(mon)) {
337 return;
338 }
339
340 buf = g_strdup_vprintf(fmt, ap);
341 monitor_puts(mon, buf);
342 g_free(buf);
343}
344
345void monitor_printf(Monitor *mon, const char *fmt, ...)
346{
347 va_list ap;
348 va_start(ap, fmt)__builtin_va_start(ap, fmt);
349 monitor_vprintf(mon, fmt, ap);
350 va_end(ap)__builtin_va_end(ap);
351}
352
353void monitor_print_filename(Monitor *mon, const char *filename)
354{
355 int i;
356
357 for (i = 0; filename[i]; i++) {
358 switch (filename[i]) {
359 case ' ':
360 case '"':
361 case '\\':
362 monitor_printf(mon, "\\%c", filename[i]);
363 break;
364 case '\t':
365 monitor_printf(mon, "\\t");
366 break;
367 case '\r':
368 monitor_printf(mon, "\\r");
369 break;
370 case '\n':
371 monitor_printf(mon, "\\n");
372 break;
373 default:
374 monitor_printf(mon, "%c", filename[i]);
375 break;
376 }
377 }
378}
379
380static int GCC_FMT_ATTR(2, 3)__attribute__((format(printf, 2, 3))) monitor_fprintf(FILE *stream,
381 const char *fmt, ...)
382{
383 va_list ap;
384 va_start(ap, fmt)__builtin_va_start(ap, fmt);
385 monitor_vprintf((Monitor *)stream, fmt, ap);
386 va_end(ap)__builtin_va_end(ap);
387 return 0;
388}
389
390static void monitor_user_noop(Monitor *mon, const QObject *data) { }
391
392static inline int handler_is_qobject(const mon_cmd_t *cmd)
393{
394 return cmd->user_print != NULL((void*)0);
395}
396
397static inline bool_Bool handler_is_async(const mon_cmd_t *cmd)
398{
399 return cmd->flags & MONITOR_CMD_ASYNC0x0001;
400}
401
402static inline int monitor_has_error(const Monitor *mon)
403{
404 return mon->error != NULL((void*)0);
405}
406
407static void monitor_json_emitter(Monitor *mon, const QObject *data)
408{
409 QString *json;
410
411 json = mon->flags & MONITOR_USE_PRETTY0x08 ? qobject_to_json_pretty(data) :
412 qobject_to_json(data);
413 assert(json != NULL)((json != ((void*)0)) ? (void) (0) : __assert_fail ("json != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 413, __PRETTY_FUNCTION__
))
;
414
415 qstring_append_chr(json, '\n');
416 monitor_puts(mon, qstring_get_str(json));
417
418 QDECREF(json)qobject_decref(json ? (&(json)->base) : ((void*)0));
419}
420
421static QDict *build_qmp_error_dict(const QError *err)
422{
423 QObject *obj;
424
425 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
426 ErrorClass_lookup[err->err_class],
427 qerror_human(err));
428
429 return qobject_to_qdict(obj);
430}
431
432static void monitor_protocol_emitter(Monitor *mon, QObject *data)
433{
434 QDict *qmp;
435
436 trace_monitor_protocol_emitter(mon);
437
438 if (!monitor_has_error(mon)) {
439 /* success response */
440 qmp = qdict_new();
441 if (data) {
442 qobject_incref(data);
443 qdict_put_obj(qmp, "return", data);
444 } else {
445 /* return an empty QDict by default */
446 qdict_put(qmp, "return", qdict_new())qdict_put_obj(qmp, "return", (&(qdict_new())->base));
447 }
448 } else {
449 /* error response */
450 qmp = build_qmp_error_dict(mon->error);
451 QDECREF(mon->error)qobject_decref(mon->error ? (&(mon->error)->base
) : ((void*)0))
;
452 mon->error = NULL((void*)0);
453 }
454
455 if (mon->mc->id) {
456 qdict_put_obj(qmp, "id", mon->mc->id);
457 mon->mc->id = NULL((void*)0);
458 }
459
460 monitor_json_emitter(mon, QOBJECT(qmp)(&(qmp)->base));
461 QDECREF(qmp)qobject_decref(qmp ? (&(qmp)->base) : ((void*)0));
462}
463
464static void timestamp_put(QDict *qdict)
465{
466 int err;
467 QObject *obj;
468 qemu_timeval tv;
469
470 err = qemu_gettimeofday(&tv)gettimeofday(&tv, ((void*)0));
471 if (err < 0)
472 return;
473
474 obj = qobject_from_jsonf("{ 'seconds': %" PRId64"l" "d" ", "
475 "'microseconds': %" PRId64"l" "d" " }",
476 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
477 qdict_put_obj(qdict, "timestamp", obj);
478}
479
480
481static const char *monitor_event_names[] = {
482 [QEVENT_SHUTDOWN] = "SHUTDOWN",
483 [QEVENT_RESET] = "RESET",
484 [QEVENT_POWERDOWN] = "POWERDOWN",
485 [QEVENT_STOP] = "STOP",
486 [QEVENT_RESUME] = "RESUME",
487 [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
488 [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
489 [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
490 [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
491 [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
492 [QEVENT_WATCHDOG] = "WATCHDOG",
493 [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
494 [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
495 [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
496 [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
497 [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
498 [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",
499 [QEVENT_BLOCK_JOB_READY] = "BLOCK_JOB_READY",
500 [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",
501 [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
502 [QEVENT_NIC_RX_FILTER_CHANGED] = "NIC_RX_FILTER_CHANGED",
503 [QEVENT_SUSPEND] = "SUSPEND",
504 [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
505 [QEVENT_WAKEUP] = "WAKEUP",
506 [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
507 [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
508 [QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",
509 [QEVENT_BLOCK_IMAGE_CORRUPTED] = "BLOCK_IMAGE_CORRUPTED",
510};
511QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)typedef char qemu_build_bug_on__511[((sizeof(monitor_event_names
) / sizeof((monitor_event_names)[0])) != QEVENT_MAX)?-1:1] __attribute__
((unused));
512
513MonitorEventState monitor_event_state[QEVENT_MAX];
514
515/*
516 * Emits the event to every monitor instance
517 */
518static void
519monitor_protocol_event_emit(MonitorEvent event,
520 QObject *data)
521{
522 Monitor *mon;
523
524 trace_monitor_protocol_event_emit(event, data);
525 QLIST_FOREACH(mon, &mon_list, entry)for ((mon) = ((&mon_list)->lh_first); (mon); (mon) = (
(mon)->entry.le_next))
{
526 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
527 monitor_json_emitter(mon, data);
528 }
529 }
530}
531
532
533/*
534 * Queue a new event for emission to Monitor instances,
535 * applying any rate limiting if required.
536 */
537static void
538monitor_protocol_event_queue(MonitorEvent event,
539 QObject *data)
540{
541 MonitorEventState *evstate;
542 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
543 assert(event < QEVENT_MAX)((event < QEVENT_MAX) ? (void) (0) : __assert_fail ("event < QEVENT_MAX"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 543, __PRETTY_FUNCTION__
))
;
544
545 evstate = &(monitor_event_state[event]);
546 trace_monitor_protocol_event_queue(event,
547 data,
548 evstate->rate,
549 evstate->last,
550 now);
551
552 /* Rate limit of 0 indicates no throttling */
553 if (!evstate->rate) {
554 monitor_protocol_event_emit(event, data);
555 evstate->last = now;
556 } else {
557 int64_t delta = now - evstate->last;
558 if (evstate->data ||
559 delta < evstate->rate) {
560 /* If there's an existing event pending, replace
561 * it with the new event, otherwise schedule a
562 * timer for delayed emission
563 */
564 if (evstate->data) {
565 qobject_decref(evstate->data);
566 } else {
567 int64_t then = evstate->last + evstate->rate;
568 timer_mod_ns(evstate->timer, then);
569 }
570 evstate->data = data;
571 qobject_incref(evstate->data);
572 } else {
573 monitor_protocol_event_emit(event, data);
574 evstate->last = now;
575 }
576 }
577}
578
579
580/*
581 * The callback invoked by QemuTimer when a delayed
582 * event is ready to be emitted
583 */
584static void monitor_protocol_event_handler(void *opaque)
585{
586 MonitorEventState *evstate = opaque;
587 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
588
589
590 trace_monitor_protocol_event_handler(evstate->event,
591 evstate->data,
592 evstate->last,
593 now);
594 if (evstate->data) {
595 monitor_protocol_event_emit(evstate->event, evstate->data);
596 qobject_decref(evstate->data);
597 evstate->data = NULL((void*)0);
598 }
599 evstate->last = now;
600}
601
602
603/*
604 * @event: the event ID to be limited
605 * @rate: the rate limit in milliseconds
606 *
607 * Sets a rate limit on a particular event, so no
608 * more than 1 event will be emitted within @rate
609 * milliseconds
610 */
611static void
612monitor_protocol_event_throttle(MonitorEvent event,
613 int64_t rate)
614{
615 MonitorEventState *evstate;
616 assert(event < QEVENT_MAX)((event < QEVENT_MAX) ? (void) (0) : __assert_fail ("event < QEVENT_MAX"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 616, __PRETTY_FUNCTION__
))
;
617
618 evstate = &(monitor_event_state[event]);
619
620 trace_monitor_protocol_event_throttle(event, rate);
621 evstate->event = event;
622 evstate->rate = rate * SCALE_MS1000000;
623 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
624 SCALE_MS1000000,
625 monitor_protocol_event_handler,
626 evstate);
627 evstate->last = 0;
628 evstate->data = NULL((void*)0);
629}
630
631
632/* Global, one-time initializer to configure the rate limiting
633 * and initialize state */
634static void monitor_protocol_event_init(void)
635{
636 /* Limit RTC & BALLOON events to 1 per second */
637 monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
638 monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
639 monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
640}
641
642/**
643 * monitor_protocol_event(): Generate a Monitor event
644 *
645 * Event-specific data can be emitted through the (optional) 'data' parameter.
646 */
647void monitor_protocol_event(MonitorEvent event, QObject *data)
648{
649 QDict *qmp;
650 const char *event_name;
651
652 assert(event < QEVENT_MAX)((event < QEVENT_MAX) ? (void) (0) : __assert_fail ("event < QEVENT_MAX"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 652, __PRETTY_FUNCTION__
))
;
653
654 event_name = monitor_event_names[event];
655 assert(event_name != NULL)((event_name != ((void*)0)) ? (void) (0) : __assert_fail ("event_name != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 655, __PRETTY_FUNCTION__
))
;
656
657 qmp = qdict_new();
658 timestamp_put(qmp);
659 qdict_put(qmp, "event", qstring_from_str(event_name))qdict_put_obj(qmp, "event", (&(qstring_from_str(event_name
))->base))
;
660 if (data) {
661 qobject_incref(data);
662 qdict_put_obj(qmp, "data", data);
663 }
664
665 trace_monitor_protocol_event(event, event_name, qmp);
666 monitor_protocol_event_queue(event, QOBJECT(qmp)(&(qmp)->base));
667 QDECREF(qmp)qobject_decref(qmp ? (&(qmp)->base) : ((void*)0));
668}
669
670static int do_qmp_capabilities(Monitor *mon, const QDict *params,
671 QObject **ret_data)
672{
673 /* Will setup QMP capabilities in the future */
674 if (monitor_ctrl_mode(mon)) {
675 mon->mc->command_mode = 1;
676 }
677
678 return 0;
679}
680
681static void handle_user_command(Monitor *mon, const char *cmdline);
682
683static void monitor_data_init(Monitor *mon)
684{
685 memset(mon, 0, sizeof(Monitor));
686 mon->outbuf = qstring_new();
687 /* Use *mon_cmds by default. */
688 mon->cmd_table = mon_cmds;
689}
690
691static void monitor_data_destroy(Monitor *mon)
692{
693 QDECREF(mon->outbuf)qobject_decref(mon->outbuf ? (&(mon->outbuf)->base
) : ((void*)0))
;
694}
695
696char *qmp_human_monitor_command(const char *command_line, bool_Bool has_cpu_index,
697 int64_t cpu_index, Error **errp)
698{
699 char *output = NULL((void*)0);
700 Monitor *old_mon, hmp;
701
702 monitor_data_init(&hmp);
703 hmp.skip_flush = true1;
704
705 old_mon = cur_mon;
706 cur_mon = &hmp;
707
708 if (has_cpu_index) {
709 int ret = monitor_set_cpu(cpu_index);
710 if (ret < 0) {
711 cur_mon = old_mon;
712 error_set(errp, QERR_INVALID_PARAMETER_VALUEERROR_CLASS_GENERIC_ERROR, "Parameter '%s' expects %s", "cpu-index",
713 "a CPU number");
714 goto out;
715 }
716 }
717
718 handle_user_command(&hmp, command_line);
719 cur_mon = old_mon;
720
721 if (qstring_get_length(hmp.outbuf) > 0) {
722 output = g_strdup(qstring_get_str(hmp.outbuf));
723 } else {
724 output = g_strdup("");
725 }
726
727out:
728 monitor_data_destroy(&hmp);
729 return output;
730}
731
732static int compare_cmd(const char *name, const char *list)
733{
734 const char *p, *pstart;
735 int len;
736 len = strlen(name);
737 p = list;
738 for(;;) {
739 pstart = p;
740 p = strchr(p, '|');
741 if (!p)
742 p = pstart + strlen(pstart);
743 if ((p - pstart) == len && !memcmp(pstart, name, len))
744 return 1;
745 if (*p == '\0')
746 break;
747 p++;
748 }
749 return 0;
750}
751
752static int get_str(char *buf, int buf_size, const char **pp)
753{
754 const char *p;
755 char *q;
756 int c;
757
758 q = buf;
759 p = *pp;
760 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
761 p++;
762 }
763 if (*p == '\0') {
764 fail:
765 *q = '\0';
766 *pp = p;
767 return -1;
768 }
769 if (*p == '\"') {
770 p++;
771 while (*p != '\0' && *p != '\"') {
772 if (*p == '\\') {
773 p++;
774 c = *p++;
775 switch (c) {
776 case 'n':
777 c = '\n';
778 break;
779 case 'r':
780 c = '\r';
781 break;
782 case '\\':
783 case '\'':
784 case '\"':
785 break;
786 default:
787 qemu_printfprintf("unsupported escape code: '\\%c'\n", c);
788 goto fail;
789 }
790 if ((q - buf) < buf_size - 1) {
791 *q++ = c;
792 }
793 } else {
794 if ((q - buf) < buf_size - 1) {
795 *q++ = *p;
796 }
797 p++;
798 }
799 }
800 if (*p != '\"') {
801 qemu_printfprintf("unterminated string\n");
802 goto fail;
803 }
804 p++;
805 } else {
806 while (*p != '\0' && !qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
807 if ((q - buf) < buf_size - 1) {
808 *q++ = *p;
809 }
810 p++;
811 }
812 }
813 *q = '\0';
814 *pp = p;
815 return 0;
816}
817
818#define MAX_ARGS16 16
819
820static void free_cmdline_args(char **args, int nb_args)
821{
822 int i;
823
824 assert(nb_args <= MAX_ARGS)((nb_args <= 16) ? (void) (0) : __assert_fail ("nb_args <= 16"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 824, __PRETTY_FUNCTION__
))
;
825
826 for (i = 0; i < nb_args; i++) {
827 g_free(args[i]);
828 }
829
830}
831
832/*
833 * Parse the command line to get valid args.
834 * @cmdline: command line to be parsed.
835 * @pnb_args: location to store the number of args, must NOT be NULL.
836 * @args: location to store the args, which should be freed by caller, must
837 * NOT be NULL.
838 *
839 * Returns 0 on success, negative on failure.
840 *
841 * NOTE: this parser is an approximate form of the real command parser. Number
842 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
843 * return with failure.
844 */
845static int parse_cmdline(const char *cmdline,
846 int *pnb_args, char **args)
847{
848 const char *p;
849 int nb_args, ret;
850 char buf[1024];
851
852 p = cmdline;
853 nb_args = 0;
854 for (;;) {
855 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
856 p++;
857 }
858 if (*p == '\0') {
859 break;
860 }
861 if (nb_args >= MAX_ARGS16) {
862 goto fail;
863 }
864 ret = get_str(buf, sizeof(buf), &p);
865 if (ret < 0) {
866 goto fail;
867 }
868 args[nb_args] = g_strdup(buf);
869 nb_args++;
870 }
871 *pnb_args = nb_args;
872 return 0;
873
874 fail:
875 free_cmdline_args(args, nb_args);
876 return -1;
877}
878
879static void help_cmd_dump_one(Monitor *mon,
880 const mon_cmd_t *cmd,
881 char **prefix_args,
882 int prefix_args_nb)
883{
884 int i;
885
886 for (i = 0; i < prefix_args_nb; i++) {
887 monitor_printf(mon, "%s ", prefix_args[i]);
888 }
889 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
890}
891
892/* @args[@arg_index] is the valid command need to find in @cmds */
893static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
894 char **args, int nb_args, int arg_index)
895{
896 const mon_cmd_t *cmd;
897
898 /* No valid arg need to compare with, dump all in *cmds */
899 if (arg_index >= nb_args) {
900 for (cmd = cmds; cmd->name != NULL((void*)0); cmd++) {
901 help_cmd_dump_one(mon, cmd, args, arg_index);
902 }
903 return;
904 }
905
906 /* Find one entry to dump */
907 for (cmd = cmds; cmd->name != NULL((void*)0); cmd++) {
908 if (compare_cmd(args[arg_index], cmd->name)) {
909 if (cmd->sub_table) {
910 /* continue with next arg */
911 help_cmd_dump(mon, cmd->sub_table,
912 args, nb_args, arg_index + 1);
913 } else {
914 help_cmd_dump_one(mon, cmd, args, arg_index);
915 }
916 break;
917 }
918 }
919}
920
921static void help_cmd(Monitor *mon, const char *name)
922{
923 char *args[MAX_ARGS16];
924 int nb_args = 0;
925
926 /* 1. parse user input */
927 if (name) {
928 /* special case for log, directly dump and return */
929 if (!strcmp(name, "log")) {
930 const QEMULogItem *item;
931 monitor_printf(mon, "Log items (comma separated):\n");
932 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
933 for (item = qemu_log_items; item->mask != 0; item++) {
934 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
935 }
936 return;
937 }
938
939 if (parse_cmdline(name, &nb_args, args) < 0) {
940 return;
941 }
942 }
943
944 /* 2. dump the contents according to parsed args */
945 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
946
947 free_cmdline_args(args, nb_args);
948}
949
950static void do_help_cmd(Monitor *mon, const QDict *qdict)
951{
952 help_cmd(mon, qdict_get_try_str(qdict, "name"));
953}
954
955static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
956{
957 const char *tp_name = qdict_get_str(qdict, "name");
958 bool_Bool new_state = qdict_get_bool(qdict, "option");
959
960 bool_Bool found = false0;
961 TraceEvent *ev = NULL((void*)0);
962 while ((ev = trace_event_pattern(tp_name, ev)) != NULL((void*)0)) {
963 found = true1;
964 if (!trace_event_get_state_static(ev)) {
965 monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);
966 } else {
967 trace_event_set_state_dynamic(ev, new_state);
968 }
969 }
970 if (!trace_event_is_pattern(tp_name) && !found) {
971 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
972 }
973}
974
975#ifdef CONFIG_TRACE_SIMPLE
976static void do_trace_file(Monitor *mon, const QDict *qdict)
977{
978 const char *op = qdict_get_try_str(qdict, "op");
979 const char *arg = qdict_get_try_str(qdict, "arg");
980
981 if (!op) {
982 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
983 } else if (!strcmp(op, "on")) {
984 st_set_trace_file_enabled(true1);
985 } else if (!strcmp(op, "off")) {
986 st_set_trace_file_enabled(false0);
987 } else if (!strcmp(op, "flush")) {
988 st_flush_trace_buffer();
989 } else if (!strcmp(op, "set")) {
990 if (arg) {
991 st_set_trace_file(arg);
992 }
993 } else {
994 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
995 help_cmd(mon, "trace-file");
996 }
997}
998#endif
999
1000static void user_monitor_complete(void *opaque, QObject *ret_data)
1001{
1002 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
1003
1004 if (ret_data) {
1005 data->user_print(data->mon, ret_data);
1006 }
1007 monitor_resume(data->mon);
1008 g_free(data);
1009}
1010
1011static void qmp_monitor_complete(void *opaque, QObject *ret_data)
1012{
1013 monitor_protocol_emitter(opaque, ret_data);
1014}
1015
1016static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1017 const QDict *params)
1018{
1019 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
1020}
1021
1022static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1023 const QDict *params)
1024{
1025 int ret;
1026
1027 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
1028 cb_data->mon = mon;
1029 cb_data->user_print = cmd->user_print;
1030 monitor_suspend(mon);
1031 ret = cmd->mhandler.cmd_async(mon, params,
1032 user_monitor_complete, cb_data);
1033 if (ret < 0) {
1034 monitor_resume(mon);
1035 g_free(cb_data);
1036 }
1037}
1038
1039static void do_info_help(Monitor *mon, const QDict *qdict)
1040{
1041 help_cmd(mon, "info");
1042}
1043
1044CommandInfoList *qmp_query_commands(Error **errp)
1045{
1046 CommandInfoList *info, *cmd_list = NULL((void*)0);
1047 const mon_cmd_t *cmd;
1048
1049 for (cmd = qmp_cmds; cmd->name != NULL((void*)0); cmd++) {
1050 info = g_malloc0(sizeof(*info));
1051 info->value = g_malloc0(sizeof(*info->value));
1052 info->value->name = g_strdup(cmd->name);
1053
1054 info->next = cmd_list;
1055 cmd_list = info;
1056 }
1057
1058 return cmd_list;
1059}
1060
1061EventInfoList *qmp_query_events(Error **errp)
1062{
1063 EventInfoList *info, *ev_list = NULL((void*)0);
1064 MonitorEvent e;
1065
1066 for (e = 0 ; e < QEVENT_MAX ; e++) {
1067 const char *event_name = monitor_event_names[e];
1068 assert(event_name != NULL)((event_name != ((void*)0)) ? (void) (0) : __assert_fail ("event_name != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 1068, __PRETTY_FUNCTION__
))
;
1069 info = g_malloc0(sizeof(*info));
1070 info->value = g_malloc0(sizeof(*info->value));
1071 info->value->name = g_strdup(event_name);
1072
1073 info->next = ev_list;
1074 ev_list = info;
1075 }
1076
1077 return ev_list;
1078}
1079
1080/* set the current CPU defined by the user */
1081int monitor_set_cpu(int cpu_index)
1082{
1083 CPUState *cpu;
1084
1085 cpu = qemu_get_cpu(cpu_index);
1086 if (cpu == NULL((void*)0)) {
1087 return -1;
1088 }
1089 cur_mon->mon_cpu = cpu;
1090 return 0;
1091}
1092
1093static CPUArchStatestruct CPUX86State *mon_get_cpu(void)
1094{
1095 if (!cur_mon->mon_cpu) {
1096 monitor_set_cpu(0);
1097 }
1098 cpu_synchronize_state(cur_mon->mon_cpu);
1099 return cur_mon->mon_cpu->env_ptr;
1100}
1101
1102int monitor_get_cpu_index(void)
1103{
1104 CPUState *cpu = ENV_GET_CPU(mon_get_cpu())((CPUState *)object_dynamic_cast_assert(((Object *)((x86_env_get_cpu
(mon_get_cpu())))), ("cpu"), "/home/stefan/src/qemu/qemu.org/qemu/monitor.c"
, 1104, __func__))
;
1105 return cpu->cpu_index;
1106}
1107
1108static void do_info_registers(Monitor *mon, const QDict *qdict)
1109{
1110 CPUState *cpu;
1111 CPUArchStatestruct CPUX86State *env;
1112 env = mon_get_cpu();
1113 cpu = ENV_GET_CPU(env)((CPUState *)object_dynamic_cast_assert(((Object *)((x86_env_get_cpu
(env)))), ("cpu"), "/home/stefan/src/qemu/qemu.org/qemu/monitor.c"
, 1113, __func__))
;
1114 cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1115}
1116
1117static void do_info_jit(Monitor *mon, const QDict *qdict)
1118{
1119 dump_exec_info((FILE *)mon, monitor_fprintf);
1120}
1121
1122static void do_info_history(Monitor *mon, const QDict *qdict)
1123{
1124 int i;
1125 const char *str;
1126
1127 if (!mon->rs)
1128 return;
1129 i = 0;
1130 for(;;) {
1131 str = readline_get_history(mon->rs, i);
1132 if (!str)
1133 break;
1134 monitor_printf(mon, "%d: '%s'\n", i, str);
1135 i++;
1136 }
1137}
1138
1139static void do_info_cpu_stats(Monitor *mon, const QDict *qdict)
1140{
1141 CPUState *cpu;
1142 CPUArchStatestruct CPUX86State *env;
1143
1144 env = mon_get_cpu();
1145 cpu = ENV_GET_CPU(env)((CPUState *)object_dynamic_cast_assert(((Object *)((x86_env_get_cpu
(env)))), ("cpu"), "/home/stefan/src/qemu/qemu.org/qemu/monitor.c"
, 1145, __func__))
;
1146 cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
1147}
1148
1149static void do_trace_print_events(Monitor *mon, const QDict *qdict)
1150{
1151 trace_print_events((FILE *)mon, &monitor_fprintf);
1152}
1153
1154static int client_migrate_info(Monitor *mon, const QDict *qdict,
1155 MonitorCompletion cb, void *opaque)
1156{
1157 const char *protocol = qdict_get_str(qdict, "protocol");
1158 const char *hostname = qdict_get_str(qdict, "hostname");
1159 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1160 int port = qdict_get_try_int(qdict, "port", -1);
1161 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1162 int ret;
1163
1164 if (strcmp(protocol, "spice") == 0) {
1165 if (!using_spice) {
1166 qerror_report(QERR_DEVICE_NOT_ACTIVEERROR_CLASS_DEVICE_NOT_ACTIVE, "Device '%s' has not been activated", "spice");
1167 return -1;
1168 }
1169
1170 if (port == -1 && tls_port == -1) {
1171 qerror_report(QERR_MISSING_PARAMETERERROR_CLASS_GENERIC_ERROR, "Parameter '%s' is missing", "port/tls-port");
1172 return -1;
1173 }
1174
1175 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1176 cb, opaque);
1177 if (ret != 0) {
1178 qerror_report(QERR_UNDEFINED_ERRORERROR_CLASS_GENERIC_ERROR, "An undefined error has occurred");
1179 return -1;
1180 }
1181 return 0;
1182 }
1183
1184 qerror_report(QERR_INVALID_PARAMETERERROR_CLASS_GENERIC_ERROR, "Invalid parameter '%s'", "protocol");
1185 return -1;
1186}
1187
1188static void do_logfile(Monitor *mon, const QDict *qdict)
1189{
1190 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1191}
1192
1193static void do_log(Monitor *mon, const QDict *qdict)
1194{
1195 int mask;
1196 const char *items = qdict_get_str(qdict, "items");
1197
1198 if (!strcmp(items, "none")) {
1199 mask = 0;
1200 } else {
1201 mask = qemu_str_to_log_mask(items);
1202 if (!mask) {
1203 help_cmd(mon, "log");
1204 return;
1205 }
1206 }
1207 qemu_set_log(mask);
1208}
1209
1210static void do_singlestep(Monitor *mon, const QDict *qdict)
1211{
1212 const char *option = qdict_get_try_str(qdict, "option");
1213 if (!option || !strcmp(option, "on")) {
1214 singlestep = 1;
1215 } else if (!strcmp(option, "off")) {
1216 singlestep = 0;
1217 } else {
1218 monitor_printf(mon, "unexpected option %s\n", option);
1219 }
1220}
1221
1222static void do_gdbserver(Monitor *mon, const QDict *qdict)
1223{
1224 const char *device = qdict_get_try_str(qdict, "device");
1225 if (!device)
1226 device = "tcp::" DEFAULT_GDBSTUB_PORT"1234";
1227 if (gdbserver_start(device) < 0) {
1228 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1229 device);
1230 } else if (strcmp(device, "none") == 0) {
1231 monitor_printf(mon, "Disabled gdbserver\n");
1232 } else {
1233 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1234 device);
1235 }
1236}
1237
1238static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1239{
1240 const char *action = qdict_get_str(qdict, "action");
1241 if (select_watchdog_action(action) == -1) {
1242 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1243 }
1244}
1245
1246static void monitor_printc(Monitor *mon, int c)
1247{
1248 monitor_printf(mon, "'");
1249 switch(c) {
1250 case '\'':
1251 monitor_printf(mon, "\\'");
1252 break;
1253 case '\\':
1254 monitor_printf(mon, "\\\\");
1255 break;
1256 case '\n':
1257 monitor_printf(mon, "\\n");
1258 break;
1259 case '\r':
1260 monitor_printf(mon, "\\r");
1261 break;
1262 default:
1263 if (c >= 32 && c <= 126) {
1264 monitor_printf(mon, "%c", c);
1265 } else {
1266 monitor_printf(mon, "\\x%02x", c);
1267 }
1268 break;
1269 }
1270 monitor_printf(mon, "'");
1271}
1272
1273static void memory_dump(Monitor *mon, int count, int format, int wsize,
1274 hwaddr addr, int is_physical)
1275{
1276 CPUArchStatestruct CPUX86State *env;
1277 int l, line_size, i, max_digits, len;
1278 uint8_t buf[16];
1279 uint64_t v;
1280
1281 if (format == 'i') {
1282 int flags;
1283 flags = 0;
Value stored to 'flags' is never read
1284 env = mon_get_cpu();
1285#ifdef TARGET_I3861
1286 if (wsize == 2) {
1287 flags = 1;
1288 } else if (wsize == 4) {
1289 flags = 0;
1290 } else {
1291 /* as default we use the current CS size */
1292 flags = 0;
1293 if (env) {
1294#ifdef TARGET_X86_641
1295 if ((env->efer & MSR_EFER_LMA(1 << 10)) &&
1296 (env->segs[R_CS1].flags & DESC_L_MASK(1 << 21)))
1297 flags = 2;
1298 else
1299#endif
1300 if (!(env->segs[R_CS1].flags & DESC_B_MASK(1 << 22)))
1301 flags = 1;
1302 }
1303 }
1304#endif
1305 monitor_disas(mon, env, addr, count, is_physical, flags);
1306 return;
1307 }
1308
1309 len = wsize * count;
1310 if (wsize == 1)
1311 line_size = 8;
1312 else
1313 line_size = 16;
1314 max_digits = 0;
1315
1316 switch(format) {
1317 case 'o':
1318 max_digits = (wsize * 8 + 2) / 3;
1319 break;
1320 default:
1321 case 'x':
1322 max_digits = (wsize * 8) / 4;
1323 break;
1324 case 'u':
1325 case 'd':
1326 max_digits = (wsize * 8 * 10 + 32) / 33;
1327 break;
1328 case 'c':
1329 wsize = 1;
1330 break;
1331 }
1332
1333 while (len > 0) {
1334 if (is_physical)
1335 monitor_printf(mon, TARGET_FMT_plx"%016" "l" "x" ":", addr);
1336 else
1337 monitor_printf(mon, TARGET_FMT_lx"%016" "l" "x" ":", (target_ulong)addr);
1338 l = len;
1339 if (l > line_size)
1340 l = line_size;
1341 if (is_physical) {
1342 cpu_physical_memory_read(addr, buf, l);
1343 } else {
1344 env = mon_get_cpu();
1345 if (cpu_memory_rw_debug(ENV_GET_CPU(env)((CPUState *)object_dynamic_cast_assert(((Object *)((x86_env_get_cpu
(env)))), ("cpu"), "/home/stefan/src/qemu/qemu.org/qemu/monitor.c"
, 1345, __func__))
, addr, buf, l, 0) < 0) {
1346 monitor_printf(mon, " Cannot access memory\n");
1347 break;
1348 }
1349 }
1350 i = 0;
1351 while (i < l) {
1352 switch(wsize) {
1353 default:
1354 case 1:
1355 v = ldub_raw(buf + i)ldub_p((uint8_t *)(intptr_t)((buf + i)));
1356 break;
1357 case 2:
1358 v = lduw_raw(buf + i)lduw_le_p((uint8_t *)(intptr_t)((buf + i)));
1359 break;
1360 case 4:
1361 v = (uint32_t)ldl_raw(buf + i)ldl_le_p((uint8_t *)(intptr_t)((buf + i)));
1362 break;
1363 case 8:
1364 v = ldq_raw(buf + i)ldq_le_p((uint8_t *)(intptr_t)((buf + i)));
1365 break;
1366 }
1367 monitor_printf(mon, " ");
1368 switch(format) {
1369 case 'o':
1370 monitor_printf(mon, "%#*" PRIo64"l" "o", max_digits, v);
1371 break;
1372 case 'x':
1373 monitor_printf(mon, "0x%0*" PRIx64"l" "x", max_digits, v);
1374 break;
1375 case 'u':
1376 monitor_printf(mon, "%*" PRIu64"l" "u", max_digits, v);
1377 break;
1378 case 'd':
1379 monitor_printf(mon, "%*" PRId64"l" "d", max_digits, v);
1380 break;
1381 case 'c':
1382 monitor_printc(mon, v);
1383 break;
1384 }
1385 i += wsize;
1386 }
1387 monitor_printf(mon, "\n");
1388 addr += l;
1389 len -= l;
1390 }
1391}
1392
1393static void do_memory_dump(Monitor *mon, const QDict *qdict)
1394{
1395 int count = qdict_get_int(qdict, "count");
1396 int format = qdict_get_int(qdict, "format");
1397 int size = qdict_get_int(qdict, "size");
1398 target_long addr = qdict_get_int(qdict, "addr");
1399
1400 memory_dump(mon, count, format, size, addr, 0);
1401}
1402
1403static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1404{
1405 int count = qdict_get_int(qdict, "count");
1406 int format = qdict_get_int(qdict, "format");
1407 int size = qdict_get_int(qdict, "size");
1408 hwaddr addr = qdict_get_int(qdict, "addr");
1409
1410 memory_dump(mon, count, format, size, addr, 1);
1411}
1412
1413static void do_print(Monitor *mon, const QDict *qdict)
1414{
1415 int format = qdict_get_int(qdict, "format");
1416 hwaddr val = qdict_get_int(qdict, "val");
1417
1418 switch(format) {
1419 case 'o':
1420 monitor_printf(mon, "%#" HWADDR_PRIo"l" "o", val);
1421 break;
1422 case 'x':
1423 monitor_printf(mon, "%#" HWADDR_PRIx"l" "x", val);
1424 break;
1425 case 'u':
1426 monitor_printf(mon, "%" HWADDR_PRIu"l" "u", val);
1427 break;
1428 default:
1429 case 'd':
1430 monitor_printf(mon, "%" HWADDR_PRId"l" "d", val);
1431 break;
1432 case 'c':
1433 monitor_printc(mon, val);
1434 break;
1435 }
1436 monitor_printf(mon, "\n");
1437}
1438
1439static void do_sum(Monitor *mon, const QDict *qdict)
1440{
1441 uint32_t addr;
1442 uint16_t sum;
1443 uint32_t start = qdict_get_int(qdict, "start");
1444 uint32_t size = qdict_get_int(qdict, "size");
1445
1446 sum = 0;
1447 for(addr = start; addr < (start + size); addr++) {
1448 uint8_t val = ldub_phys(addr);
1449 /* BSD sum algorithm ('sum' Unix command) */
1450 sum = (sum >> 1) | (sum << 15);
1451 sum += val;
1452 }
1453 monitor_printf(mon, "%05d\n", sum);
1454}
1455
1456static int mouse_button_state;
1457
1458static void do_mouse_move(Monitor *mon, const QDict *qdict)
1459{
1460 int dx, dy, dz;
1461 const char *dx_str = qdict_get_str(qdict, "dx_str");
1462 const char *dy_str = qdict_get_str(qdict, "dy_str");
1463 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1464 dx = strtol(dx_str, NULL((void*)0), 0);
1465 dy = strtol(dy_str, NULL((void*)0), 0);
1466 dz = 0;
1467 if (dz_str)
1468 dz = strtol(dz_str, NULL((void*)0), 0);
1469 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1470}
1471
1472static void do_mouse_button(Monitor *mon, const QDict *qdict)
1473{
1474 int button_state = qdict_get_int(qdict, "button_state");
1475 mouse_button_state = button_state;
1476 kbd_mouse_event(0, 0, 0, mouse_button_state);
1477}
1478
1479static void do_ioport_read(Monitor *mon, const QDict *qdict)
1480{
1481 int size = qdict_get_int(qdict, "size");
1482 int addr = qdict_get_int(qdict, "addr");
1483 int has_index = qdict_haskey(qdict, "index");
1484 uint32_t val;
1485 int suffix;
1486
1487 if (has_index) {
1488 int index = qdict_get_int(qdict, "index");
1489 cpu_outb(addr & IOPORTS_MASK((64 * 1024) - 1), index & 0xff);
1490 addr++;
1491 }
1492 addr &= 0xffff;
1493
1494 switch(size) {
1495 default:
1496 case 1:
1497 val = cpu_inb(addr);
1498 suffix = 'b';
1499 break;
1500 case 2:
1501 val = cpu_inw(addr);
1502 suffix = 'w';
1503 break;
1504 case 4:
1505 val = cpu_inl(addr);
1506 suffix = 'l';
1507 break;
1508 }
1509 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1510 suffix, addr, size * 2, val);
1511}
1512
1513static void do_ioport_write(Monitor *mon, const QDict *qdict)
1514{
1515 int size = qdict_get_int(qdict, "size");
1516 int addr = qdict_get_int(qdict, "addr");
1517 int val = qdict_get_int(qdict, "val");
1518
1519 addr &= IOPORTS_MASK((64 * 1024) - 1);
1520
1521 switch (size) {
1522 default:
1523 case 1:
1524 cpu_outb(addr, val);
1525 break;
1526 case 2:
1527 cpu_outw(addr, val);
1528 break;
1529 case 4:
1530 cpu_outl(addr, val);
1531 break;
1532 }
1533}
1534
1535static void do_boot_set(Monitor *mon, const QDict *qdict)
1536{
1537 int res;
1538 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1539
1540 res = qemu_boot_set(bootdevice);
1541 if (res == 0) {
1542 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1543 } else if (res > 0) {
1544 monitor_printf(mon, "setting boot device list failed\n");
1545 } else {
1546 monitor_printf(mon, "no function defined to set boot device list for "
1547 "this architecture\n");
1548 }
1549}
1550
1551#if defined(TARGET_I3861)
1552static void print_pte(Monitor *mon, hwaddr addr,
1553 hwaddr pte,
1554 hwaddr mask)
1555{
1556#ifdef TARGET_X86_641
1557 if (addr & (1ULL << 47)) {
1558 addr |= -1LL << 48;
1559 }
1560#endif
1561 monitor_printf(mon, TARGET_FMT_plx"%016" "l" "x" ": " TARGET_FMT_plx"%016" "l" "x"
1562 " %c%c%c%c%c%c%c%c%c\n",
1563 addr,
1564 pte & mask,
1565 pte & PG_NX_MASK(1LL << 63) ? 'X' : '-',
1566 pte & PG_GLOBAL_MASK(1 << 8) ? 'G' : '-',
1567 pte & PG_PSE_MASK(1 << 7) ? 'P' : '-',
1568 pte & PG_DIRTY_MASK(1 << 6) ? 'D' : '-',
1569 pte & PG_ACCESSED_MASK(1 << 5) ? 'A' : '-',
1570 pte & PG_PCD_MASK(1 << 4) ? 'C' : '-',
1571 pte & PG_PWT_MASK(1 << 3) ? 'T' : '-',
1572 pte & PG_USER_MASK(1 << 2) ? 'U' : '-',
1573 pte & PG_RW_MASK(1 << 1) ? 'W' : '-');
1574}
1575
1576static void tlb_info_32(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1577{
1578 unsigned int l1, l2;
1579 uint32_t pgd, pde, pte;
1580
1581 pgd = env->cr[3] & ~0xfff;
1582 for(l1 = 0; l1 < 1024; l1++) {
1583 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1584 pde = le32_to_cpu(pde);
1585 if (pde & PG_PRESENT_MASK(1 << 0)) {
1586 if ((pde & PG_PSE_MASK(1 << 7)) && (env->cr[4] & CR4_PSE_MASK(1 << 4))) {
1587 /* 4M pages */
1588 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
1589 } else {
1590 for(l2 = 0; l2 < 1024; l2++) {
1591 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1592 pte = le32_to_cpu(pte);
1593 if (pte & PG_PRESENT_MASK(1 << 0)) {
1594 print_pte(mon, (l1 << 22) + (l2 << 12),
1595 pte & ~PG_PSE_MASK(1 << 7),
1596 ~0xfff);
1597 }
1598 }
1599 }
1600 }
1601 }
1602}
1603
1604static void tlb_info_pae32(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1605{
1606 unsigned int l1, l2, l3;
1607 uint64_t pdpe, pde, pte;
1608 uint64_t pdp_addr, pd_addr, pt_addr;
1609
1610 pdp_addr = env->cr[3] & ~0x1f;
1611 for (l1 = 0; l1 < 4; l1++) {
1612 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1613 pdpe = le64_to_cpu(pdpe);
1614 if (pdpe & PG_PRESENT_MASK(1 << 0)) {
1615 pd_addr = pdpe & 0x3fffffffff000ULL;
1616 for (l2 = 0; l2 < 512; l2++) {
1617 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1618 pde = le64_to_cpu(pde);
1619 if (pde & PG_PRESENT_MASK(1 << 0)) {
1620 if (pde & PG_PSE_MASK(1 << 7)) {
1621 /* 2M pages with PAE, CR4.PSE is ignored */
1622 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
1623 ~((hwaddr)(1 << 20) - 1));
1624 } else {
1625 pt_addr = pde & 0x3fffffffff000ULL;
1626 for (l3 = 0; l3 < 512; l3++) {
1627 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1628 pte = le64_to_cpu(pte);
1629 if (pte & PG_PRESENT_MASK(1 << 0)) {
1630 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1631 + (l3 << 12),
1632 pte & ~PG_PSE_MASK(1 << 7),
1633 ~(hwaddr)0xfff);
1634 }
1635 }
1636 }
1637 }
1638 }
1639 }
1640 }
1641}
1642
1643#ifdef TARGET_X86_641
1644static void tlb_info_64(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1645{
1646 uint64_t l1, l2, l3, l4;
1647 uint64_t pml4e, pdpe, pde, pte;
1648 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1649
1650 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1651 for (l1 = 0; l1 < 512; l1++) {
1652 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1653 pml4e = le64_to_cpu(pml4e);
1654 if (pml4e & PG_PRESENT_MASK(1 << 0)) {
1655 pdp_addr = pml4e & 0x3fffffffff000ULL;
1656 for (l2 = 0; l2 < 512; l2++) {
1657 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1658 pdpe = le64_to_cpu(pdpe);
1659 if (pdpe & PG_PRESENT_MASK(1 << 0)) {
1660 if (pdpe & PG_PSE_MASK(1 << 7)) {
1661 /* 1G pages, CR4.PSE is ignored */
1662 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1663 0x3ffffc0000000ULL);
1664 } else {
1665 pd_addr = pdpe & 0x3fffffffff000ULL;
1666 for (l3 = 0; l3 < 512; l3++) {
1667 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1668 pde = le64_to_cpu(pde);
1669 if (pde & PG_PRESENT_MASK(1 << 0)) {
1670 if (pde & PG_PSE_MASK(1 << 7)) {
1671 /* 2M pages, CR4.PSE is ignored */
1672 print_pte(mon, (l1 << 39) + (l2 << 30) +
1673 (l3 << 21), pde,
1674 0x3ffffffe00000ULL);
1675 } else {
1676 pt_addr = pde & 0x3fffffffff000ULL;
1677 for (l4 = 0; l4 < 512; l4++) {
1678 cpu_physical_memory_read(pt_addr
1679 + l4 * 8,
1680 &pte, 8);
1681 pte = le64_to_cpu(pte);
1682 if (pte & PG_PRESENT_MASK(1 << 0)) {
1683 print_pte(mon, (l1 << 39) +
1684 (l2 << 30) +
1685 (l3 << 21) + (l4 << 12),
1686 pte & ~PG_PSE_MASK(1 << 7),
1687 0x3fffffffff000ULL);
1688 }
1689 }
1690 }
1691 }
1692 }
1693 }
1694 }
1695 }
1696 }
1697 }
1698}
1699#endif
1700
1701static void tlb_info(Monitor *mon, const QDict *qdict)
1702{
1703 CPUArchStatestruct CPUX86State *env;
1704
1705 env = mon_get_cpu();
1706
1707 if (!(env->cr[0] & CR0_PG_MASK(1 << 31))) {
1708 monitor_printf(mon, "PG disabled\n");
1709 return;
1710 }
1711 if (env->cr[4] & CR4_PAE_MASK(1 << 5)) {
1712#ifdef TARGET_X86_641
1713 if (env->hflags & HF_LMA_MASK(1 << 14)) {
1714 tlb_info_64(mon, env);
1715 } else
1716#endif
1717 {
1718 tlb_info_pae32(mon, env);
1719 }
1720 } else {
1721 tlb_info_32(mon, env);
1722 }
1723}
1724
1725static void mem_print(Monitor *mon, hwaddr *pstart,
1726 int *plast_prot,
1727 hwaddr end, int prot)
1728{
1729 int prot1;
1730 prot1 = *plast_prot;
1731 if (prot != prot1) {
1732 if (*pstart != -1) {
1733 monitor_printf(mon, TARGET_FMT_plx"%016" "l" "x" "-" TARGET_FMT_plx"%016" "l" "x" " "
1734 TARGET_FMT_plx"%016" "l" "x" " %c%c%c\n",
1735 *pstart, end, end - *pstart,
1736 prot1 & PG_USER_MASK(1 << 2) ? 'u' : '-',
1737 'r',
1738 prot1 & PG_RW_MASK(1 << 1) ? 'w' : '-');
1739 }
1740 if (prot != 0)
1741 *pstart = end;
1742 else
1743 *pstart = -1;
1744 *plast_prot = prot;
1745 }
1746}
1747
1748static void mem_info_32(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1749{
1750 unsigned int l1, l2;
1751 int prot, last_prot;
1752 uint32_t pgd, pde, pte;
1753 hwaddr start, end;
1754
1755 pgd = env->cr[3] & ~0xfff;
1756 last_prot = 0;
1757 start = -1;
1758 for(l1 = 0; l1 < 1024; l1++) {
1759 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1760 pde = le32_to_cpu(pde);
1761 end = l1 << 22;
1762 if (pde & PG_PRESENT_MASK(1 << 0)) {
1763 if ((pde & PG_PSE_MASK(1 << 7)) && (env->cr[4] & CR4_PSE_MASK(1 << 4))) {
1764 prot = pde & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) | PG_PRESENT_MASK(1 << 0));
1765 mem_print(mon, &start, &last_prot, end, prot);
1766 } else {
1767 for(l2 = 0; l2 < 1024; l2++) {
1768 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1769 pte = le32_to_cpu(pte);
1770 end = (l1 << 22) + (l2 << 12);
1771 if (pte & PG_PRESENT_MASK(1 << 0)) {
1772 prot = pte & pde &
1773 (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) | PG_PRESENT_MASK(1 << 0));
1774 } else {
1775 prot = 0;
1776 }
1777 mem_print(mon, &start, &last_prot, end, prot);
1778 }
1779 }
1780 } else {
1781 prot = 0;
1782 mem_print(mon, &start, &last_prot, end, prot);
1783 }
1784 }
1785 /* Flush last range */
1786 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1787}
1788
1789static void mem_info_pae32(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1790{
1791 unsigned int l1, l2, l3;
1792 int prot, last_prot;
1793 uint64_t pdpe, pde, pte;
1794 uint64_t pdp_addr, pd_addr, pt_addr;
1795 hwaddr start, end;
1796
1797 pdp_addr = env->cr[3] & ~0x1f;
1798 last_prot = 0;
1799 start = -1;
1800 for (l1 = 0; l1 < 4; l1++) {
1801 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1802 pdpe = le64_to_cpu(pdpe);
1803 end = l1 << 30;
1804 if (pdpe & PG_PRESENT_MASK(1 << 0)) {
1805 pd_addr = pdpe & 0x3fffffffff000ULL;
1806 for (l2 = 0; l2 < 512; l2++) {
1807 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1808 pde = le64_to_cpu(pde);
1809 end = (l1 << 30) + (l2 << 21);
1810 if (pde & PG_PRESENT_MASK(1 << 0)) {
1811 if (pde & PG_PSE_MASK(1 << 7)) {
1812 prot = pde & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) |
1813 PG_PRESENT_MASK(1 << 0));
1814 mem_print(mon, &start, &last_prot, end, prot);
1815 } else {
1816 pt_addr = pde & 0x3fffffffff000ULL;
1817 for (l3 = 0; l3 < 512; l3++) {
1818 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1819 pte = le64_to_cpu(pte);
1820 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1821 if (pte & PG_PRESENT_MASK(1 << 0)) {
1822 prot = pte & pde & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) |
1823 PG_PRESENT_MASK(1 << 0));
1824 } else {
1825 prot = 0;
1826 }
1827 mem_print(mon, &start, &last_prot, end, prot);
1828 }
1829 }
1830 } else {
1831 prot = 0;
1832 mem_print(mon, &start, &last_prot, end, prot);
1833 }
1834 }
1835 } else {
1836 prot = 0;
1837 mem_print(mon, &start, &last_prot, end, prot);
1838 }
1839 }
1840 /* Flush last range */
1841 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1842}
1843
1844
1845#ifdef TARGET_X86_641
1846static void mem_info_64(Monitor *mon, CPUArchStatestruct CPUX86State *env)
1847{
1848 int prot, last_prot;
1849 uint64_t l1, l2, l3, l4;
1850 uint64_t pml4e, pdpe, pde, pte;
1851 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1852
1853 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1854 last_prot = 0;
1855 start = -1;
1856 for (l1 = 0; l1 < 512; l1++) {
1857 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1858 pml4e = le64_to_cpu(pml4e);
1859 end = l1 << 39;
1860 if (pml4e & PG_PRESENT_MASK(1 << 0)) {
1861 pdp_addr = pml4e & 0x3fffffffff000ULL;
1862 for (l2 = 0; l2 < 512; l2++) {
1863 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1864 pdpe = le64_to_cpu(pdpe);
1865 end = (l1 << 39) + (l2 << 30);
1866 if (pdpe & PG_PRESENT_MASK(1 << 0)) {
1867 if (pdpe & PG_PSE_MASK(1 << 7)) {
1868 prot = pdpe & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) |
1869 PG_PRESENT_MASK(1 << 0));
1870 prot &= pml4e;
1871 mem_print(mon, &start, &last_prot, end, prot);
1872 } else {
1873 pd_addr = pdpe & 0x3fffffffff000ULL;
1874 for (l3 = 0; l3 < 512; l3++) {
1875 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1876 pde = le64_to_cpu(pde);
1877 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1878 if (pde & PG_PRESENT_MASK(1 << 0)) {
1879 if (pde & PG_PSE_MASK(1 << 7)) {
1880 prot = pde & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) |
1881 PG_PRESENT_MASK(1 << 0));
1882 prot &= pml4e & pdpe;
1883 mem_print(mon, &start, &last_prot, end, prot);
1884 } else {
1885 pt_addr = pde & 0x3fffffffff000ULL;
1886 for (l4 = 0; l4 < 512; l4++) {
1887 cpu_physical_memory_read(pt_addr
1888 + l4 * 8,
1889 &pte, 8);
1890 pte = le64_to_cpu(pte);
1891 end = (l1 << 39) + (l2 << 30) +
1892 (l3 << 21) + (l4 << 12);
1893 if (pte & PG_PRESENT_MASK(1 << 0)) {
1894 prot = pte & (PG_USER_MASK(1 << 2) | PG_RW_MASK(1 << 1) |
1895 PG_PRESENT_MASK(1 << 0));
1896 prot &= pml4e & pdpe & pde;
1897 } else {
1898 prot = 0;
1899 }
1900 mem_print(mon, &start, &last_prot, end, prot);
1901 }
1902 }
1903 } else {
1904 prot = 0;
1905 mem_print(mon, &start, &last_prot, end, prot);
1906 }
1907 }
1908 }
1909 } else {
1910 prot = 0;
1911 mem_print(mon, &start, &last_prot, end, prot);
1912 }
1913 }
1914 } else {
1915 prot = 0;
1916 mem_print(mon, &start, &last_prot, end, prot);
1917 }
1918 }
1919 /* Flush last range */
1920 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
1921}
1922#endif
1923
1924static void mem_info(Monitor *mon, const QDict *qdict)
1925{
1926 CPUArchStatestruct CPUX86State *env;
1927
1928 env = mon_get_cpu();
1929
1930 if (!(env->cr[0] & CR0_PG_MASK(1 << 31))) {
1931 monitor_printf(mon, "PG disabled\n");
1932 return;
1933 }
1934 if (env->cr[4] & CR4_PAE_MASK(1 << 5)) {
1935#ifdef TARGET_X86_641
1936 if (env->hflags & HF_LMA_MASK(1 << 14)) {
1937 mem_info_64(mon, env);
1938 } else
1939#endif
1940 {
1941 mem_info_pae32(mon, env);
1942 }
1943 } else {
1944 mem_info_32(mon, env);
1945 }
1946}
1947#endif
1948
1949#if defined(TARGET_SH4)
1950
1951static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1952{
1953 monitor_printf(mon, " tlb%i:\t"
1954 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1955 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1956 "dirty=%hhu writethrough=%hhu\n",
1957 idx,
1958 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1959 tlb->v, tlb->sh, tlb->c, tlb->pr,
1960 tlb->d, tlb->wt);
1961}
1962
1963static void tlb_info(Monitor *mon, const QDict *qdict)
1964{
1965 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
1966 int i;
1967
1968 monitor_printf (mon, "ITLB:\n");
1969 for (i = 0 ; i < ITLB_SIZE ; i++)
1970 print_tlb (mon, i, &env->itlb[i]);
1971 monitor_printf (mon, "UTLB:\n");
1972 for (i = 0 ; i < UTLB_SIZE ; i++)
1973 print_tlb (mon, i, &env->utlb[i]);
1974}
1975
1976#endif
1977
1978#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
1979static void tlb_info(Monitor *mon, const QDict *qdict)
1980{
1981 CPUArchStatestruct CPUX86State *env1 = mon_get_cpu();
1982
1983 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1984}
1985#endif
1986
1987static void do_info_mtree(Monitor *mon, const QDict *qdict)
1988{
1989 mtree_info((fprintf_function)monitor_printf, mon);
1990}
1991
1992static void do_info_numa(Monitor *mon, const QDict *qdict)
1993{
1994 int i;
1995 CPUState *cpu;
1996
1997 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1998 for (i = 0; i < nb_numa_nodes; i++) {
1999 monitor_printf(mon, "node %d cpus:", i);
2000 CPU_FOREACH(cpu)for ((cpu) = ((&cpus)->tqh_first); (cpu); (cpu) = ((cpu
)->node.tqe_next))
{
2001 if (cpu->numa_node == i) {
2002 monitor_printf(mon, " %d", cpu->cpu_index);
2003 }
2004 }
2005 monitor_printf(mon, "\n");
2006 monitor_printf(mon, "node %d size: %" PRId64"l" "d" " MB\n", i,
2007 node_mem[i] >> 20);
2008 }
2009}
2010
2011#ifdef CONFIG_PROFILER
2012
2013int64_t qemu_time;
2014int64_t dev_time;
2015
2016static void do_info_profile(Monitor *mon, const QDict *qdict)
2017{
2018 int64_t total;
2019 total = qemu_time;
2020 if (total == 0)
2021 total = 1;
2022 monitor_printf(mon, "async time %" PRId64"l" "d" " (%0.3f)\n",
2023 dev_time, dev_time / (double)get_ticks_per_sec());
2024 monitor_printf(mon, "qemu time %" PRId64"l" "d" " (%0.3f)\n",
2025 qemu_time, qemu_time / (double)get_ticks_per_sec());
2026 qemu_time = 0;
2027 dev_time = 0;
2028}
2029#else
2030static void do_info_profile(Monitor *mon, const QDict *qdict)
2031{
2032 monitor_printf(mon, "Internal profiler not compiled\n");
2033}
2034#endif
2035
2036/* Capture support */
2037static QLIST_HEAD (capture_list_head, CaptureState)struct capture_list_head { struct CaptureState *lh_first; } capture_head;
2038
2039static void do_info_capture(Monitor *mon, const QDict *qdict)
2040{
2041 int i;
2042 CaptureState *s;
2043
2044 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2045 monitor_printf(mon, "[%d]: ", i);
2046 s->ops.info (s->opaque);
2047 }
2048}
2049
2050static void do_stop_capture(Monitor *mon, const QDict *qdict)
2051{
2052 int i;
2053 int n = qdict_get_int(qdict, "n");
2054 CaptureState *s;
2055
2056 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2057 if (i == n) {
2058 s->ops.destroy (s->opaque);
2059 QLIST_REMOVE (s, entries)do { if ((s)->entries.le_next != ((void*)0)) (s)->entries
.le_next->entries.le_prev = (s)->entries.le_prev; *(s)->
entries.le_prev = (s)->entries.le_next; } while ( 0)
;
2060 g_free (s);
2061 return;
2062 }
2063 }
2064}
2065
2066static void do_wav_capture(Monitor *mon, const QDict *qdict)
2067{
2068 const char *path = qdict_get_str(qdict, "path");
2069 int has_freq = qdict_haskey(qdict, "freq");
2070 int freq = qdict_get_try_int(qdict, "freq", -1);
2071 int has_bits = qdict_haskey(qdict, "bits");
2072 int bits = qdict_get_try_int(qdict, "bits", -1);
2073 int has_channels = qdict_haskey(qdict, "nchannels");
2074 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2075 CaptureState *s;
2076
2077 s = g_malloc0 (sizeof (*s));
2078
2079 freq = has_freq ? freq : 44100;
2080 bits = has_bits ? bits : 16;
2081 nchannels = has_channels ? nchannels : 2;
2082
2083 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2084 monitor_printf(mon, "Failed to add wave capture\n");
2085 g_free (s);
2086 return;
2087 }
2088 QLIST_INSERT_HEAD (&capture_head, s, entries)do { if (((s)->entries.le_next = (&capture_head)->lh_first
) != ((void*)0)) (&capture_head)->lh_first->entries
.le_prev = &(s)->entries.le_next; (&capture_head)->
lh_first = (s); (s)->entries.le_prev = &(&capture_head
)->lh_first; } while ( 0)
;
2089}
2090
2091static qemu_acl *find_acl(Monitor *mon, const char *name)
2092{
2093 qemu_acl *acl = qemu_acl_find(name);
2094
2095 if (!acl) {
2096 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2097 }
2098 return acl;
2099}
2100
2101static void do_acl_show(Monitor *mon, const QDict *qdict)
2102{
2103 const char *aclname = qdict_get_str(qdict, "aclname");
2104 qemu_acl *acl = find_acl(mon, aclname);
2105 qemu_acl_entry *entry;
2106 int i = 0;
2107
2108 if (acl) {
2109 monitor_printf(mon, "policy: %s\n",
2110 acl->defaultDeny ? "deny" : "allow");
2111 QTAILQ_FOREACH(entry, &acl->entries, next)for ((entry) = ((&acl->entries)->tqh_first); (entry
); (entry) = ((entry)->next.tqe_next))
{
2112 i++;
2113 monitor_printf(mon, "%d: %s %s\n", i,
2114 entry->deny ? "deny" : "allow", entry->match);
2115 }
2116 }
2117}
2118
2119static void do_acl_reset(Monitor *mon, const QDict *qdict)
2120{
2121 const char *aclname = qdict_get_str(qdict, "aclname");
2122 qemu_acl *acl = find_acl(mon, aclname);
2123
2124 if (acl) {
2125 qemu_acl_reset(acl);
2126 monitor_printf(mon, "acl: removed all rules\n");
2127 }
2128}
2129
2130static void do_acl_policy(Monitor *mon, const QDict *qdict)
2131{
2132 const char *aclname = qdict_get_str(qdict, "aclname");
2133 const char *policy = qdict_get_str(qdict, "policy");
2134 qemu_acl *acl = find_acl(mon, aclname);
2135
2136 if (acl) {
2137 if (strcmp(policy, "allow") == 0) {
2138 acl->defaultDeny = 0;
2139 monitor_printf(mon, "acl: policy set to 'allow'\n");
2140 } else if (strcmp(policy, "deny") == 0) {
2141 acl->defaultDeny = 1;
2142 monitor_printf(mon, "acl: policy set to 'deny'\n");
2143 } else {
2144 monitor_printf(mon, "acl: unknown policy '%s', "
2145 "expected 'deny' or 'allow'\n", policy);
2146 }
2147 }
2148}
2149
2150static void do_acl_add(Monitor *mon, const QDict *qdict)
2151{
2152 const char *aclname = qdict_get_str(qdict, "aclname");
2153 const char *match = qdict_get_str(qdict, "match");
2154 const char *policy = qdict_get_str(qdict, "policy");
2155 int has_index = qdict_haskey(qdict, "index");
2156 int index = qdict_get_try_int(qdict, "index", -1);
2157 qemu_acl *acl = find_acl(mon, aclname);
2158 int deny, ret;
2159
2160 if (acl) {
2161 if (strcmp(policy, "allow") == 0) {
2162 deny = 0;
2163 } else if (strcmp(policy, "deny") == 0) {
2164 deny = 1;
2165 } else {
2166 monitor_printf(mon, "acl: unknown policy '%s', "
2167 "expected 'deny' or 'allow'\n", policy);
2168 return;
2169 }
2170 if (has_index)
2171 ret = qemu_acl_insert(acl, deny, match, index);
2172 else
2173 ret = qemu_acl_append(acl, deny, match);
2174 if (ret < 0)
2175 monitor_printf(mon, "acl: unable to add acl entry\n");
2176 else
2177 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2178 }
2179}
2180
2181static void do_acl_remove(Monitor *mon, const QDict *qdict)
2182{
2183 const char *aclname = qdict_get_str(qdict, "aclname");
2184 const char *match = qdict_get_str(qdict, "match");
2185 qemu_acl *acl = find_acl(mon, aclname);
2186 int ret;
2187
2188 if (acl) {
2189 ret = qemu_acl_remove(acl, match);
2190 if (ret < 0)
2191 monitor_printf(mon, "acl: no matching acl entry\n");
2192 else
2193 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2194 }
2195}
2196
2197#if defined(TARGET_I3861)
2198static void do_inject_mce(Monitor *mon, const QDict *qdict)
2199{
2200 X86CPU *cpu;
2201 CPUState *cs;
2202 int cpu_index = qdict_get_int(qdict, "cpu_index");
2203 int bank = qdict_get_int(qdict, "bank");
2204 uint64_t status = qdict_get_int(qdict, "status");
2205 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2206 uint64_t addr = qdict_get_int(qdict, "addr");
2207 uint64_t misc = qdict_get_int(qdict, "misc");
2208 int flags = MCE_INJECT_UNCOND_AO2;
2209
2210 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2211 flags |= MCE_INJECT_BROADCAST1;
2212 }
2213 cs = qemu_get_cpu(cpu_index);
2214 if (cs != NULL((void*)0)) {
2215 cpu = X86_CPU(cs)((X86CPU *)object_dynamic_cast_assert(((Object *)((cs))), ("x86_64-cpu"
), "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 2215, __func__
))
;
2216 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2217 flags);
2218 }
2219}
2220#endif
2221
2222void qmp_getfd(const char *fdname, Error **errp)
2223{
2224 mon_fd_t *monfd;
2225 int fd;
2226
2227 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
2228 if (fd == -1) {
2229 error_set(errp, QERR_FD_NOT_SUPPLIEDERROR_CLASS_GENERIC_ERROR, "No file descriptor supplied via SCM_RIGHTS");
2230 return;
2231 }
2232
2233 if (qemu_isdigit(fdname[0])((*__ctype_b_loc ())[(int) (((unsigned char)(fdname[0])))] &
(unsigned short int) _ISdigit)
) {
2234 error_set(errp, QERR_INVALID_PARAMETER_VALUEERROR_CLASS_GENERIC_ERROR, "Parameter '%s' expects %s", "fdname",
2235 "a name not starting with a digit");
2236 return;
2237 }
2238
2239 QLIST_FOREACH(monfd, &cur_mon->fds, next)for ((monfd) = ((&cur_mon->fds)->lh_first); (monfd)
; (monfd) = ((monfd)->next.le_next))
{
2240 if (strcmp(monfd->name, fdname) != 0) {
2241 continue;
2242 }
2243
2244 close(monfd->fd);
2245 monfd->fd = fd;
2246 return;
2247 }
2248
2249 monfd = g_malloc0(sizeof(mon_fd_t));
2250 monfd->name = g_strdup(fdname);
2251 monfd->fd = fd;
2252
2253 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next)do { if (((monfd)->next.le_next = (&cur_mon->fds)->
lh_first) != ((void*)0)) (&cur_mon->fds)->lh_first->
next.le_prev = &(monfd)->next.le_next; (&cur_mon->
fds)->lh_first = (monfd); (monfd)->next.le_prev = &
(&cur_mon->fds)->lh_first; } while ( 0)
;
2254}
2255
2256void qmp_closefd(const char *fdname, Error **errp)
2257{
2258 mon_fd_t *monfd;
2259
2260 QLIST_FOREACH(monfd, &cur_mon->fds, next)for ((monfd) = ((&cur_mon->fds)->lh_first); (monfd)
; (monfd) = ((monfd)->next.le_next))
{
2261 if (strcmp(monfd->name, fdname) != 0) {
2262 continue;
2263 }
2264
2265 QLIST_REMOVE(monfd, next)do { if ((monfd)->next.le_next != ((void*)0)) (monfd)->
next.le_next->next.le_prev = (monfd)->next.le_prev; *(monfd
)->next.le_prev = (monfd)->next.le_next; } while ( 0)
;
2266 close(monfd->fd);
2267 g_free(monfd->name);
2268 g_free(monfd);
2269 return;
2270 }
2271
2272 error_set(errp, QERR_FD_NOT_FOUNDERROR_CLASS_GENERIC_ERROR, "File descriptor named '%s' not found", fdname);
2273}
2274
2275static void do_loadvm(Monitor *mon, const QDict *qdict)
2276{
2277 int saved_vm_running = runstate_is_running();
2278 const char *name = qdict_get_str(qdict, "name");
2279
2280 vm_stop(RUN_STATE_RESTORE_VM);
2281
2282 if (load_vmstate(name) == 0 && saved_vm_running) {
2283 vm_start();
2284 }
2285}
2286
2287int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2288{
2289 mon_fd_t *monfd;
2290
2291 QLIST_FOREACH(monfd, &mon->fds, next)for ((monfd) = ((&mon->fds)->lh_first); (monfd); (monfd
) = ((monfd)->next.le_next))
{
2292 int fd;
2293
2294 if (strcmp(monfd->name, fdname) != 0) {
2295 continue;
2296 }
2297
2298 fd = monfd->fd;
2299
2300 /* caller takes ownership of fd */
2301 QLIST_REMOVE(monfd, next)do { if ((monfd)->next.le_next != ((void*)0)) (monfd)->
next.le_next->next.le_prev = (monfd)->next.le_prev; *(monfd
)->next.le_prev = (monfd)->next.le_next; } while ( 0)
;
2302 g_free(monfd->name);
2303 g_free(monfd);
2304
2305 return fd;
2306 }
2307
2308 error_setg(errp, "File descriptor named '%s' has not been found", fdname)error_set(errp, ERROR_CLASS_GENERIC_ERROR, "File descriptor named '%s' has not been found"
, fdname)
;
2309 return -1;
2310}
2311
2312static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2313{
2314 MonFdsetFd *mon_fdset_fd;
2315 MonFdsetFd *mon_fdset_fd_next;
2316
2317 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next)for ((mon_fdset_fd) = ((&mon_fdset->fds)->lh_first)
; (mon_fdset_fd) && ((mon_fdset_fd_next) = ((mon_fdset_fd
)->next.le_next), 1); (mon_fdset_fd) = (mon_fdset_fd_next)
)
{
2318 if ((mon_fdset_fd->removed ||
2319 (QLIST_EMPTY(&mon_fdset->dup_fds)((&mon_fdset->dup_fds)->lh_first == ((void*)0)) && mon_refcount == 0)) &&
2320 runstate_is_running()) {
2321 close(mon_fdset_fd->fd);
2322 g_free(mon_fdset_fd->opaque);
2323 QLIST_REMOVE(mon_fdset_fd, next)do { if ((mon_fdset_fd)->next.le_next != ((void*)0)) (mon_fdset_fd
)->next.le_next->next.le_prev = (mon_fdset_fd)->next
.le_prev; *(mon_fdset_fd)->next.le_prev = (mon_fdset_fd)->
next.le_next; } while ( 0)
;
2324 g_free(mon_fdset_fd);
2325 }
2326 }
2327
2328 if (QLIST_EMPTY(&mon_fdset->fds)((&mon_fdset->fds)->lh_first == ((void*)0)) && QLIST_EMPTY(&mon_fdset->dup_fds)((&mon_fdset->dup_fds)->lh_first == ((void*)0))) {
2329 QLIST_REMOVE(mon_fdset, next)do { if ((mon_fdset)->next.le_next != ((void*)0)) (mon_fdset
)->next.le_next->next.le_prev = (mon_fdset)->next.le_prev
; *(mon_fdset)->next.le_prev = (mon_fdset)->next.le_next
; } while ( 0)
;
2330 g_free(mon_fdset);
2331 }
2332}
2333
2334static void monitor_fdsets_cleanup(void)
2335{
2336 MonFdset *mon_fdset;
2337 MonFdset *mon_fdset_next;
2338
2339 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
) && ((mon_fdset_next) = ((mon_fdset)->next.le_next
), 1); (mon_fdset) = (mon_fdset_next))
{
2340 monitor_fdset_cleanup(mon_fdset);
2341 }
2342}
2343
2344AddfdInfo *qmp_add_fd(bool_Bool has_fdset_id, int64_t fdset_id, bool_Bool has_opaque,
2345 const char *opaque, Error **errp)
2346{
2347 int fd;
2348 Monitor *mon = cur_mon;
2349 AddfdInfo *fdinfo;
2350
2351 fd = qemu_chr_fe_get_msgfd(mon->chr);
2352 if (fd == -1) {
2353 error_set(errp, QERR_FD_NOT_SUPPLIEDERROR_CLASS_GENERIC_ERROR, "No file descriptor supplied via SCM_RIGHTS");
2354 goto error;
2355 }
2356
2357 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2358 has_opaque, opaque, errp);
2359 if (fdinfo) {
2360 return fdinfo;
2361 }
2362
2363error:
2364 if (fd != -1) {
2365 close(fd);
2366 }
2367 return NULL((void*)0);
2368}
2369
2370void qmp_remove_fd(int64_t fdset_id, bool_Bool has_fd, int64_t fd, Error **errp)
2371{
2372 MonFdset *mon_fdset;
2373 MonFdsetFd *mon_fdset_fd;
2374 char fd_str[60];
2375
2376 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2377 if (mon_fdset->id != fdset_id) {
2378 continue;
2379 }
2380 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next)for ((mon_fdset_fd) = ((&mon_fdset->fds)->lh_first)
; (mon_fdset_fd); (mon_fdset_fd) = ((mon_fdset_fd)->next.le_next
))
{
2381 if (has_fd) {
2382 if (mon_fdset_fd->fd != fd) {
2383 continue;
2384 }
2385 mon_fdset_fd->removed = true1;
2386 break;
2387 } else {
2388 mon_fdset_fd->removed = true1;
2389 }
2390 }
2391 if (has_fd && !mon_fdset_fd) {
2392 goto error;
2393 }
2394 monitor_fdset_cleanup(mon_fdset);
2395 return;
2396 }
2397
2398error:
2399 if (has_fd) {
2400 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64"l" "d" ", fd:%" PRId64"l" "d",
2401 fdset_id, fd);
2402 } else {
2403 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64"l" "d", fdset_id);
2404 }
2405 error_set(errp, QERR_FD_NOT_FOUNDERROR_CLASS_GENERIC_ERROR, "File descriptor named '%s' not found", fd_str);
2406}
2407
2408FdsetInfoList *qmp_query_fdsets(Error **errp)
2409{
2410 MonFdset *mon_fdset;
2411 MonFdsetFd *mon_fdset_fd;
2412 FdsetInfoList *fdset_list = NULL((void*)0);
2413
2414 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2415 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2416 FdsetFdInfoList *fdsetfd_list = NULL((void*)0);
2417
2418 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2419 fdset_info->value->fdset_id = mon_fdset->id;
2420
2421 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next)for ((mon_fdset_fd) = ((&mon_fdset->fds)->lh_first)
; (mon_fdset_fd); (mon_fdset_fd) = ((mon_fdset_fd)->next.le_next
))
{
2422 FdsetFdInfoList *fdsetfd_info;
2423
2424 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2425 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2426 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2427 if (mon_fdset_fd->opaque) {
2428 fdsetfd_info->value->has_opaque = true1;
2429 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2430 } else {
2431 fdsetfd_info->value->has_opaque = false0;
2432 }
2433
2434 fdsetfd_info->next = fdsetfd_list;
2435 fdsetfd_list = fdsetfd_info;
2436 }
2437
2438 fdset_info->value->fds = fdsetfd_list;
2439
2440 fdset_info->next = fdset_list;
2441 fdset_list = fdset_info;
2442 }
2443
2444 return fdset_list;
2445}
2446
2447AddfdInfo *monitor_fdset_add_fd(int fd, bool_Bool has_fdset_id, int64_t fdset_id,
2448 bool_Bool has_opaque, const char *opaque,
2449 Error **errp)
2450{
2451 MonFdset *mon_fdset = NULL((void*)0);
2452 MonFdsetFd *mon_fdset_fd;
2453 AddfdInfo *fdinfo;
2454
2455 if (has_fdset_id) {
2456 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2457 /* Break if match found or match impossible due to ordering by ID */
2458 if (fdset_id <= mon_fdset->id) {
2459 if (fdset_id < mon_fdset->id) {
2460 mon_fdset = NULL((void*)0);
2461 }
2462 break;
2463 }
2464 }
2465 }
2466
2467 if (mon_fdset == NULL((void*)0)) {
2468 int64_t fdset_id_prev = -1;
2469 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets)((&mon_fdsets)->lh_first);
2470
2471 if (has_fdset_id) {
2472 if (fdset_id < 0) {
2473 error_set(errp, QERR_INVALID_PARAMETER_VALUEERROR_CLASS_GENERIC_ERROR, "Parameter '%s' expects %s", "fdset-id",
2474 "a non-negative value");
2475 return NULL((void*)0);
2476 }
2477 /* Use specified fdset ID */
2478 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2479 mon_fdset_cur = mon_fdset;
2480 if (fdset_id < mon_fdset_cur->id) {
2481 break;
2482 }
2483 }
2484 } else {
2485 /* Use first available fdset ID */
2486 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2487 mon_fdset_cur = mon_fdset;
2488 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2489 fdset_id_prev = mon_fdset_cur->id;
2490 continue;
2491 }
2492 break;
2493 }
2494 }
2495
2496 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2497 if (has_fdset_id) {
2498 mon_fdset->id = fdset_id;
2499 } else {
2500 mon_fdset->id = fdset_id_prev + 1;
2501 }
2502
2503 /* The fdset list is ordered by fdset ID */
2504 if (!mon_fdset_cur) {
2505 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next)do { if (((mon_fdset)->next.le_next = (&mon_fdsets)->
lh_first) != ((void*)0)) (&mon_fdsets)->lh_first->next
.le_prev = &(mon_fdset)->next.le_next; (&mon_fdsets
)->lh_first = (mon_fdset); (mon_fdset)->next.le_prev = &
(&mon_fdsets)->lh_first; } while ( 0)
;
2506 } else if (mon_fdset->id < mon_fdset_cur->id) {
2507 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next)do { (mon_fdset)->next.le_prev = (mon_fdset_cur)->next.
le_prev; (mon_fdset)->next.le_next = (mon_fdset_cur); *(mon_fdset_cur
)->next.le_prev = (mon_fdset); (mon_fdset_cur)->next.le_prev
= &(mon_fdset)->next.le_next; } while ( 0)
;
2508 } else {
2509 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next)do { if (((mon_fdset)->next.le_next = (mon_fdset_cur)->
next.le_next) != ((void*)0)) (mon_fdset_cur)->next.le_next
->next.le_prev = &(mon_fdset)->next.le_next; (mon_fdset_cur
)->next.le_next = (mon_fdset); (mon_fdset)->next.le_prev
= &(mon_fdset_cur)->next.le_next; } while ( 0)
;
2510 }
2511 }
2512
2513 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2514 mon_fdset_fd->fd = fd;
2515 mon_fdset_fd->removed = false0;
2516 if (has_opaque) {
2517 mon_fdset_fd->opaque = g_strdup(opaque);
2518 }
2519 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next)do { if (((mon_fdset_fd)->next.le_next = (&mon_fdset->
fds)->lh_first) != ((void*)0)) (&mon_fdset->fds)->
lh_first->next.le_prev = &(mon_fdset_fd)->next.le_next
; (&mon_fdset->fds)->lh_first = (mon_fdset_fd); (mon_fdset_fd
)->next.le_prev = &(&mon_fdset->fds)->lh_first
; } while ( 0)
;
2520
2521 fdinfo = g_malloc0(sizeof(*fdinfo));
2522 fdinfo->fdset_id = mon_fdset->id;
2523 fdinfo->fd = mon_fdset_fd->fd;
2524
2525 return fdinfo;
2526}
2527
2528int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2529{
2530#ifndef _WIN32
2531 MonFdset *mon_fdset;
2532 MonFdsetFd *mon_fdset_fd;
2533 int mon_fd_flags;
2534
2535 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2536 if (mon_fdset->id != fdset_id) {
2537 continue;
2538 }
2539 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next)for ((mon_fdset_fd) = ((&mon_fdset->fds)->lh_first)
; (mon_fdset_fd); (mon_fdset_fd) = ((mon_fdset_fd)->next.le_next
))
{
2540 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL3);
2541 if (mon_fd_flags == -1) {
2542 return -1;
2543 }
2544
2545 if ((flags & O_ACCMODE0003) == (mon_fd_flags & O_ACCMODE0003)) {
2546 return mon_fdset_fd->fd;
2547 }
2548 }
2549 errno(*__errno_location ()) = EACCES13;
2550 return -1;
2551 }
2552#endif
2553
2554 errno(*__errno_location ()) = ENOENT2;
2555 return -1;
2556}
2557
2558int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2559{
2560 MonFdset *mon_fdset;
2561 MonFdsetFd *mon_fdset_fd_dup;
2562
2563 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2564 if (mon_fdset->id != fdset_id) {
2565 continue;
2566 }
2567 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next)for ((mon_fdset_fd_dup) = ((&mon_fdset->dup_fds)->lh_first
); (mon_fdset_fd_dup); (mon_fdset_fd_dup) = ((mon_fdset_fd_dup
)->next.le_next))
{
2568 if (mon_fdset_fd_dup->fd == dup_fd) {
2569 return -1;
2570 }
2571 }
2572 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2573 mon_fdset_fd_dup->fd = dup_fd;
2574 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next)do { if (((mon_fdset_fd_dup)->next.le_next = (&mon_fdset
->dup_fds)->lh_first) != ((void*)0)) (&mon_fdset->
dup_fds)->lh_first->next.le_prev = &(mon_fdset_fd_dup
)->next.le_next; (&mon_fdset->dup_fds)->lh_first
= (mon_fdset_fd_dup); (mon_fdset_fd_dup)->next.le_prev = &
(&mon_fdset->dup_fds)->lh_first; } while ( 0)
;
2575 return 0;
2576 }
2577 return -1;
2578}
2579
2580static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool_Bool remove)
2581{
2582 MonFdset *mon_fdset;
2583 MonFdsetFd *mon_fdset_fd_dup;
2584
2585 QLIST_FOREACH(mon_fdset, &mon_fdsets, next)for ((mon_fdset) = ((&mon_fdsets)->lh_first); (mon_fdset
); (mon_fdset) = ((mon_fdset)->next.le_next))
{
2586 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next)for ((mon_fdset_fd_dup) = ((&mon_fdset->dup_fds)->lh_first
); (mon_fdset_fd_dup); (mon_fdset_fd_dup) = ((mon_fdset_fd_dup
)->next.le_next))
{
2587 if (mon_fdset_fd_dup->fd == dup_fd) {
2588 if (remove) {
2589 QLIST_REMOVE(mon_fdset_fd_dup, next)do { if ((mon_fdset_fd_dup)->next.le_next != ((void*)0)) (
mon_fdset_fd_dup)->next.le_next->next.le_prev = (mon_fdset_fd_dup
)->next.le_prev; *(mon_fdset_fd_dup)->next.le_prev = (mon_fdset_fd_dup
)->next.le_next; } while ( 0)
;
2590 if (QLIST_EMPTY(&mon_fdset->dup_fds)((&mon_fdset->dup_fds)->lh_first == ((void*)0))) {
2591 monitor_fdset_cleanup(mon_fdset);
2592 }
2593 }
2594 return mon_fdset->id;
2595 }
2596 }
2597 }
2598 return -1;
2599}
2600
2601int monitor_fdset_dup_fd_find(int dup_fd)
2602{
2603 return monitor_fdset_dup_fd_find_remove(dup_fd, false0);
2604}
2605
2606int monitor_fdset_dup_fd_remove(int dup_fd)
2607{
2608 return monitor_fdset_dup_fd_find_remove(dup_fd, true1);
2609}
2610
2611int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2612{
2613 int fd;
2614 Error *local_err = NULL((void*)0);
2615
2616 if (!qemu_isdigit(fdname[0])((*__ctype_b_loc ())[(int) (((unsigned char)(fdname[0])))] &
(unsigned short int) _ISdigit)
&& mon) {
2617
2618 fd = monitor_get_fd(mon, fdname, &local_err);
2619 if (fd == -1) {
2620 qerror_report_err(local_err);
2621 error_free(local_err);
2622 return -1;
2623 }
2624 } else {
2625 fd = qemu_parse_fd(fdname);
2626 }
2627
2628 return fd;
2629}
2630
2631/* Please update hmp-commands.hx when adding or changing commands */
2632static mon_cmd_t info_cmds[] = {
2633 {
2634 .name = "version",
2635 .args_type = "",
2636 .params = "",
2637 .help = "show the version of QEMU",
2638 .mhandler.cmd = hmp_info_version,
2639 },
2640 {
2641 .name = "network",
2642 .args_type = "",
2643 .params = "",
2644 .help = "show the network state",
2645 .mhandler.cmd = do_info_network,
2646 },
2647 {
2648 .name = "chardev",
2649 .args_type = "",
2650 .params = "",
2651 .help = "show the character devices",
2652 .mhandler.cmd = hmp_info_chardev,
2653 },
2654 {
2655 .name = "block",
2656 .args_type = "verbose:-v,device:B?",
2657 .params = "[-v] [device]",
2658 .help = "show info of one block device or all block devices "
2659 "(and details of images with -v option)",
2660 .mhandler.cmd = hmp_info_block,
2661 },
2662 {
2663 .name = "blockstats",
2664 .args_type = "",
2665 .params = "",
2666 .help = "show block device statistics",
2667 .mhandler.cmd = hmp_info_blockstats,
2668 },
2669 {
2670 .name = "block-jobs",
2671 .args_type = "",
2672 .params = "",
2673 .help = "show progress of ongoing block device operations",
2674 .mhandler.cmd = hmp_info_block_jobs,
2675 },
2676 {
2677 .name = "registers",
2678 .args_type = "",
2679 .params = "",
2680 .help = "show the cpu registers",
2681 .mhandler.cmd = do_info_registers,
2682 },
2683 {
2684 .name = "cpus",
2685 .args_type = "",
2686 .params = "",
2687 .help = "show infos for each CPU",
2688 .mhandler.cmd = hmp_info_cpus,
2689 },
2690 {
2691 .name = "history",
2692 .args_type = "",
2693 .params = "",
2694 .help = "show the command line history",
2695 .mhandler.cmd = do_info_history,
2696 },
2697#if defined(TARGET_I3861) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2698 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
2699 {
2700 .name = "irq",
2701 .args_type = "",
2702 .params = "",
2703 .help = "show the interrupts statistics (if available)",
2704#ifdef TARGET_SPARC
2705 .mhandler.cmd = sun4m_irq_info,
2706#elif defined(TARGET_LM32)
2707 .mhandler.cmd = lm32_irq_info,
2708#else
2709 .mhandler.cmd = irq_info,
2710#endif
2711 },
2712 {
2713 .name = "pic",
2714 .args_type = "",
2715 .params = "",
2716 .help = "show i8259 (PIC) state",
2717#ifdef TARGET_SPARC
2718 .mhandler.cmd = sun4m_pic_info,
2719#elif defined(TARGET_LM32)
2720 .mhandler.cmd = lm32_do_pic_info,
2721#else
2722 .mhandler.cmd = pic_info,
2723#endif
2724 },
2725#endif
2726 {
2727 .name = "pci",
2728 .args_type = "",
2729 .params = "",
2730 .help = "show PCI info",
2731 .mhandler.cmd = hmp_info_pci,
2732 },
2733#if defined(TARGET_I3861) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
2734 defined(TARGET_PPC) || defined(TARGET_XTENSA)
2735 {
2736 .name = "tlb",
2737 .args_type = "",
2738 .params = "",
2739 .help = "show virtual to physical memory mappings",
2740 .mhandler.cmd = tlb_info,
2741 },
2742#endif
2743#if defined(TARGET_I3861)
2744 {
2745 .name = "mem",
2746 .args_type = "",
2747 .params = "",
2748 .help = "show the active virtual memory mappings",
2749 .mhandler.cmd = mem_info,
2750 },
2751#endif
2752 {
2753 .name = "mtree",
2754 .args_type = "",
2755 .params = "",
2756 .help = "show memory tree",
2757 .mhandler.cmd = do_info_mtree,
2758 },
2759 {
2760 .name = "jit",
2761 .args_type = "",
2762 .params = "",
2763 .help = "show dynamic compiler info",
2764 .mhandler.cmd = do_info_jit,
2765 },
2766 {
2767 .name = "kvm",
2768 .args_type = "",
2769 .params = "",
2770 .help = "show KVM information",
2771 .mhandler.cmd = hmp_info_kvm,
2772 },
2773 {
2774 .name = "numa",
2775 .args_type = "",
2776 .params = "",
2777 .help = "show NUMA information",
2778 .mhandler.cmd = do_info_numa,
2779 },
2780 {
2781 .name = "usb",
2782 .args_type = "",
2783 .params = "",
2784 .help = "show guest USB devices",
2785 .mhandler.cmd = usb_info,
2786 },
2787 {
2788 .name = "usbhost",
2789 .args_type = "",
2790 .params = "",
2791 .help = "show host USB devices",
2792 .mhandler.cmd = usb_host_info,
2793 },
2794 {
2795 .name = "profile",
2796 .args_type = "",
2797 .params = "",
2798 .help = "show profiling information",
2799 .mhandler.cmd = do_info_profile,
2800 },
2801 {
2802 .name = "capture",
2803 .args_type = "",
2804 .params = "",
2805 .help = "show capture information",
2806 .mhandler.cmd = do_info_capture,
2807 },
2808 {
2809 .name = "snapshots",
2810 .args_type = "",
2811 .params = "",
2812 .help = "show the currently saved VM snapshots",
2813 .mhandler.cmd = do_info_snapshots,
2814 },
2815 {
2816 .name = "status",
2817 .args_type = "",
2818 .params = "",
2819 .help = "show the current VM status (running|paused)",
2820 .mhandler.cmd = hmp_info_status,
2821 },
2822 {
2823 .name = "pcmcia",
2824 .args_type = "",
2825 .params = "",
2826 .help = "show guest PCMCIA status",
2827 .mhandler.cmd = pcmcia_info,
2828 },
2829 {
2830 .name = "mice",
2831 .args_type = "",
2832 .params = "",
2833 .help = "show which guest mouse is receiving events",
2834 .mhandler.cmd = hmp_info_mice,
2835 },
2836 {
2837 .name = "vnc",
2838 .args_type = "",
2839 .params = "",
2840 .help = "show the vnc server status",
2841 .mhandler.cmd = hmp_info_vnc,
2842 },
2843#if defined(CONFIG_SPICE1)
2844 {
2845 .name = "spice",
2846 .args_type = "",
2847 .params = "",
2848 .help = "show the spice server status",
2849 .mhandler.cmd = hmp_info_spice,
2850 },
2851#endif
2852 {
2853 .name = "name",
2854 .args_type = "",
2855 .params = "",
2856 .help = "show the current VM name",
2857 .mhandler.cmd = hmp_info_name,
2858 },
2859 {
2860 .name = "uuid",
2861 .args_type = "",
2862 .params = "",
2863 .help = "show the current VM UUID",
2864 .mhandler.cmd = hmp_info_uuid,
2865 },
2866 {
2867 .name = "cpustats",
2868 .args_type = "",
2869 .params = "",
2870 .help = "show CPU statistics",
2871 .mhandler.cmd = do_info_cpu_stats,
2872 },
2873#if defined(CONFIG_SLIRP1)
2874 {
2875 .name = "usernet",
2876 .args_type = "",
2877 .params = "",
2878 .help = "show user network stack connection states",
2879 .mhandler.cmd = do_info_usernet,
2880 },
2881#endif
2882 {
2883 .name = "migrate",
2884 .args_type = "",
2885 .params = "",
2886 .help = "show migration status",
2887 .mhandler.cmd = hmp_info_migrate,
2888 },
2889 {
2890 .name = "migrate_capabilities",
2891 .args_type = "",
2892 .params = "",
2893 .help = "show current migration capabilities",
2894 .mhandler.cmd = hmp_info_migrate_capabilities,
2895 },
2896 {
2897 .name = "migrate_cache_size",
2898 .args_type = "",
2899 .params = "",
2900 .help = "show current migration xbzrle cache size",
2901 .mhandler.cmd = hmp_info_migrate_cache_size,
2902 },
2903 {
2904 .name = "balloon",
2905 .args_type = "",
2906 .params = "",
2907 .help = "show balloon information",
2908 .mhandler.cmd = hmp_info_balloon,
2909 },
2910 {
2911 .name = "qtree",
2912 .args_type = "",
2913 .params = "",
2914 .help = "show device tree",
2915 .mhandler.cmd = do_info_qtree,
2916 },
2917 {
2918 .name = "qdm",
2919 .args_type = "",
2920 .params = "",
2921 .help = "show qdev device model list",
2922 .mhandler.cmd = do_info_qdm,
2923 },
2924 {
2925 .name = "roms",
2926 .args_type = "",
2927 .params = "",
2928 .help = "show roms",
2929 .mhandler.cmd = do_info_roms,
2930 },
2931 {
2932 .name = "trace-events",
2933 .args_type = "",
2934 .params = "",
2935 .help = "show available trace-events & their state",
2936 .mhandler.cmd = do_trace_print_events,
2937 },
2938 {
2939 .name = "tpm",
2940 .args_type = "",
2941 .params = "",
2942 .help = "show the TPM device",
2943 .mhandler.cmd = hmp_info_tpm,
2944 },
2945 {
2946 .name = NULL((void*)0),
2947 },
2948};
2949
2950/* mon_cmds and info_cmds would be sorted at runtime */
2951static mon_cmd_t mon_cmds[] = {
2952#include "hmp-commands.h"
2953 { NULL((void*)0), NULL((void*)0), },
2954};
2955
2956static const mon_cmd_t qmp_cmds[] = {
2957#include "qmp-commands-old.h"
2958 { /* NULL */ },
2959};
2960
2961/*******************************************************************/
2962
2963static const char *pch;
2964static sigjmp_buf expr_env;
2965
2966#define MD_TLONG0 0
2967#define MD_I321 1
2968
2969typedef struct MonitorDef {
2970 const char *name;
2971 int offset;
2972 target_long (*get_value)(const struct MonitorDef *md, int val);
2973 int type;
2974} MonitorDef;
2975
2976#if defined(TARGET_I3861)
2977static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2978{
2979 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
2980 return env->eip + env->segs[R_CS1].base;
2981}
2982#endif
2983
2984#if defined(TARGET_PPC)
2985static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2986{
2987 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
2988 unsigned int u;
2989 int i;
2990
2991 u = 0;
2992 for (i = 0; i < 8; i++)
2993 u |= env->crf[i] << (32 - (4 * i));
2994
2995 return u;
2996}
2997
2998static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2999{
3000 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3001 return env->msr;
3002}
3003
3004static target_long monitor_get_xer (const struct MonitorDef *md, int val)
3005{
3006 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3007 return env->xer;
3008}
3009
3010static target_long monitor_get_decr (const struct MonitorDef *md, int val)
3011{
3012 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3013 return cpu_ppc_load_decr(env);
3014}
3015
3016static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
3017{
3018 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3019 return cpu_ppc_load_tbu(env);
3020}
3021
3022static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
3023{
3024 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3025 return cpu_ppc_load_tbl(env);
3026}
3027#endif
3028
3029#if defined(TARGET_SPARC)
3030#ifndef TARGET_SPARC64
3031static target_long monitor_get_psr (const struct MonitorDef *md, int val)
3032{
3033 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3034
3035 return cpu_get_psr(env);
3036}
3037#endif
3038
3039static target_long monitor_get_reg(const struct MonitorDef *md, int val)
3040{
3041 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3042 return env->regwptr[val];
3043}
3044#endif
3045
3046static const MonitorDef monitor_defs[] = {
3047#ifdef TARGET_I3861
3048
3049#define SEG(name, seg){ name, __builtin_offsetof(CPUX86State, segs[seg].selector), (
(void*)0), 1 }, { name ".base", __builtin_offsetof(CPUX86State
, segs[seg].base) }, { name ".limit", __builtin_offsetof(CPUX86State
, segs[seg].limit), ((void*)0), 1 },
\
3050 { name, offsetof(CPUX86State, segs[seg].selector)__builtin_offsetof(CPUX86State, segs[seg].selector), NULL((void*)0), MD_I321 },\
3051 { name ".base", offsetof(CPUX86State, segs[seg].base)__builtin_offsetof(CPUX86State, segs[seg].base) },\
3052 { name ".limit", offsetof(CPUX86State, segs[seg].limit)__builtin_offsetof(CPUX86State, segs[seg].limit), NULL((void*)0), MD_I321 },
3053
3054 { "eax", offsetof(CPUX86State, regs[0])__builtin_offsetof(CPUX86State, regs[0]) },
3055 { "ecx", offsetof(CPUX86State, regs[1])__builtin_offsetof(CPUX86State, regs[1]) },
3056 { "edx", offsetof(CPUX86State, regs[2])__builtin_offsetof(CPUX86State, regs[2]) },
3057 { "ebx", offsetof(CPUX86State, regs[3])__builtin_offsetof(CPUX86State, regs[3]) },
3058 { "esp|sp", offsetof(CPUX86State, regs[4])__builtin_offsetof(CPUX86State, regs[4]) },
3059 { "ebp|fp", offsetof(CPUX86State, regs[5])__builtin_offsetof(CPUX86State, regs[5]) },
3060 { "esi", offsetof(CPUX86State, regs[6])__builtin_offsetof(CPUX86State, regs[6]) },
3061 { "edi", offsetof(CPUX86State, regs[7])__builtin_offsetof(CPUX86State, regs[7]) },
3062#ifdef TARGET_X86_641
3063 { "r8", offsetof(CPUX86State, regs[8])__builtin_offsetof(CPUX86State, regs[8]) },
3064 { "r9", offsetof(CPUX86State, regs[9])__builtin_offsetof(CPUX86State, regs[9]) },
3065 { "r10", offsetof(CPUX86State, regs[10])__builtin_offsetof(CPUX86State, regs[10]) },
3066 { "r11", offsetof(CPUX86State, regs[11])__builtin_offsetof(CPUX86State, regs[11]) },
3067 { "r12", offsetof(CPUX86State, regs[12])__builtin_offsetof(CPUX86State, regs[12]) },
3068 { "r13", offsetof(CPUX86State, regs[13])__builtin_offsetof(CPUX86State, regs[13]) },
3069 { "r14", offsetof(CPUX86State, regs[14])__builtin_offsetof(CPUX86State, regs[14]) },
3070 { "r15", offsetof(CPUX86State, regs[15])__builtin_offsetof(CPUX86State, regs[15]) },
3071#endif
3072 { "eflags", offsetof(CPUX86State, eflags)__builtin_offsetof(CPUX86State, eflags) },
3073 { "eip", offsetof(CPUX86State, eip)__builtin_offsetof(CPUX86State, eip) },
3074 SEG("cs", R_CS){ "cs", __builtin_offsetof(CPUX86State, segs[1].selector), ((
void*)0), 1 }, { "cs" ".base", __builtin_offsetof(CPUX86State
, segs[1].base) }, { "cs" ".limit", __builtin_offsetof(CPUX86State
, segs[1].limit), ((void*)0), 1 },
3075 SEG("ds", R_DS){ "ds", __builtin_offsetof(CPUX86State, segs[3].selector), ((
void*)0), 1 }, { "ds" ".base", __builtin_offsetof(CPUX86State
, segs[3].base) }, { "ds" ".limit", __builtin_offsetof(CPUX86State
, segs[3].limit), ((void*)0), 1 },
3076 SEG("es", R_ES){ "es", __builtin_offsetof(CPUX86State, segs[0].selector), ((
void*)0), 1 }, { "es" ".base", __builtin_offsetof(CPUX86State
, segs[0].base) }, { "es" ".limit", __builtin_offsetof(CPUX86State
, segs[0].limit), ((void*)0), 1 },
3077 SEG("ss", R_SS){ "ss", __builtin_offsetof(CPUX86State, segs[2].selector), ((
void*)0), 1 }, { "ss" ".base", __builtin_offsetof(CPUX86State
, segs[2].base) }, { "ss" ".limit", __builtin_offsetof(CPUX86State
, segs[2].limit), ((void*)0), 1 },
3078 SEG("fs", R_FS){ "fs", __builtin_offsetof(CPUX86State, segs[4].selector), ((
void*)0), 1 }, { "fs" ".base", __builtin_offsetof(CPUX86State
, segs[4].base) }, { "fs" ".limit", __builtin_offsetof(CPUX86State
, segs[4].limit), ((void*)0), 1 },
3079 SEG("gs", R_GS){ "gs", __builtin_offsetof(CPUX86State, segs[5].selector), ((
void*)0), 1 }, { "gs" ".base", __builtin_offsetof(CPUX86State
, segs[5].base) }, { "gs" ".limit", __builtin_offsetof(CPUX86State
, segs[5].limit), ((void*)0), 1 },
3080 { "pc", 0, monitor_get_pc, },
3081#elif defined(TARGET_PPC)
3082 /* General purpose registers */
3083 { "r0", offsetof(CPUPPCState, gpr[0])__builtin_offsetof(CPUPPCState, gpr[0]) },
3084 { "r1", offsetof(CPUPPCState, gpr[1])__builtin_offsetof(CPUPPCState, gpr[1]) },
3085 { "r2", offsetof(CPUPPCState, gpr[2])__builtin_offsetof(CPUPPCState, gpr[2]) },
3086 { "r3", offsetof(CPUPPCState, gpr[3])__builtin_offsetof(CPUPPCState, gpr[3]) },
3087 { "r4", offsetof(CPUPPCState, gpr[4])__builtin_offsetof(CPUPPCState, gpr[4]) },
3088 { "r5", offsetof(CPUPPCState, gpr[5])__builtin_offsetof(CPUPPCState, gpr[5]) },
3089 { "r6", offsetof(CPUPPCState, gpr[6])__builtin_offsetof(CPUPPCState, gpr[6]) },
3090 { "r7", offsetof(CPUPPCState, gpr[7])__builtin_offsetof(CPUPPCState, gpr[7]) },
3091 { "r8", offsetof(CPUPPCState, gpr[8])__builtin_offsetof(CPUPPCState, gpr[8]) },
3092 { "r9", offsetof(CPUPPCState, gpr[9])__builtin_offsetof(CPUPPCState, gpr[9]) },
3093 { "r10", offsetof(CPUPPCState, gpr[10])__builtin_offsetof(CPUPPCState, gpr[10]) },
3094 { "r11", offsetof(CPUPPCState, gpr[11])__builtin_offsetof(CPUPPCState, gpr[11]) },
3095 { "r12", offsetof(CPUPPCState, gpr[12])__builtin_offsetof(CPUPPCState, gpr[12]) },
3096 { "r13", offsetof(CPUPPCState, gpr[13])__builtin_offsetof(CPUPPCState, gpr[13]) },
3097 { "r14", offsetof(CPUPPCState, gpr[14])__builtin_offsetof(CPUPPCState, gpr[14]) },
3098 { "r15", offsetof(CPUPPCState, gpr[15])__builtin_offsetof(CPUPPCState, gpr[15]) },
3099 { "r16", offsetof(CPUPPCState, gpr[16])__builtin_offsetof(CPUPPCState, gpr[16]) },
3100 { "r17", offsetof(CPUPPCState, gpr[17])__builtin_offsetof(CPUPPCState, gpr[17]) },
3101 { "r18", offsetof(CPUPPCState, gpr[18])__builtin_offsetof(CPUPPCState, gpr[18]) },
3102 { "r19", offsetof(CPUPPCState, gpr[19])__builtin_offsetof(CPUPPCState, gpr[19]) },
3103 { "r20", offsetof(CPUPPCState, gpr[20])__builtin_offsetof(CPUPPCState, gpr[20]) },
3104 { "r21", offsetof(CPUPPCState, gpr[21])__builtin_offsetof(CPUPPCState, gpr[21]) },
3105 { "r22", offsetof(CPUPPCState, gpr[22])__builtin_offsetof(CPUPPCState, gpr[22]) },
3106 { "r23", offsetof(CPUPPCState, gpr[23])__builtin_offsetof(CPUPPCState, gpr[23]) },
3107 { "r24", offsetof(CPUPPCState, gpr[24])__builtin_offsetof(CPUPPCState, gpr[24]) },
3108 { "r25", offsetof(CPUPPCState, gpr[25])__builtin_offsetof(CPUPPCState, gpr[25]) },
3109 { "r26", offsetof(CPUPPCState, gpr[26])__builtin_offsetof(CPUPPCState, gpr[26]) },
3110 { "r27", offsetof(CPUPPCState, gpr[27])__builtin_offsetof(CPUPPCState, gpr[27]) },
3111 { "r28", offsetof(CPUPPCState, gpr[28])__builtin_offsetof(CPUPPCState, gpr[28]) },
3112 { "r29", offsetof(CPUPPCState, gpr[29])__builtin_offsetof(CPUPPCState, gpr[29]) },
3113 { "r30", offsetof(CPUPPCState, gpr[30])__builtin_offsetof(CPUPPCState, gpr[30]) },
3114 { "r31", offsetof(CPUPPCState, gpr[31])__builtin_offsetof(CPUPPCState, gpr[31]) },
3115 /* Floating point registers */
3116 { "f0", offsetof(CPUPPCState, fpr[0])__builtin_offsetof(CPUPPCState, fpr[0]) },
3117 { "f1", offsetof(CPUPPCState, fpr[1])__builtin_offsetof(CPUPPCState, fpr[1]) },
3118 { "f2", offsetof(CPUPPCState, fpr[2])__builtin_offsetof(CPUPPCState, fpr[2]) },
3119 { "f3", offsetof(CPUPPCState, fpr[3])__builtin_offsetof(CPUPPCState, fpr[3]) },
3120 { "f4", offsetof(CPUPPCState, fpr[4])__builtin_offsetof(CPUPPCState, fpr[4]) },
3121 { "f5", offsetof(CPUPPCState, fpr[5])__builtin_offsetof(CPUPPCState, fpr[5]) },
3122 { "f6", offsetof(CPUPPCState, fpr[6])__builtin_offsetof(CPUPPCState, fpr[6]) },
3123 { "f7", offsetof(CPUPPCState, fpr[7])__builtin_offsetof(CPUPPCState, fpr[7]) },
3124 { "f8", offsetof(CPUPPCState, fpr[8])__builtin_offsetof(CPUPPCState, fpr[8]) },
3125 { "f9", offsetof(CPUPPCState, fpr[9])__builtin_offsetof(CPUPPCState, fpr[9]) },
3126 { "f10", offsetof(CPUPPCState, fpr[10])__builtin_offsetof(CPUPPCState, fpr[10]) },
3127 { "f11", offsetof(CPUPPCState, fpr[11])__builtin_offsetof(CPUPPCState, fpr[11]) },
3128 { "f12", offsetof(CPUPPCState, fpr[12])__builtin_offsetof(CPUPPCState, fpr[12]) },
3129 { "f13", offsetof(CPUPPCState, fpr[13])__builtin_offsetof(CPUPPCState, fpr[13]) },
3130 { "f14", offsetof(CPUPPCState, fpr[14])__builtin_offsetof(CPUPPCState, fpr[14]) },
3131 { "f15", offsetof(CPUPPCState, fpr[15])__builtin_offsetof(CPUPPCState, fpr[15]) },
3132 { "f16", offsetof(CPUPPCState, fpr[16])__builtin_offsetof(CPUPPCState, fpr[16]) },
3133 { "f17", offsetof(CPUPPCState, fpr[17])__builtin_offsetof(CPUPPCState, fpr[17]) },
3134 { "f18", offsetof(CPUPPCState, fpr[18])__builtin_offsetof(CPUPPCState, fpr[18]) },
3135 { "f19", offsetof(CPUPPCState, fpr[19])__builtin_offsetof(CPUPPCState, fpr[19]) },
3136 { "f20", offsetof(CPUPPCState, fpr[20])__builtin_offsetof(CPUPPCState, fpr[20]) },
3137 { "f21", offsetof(CPUPPCState, fpr[21])__builtin_offsetof(CPUPPCState, fpr[21]) },
3138 { "f22", offsetof(CPUPPCState, fpr[22])__builtin_offsetof(CPUPPCState, fpr[22]) },
3139 { "f23", offsetof(CPUPPCState, fpr[23])__builtin_offsetof(CPUPPCState, fpr[23]) },
3140 { "f24", offsetof(CPUPPCState, fpr[24])__builtin_offsetof(CPUPPCState, fpr[24]) },
3141 { "f25", offsetof(CPUPPCState, fpr[25])__builtin_offsetof(CPUPPCState, fpr[25]) },
3142 { "f26", offsetof(CPUPPCState, fpr[26])__builtin_offsetof(CPUPPCState, fpr[26]) },
3143 { "f27", offsetof(CPUPPCState, fpr[27])__builtin_offsetof(CPUPPCState, fpr[27]) },
3144 { "f28", offsetof(CPUPPCState, fpr[28])__builtin_offsetof(CPUPPCState, fpr[28]) },
3145 { "f29", offsetof(CPUPPCState, fpr[29])__builtin_offsetof(CPUPPCState, fpr[29]) },
3146 { "f30", offsetof(CPUPPCState, fpr[30])__builtin_offsetof(CPUPPCState, fpr[30]) },
3147 { "f31", offsetof(CPUPPCState, fpr[31])__builtin_offsetof(CPUPPCState, fpr[31]) },
3148 { "fpscr", offsetof(CPUPPCState, fpscr)__builtin_offsetof(CPUPPCState, fpscr) },
3149 /* Next instruction pointer */
3150 { "nip|pc", offsetof(CPUPPCState, nip)__builtin_offsetof(CPUPPCState, nip) },
3151 { "lr", offsetof(CPUPPCState, lr)__builtin_offsetof(CPUPPCState, lr) },
3152 { "ctr", offsetof(CPUPPCState, ctr)__builtin_offsetof(CPUPPCState, ctr) },
3153 { "decr", 0, &monitor_get_decr, },
3154 { "ccr", 0, &monitor_get_ccr, },
3155 /* Machine state register */
3156 { "msr", 0, &monitor_get_msr, },
3157 { "xer", 0, &monitor_get_xer, },
3158 { "tbu", 0, &monitor_get_tbu, },
3159 { "tbl", 0, &monitor_get_tbl, },
3160 /* Segment registers */
3161 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1])__builtin_offsetof(CPUPPCState, spr[SPR_SDR1]) },
3162 { "sr0", offsetof(CPUPPCState, sr[0])__builtin_offsetof(CPUPPCState, sr[0]) },
3163 { "sr1", offsetof(CPUPPCState, sr[1])__builtin_offsetof(CPUPPCState, sr[1]) },
3164 { "sr2", offsetof(CPUPPCState, sr[2])__builtin_offsetof(CPUPPCState, sr[2]) },
3165 { "sr3", offsetof(CPUPPCState, sr[3])__builtin_offsetof(CPUPPCState, sr[3]) },
3166 { "sr4", offsetof(CPUPPCState, sr[4])__builtin_offsetof(CPUPPCState, sr[4]) },
3167 { "sr5", offsetof(CPUPPCState, sr[5])__builtin_offsetof(CPUPPCState, sr[5]) },
3168 { "sr6", offsetof(CPUPPCState, sr[6])__builtin_offsetof(CPUPPCState, sr[6]) },
3169 { "sr7", offsetof(CPUPPCState, sr[7])__builtin_offsetof(CPUPPCState, sr[7]) },
3170 { "sr8", offsetof(CPUPPCState, sr[8])__builtin_offsetof(CPUPPCState, sr[8]) },
3171 { "sr9", offsetof(CPUPPCState, sr[9])__builtin_offsetof(CPUPPCState, sr[9]) },
3172 { "sr10", offsetof(CPUPPCState, sr[10])__builtin_offsetof(CPUPPCState, sr[10]) },
3173 { "sr11", offsetof(CPUPPCState, sr[11])__builtin_offsetof(CPUPPCState, sr[11]) },
3174 { "sr12", offsetof(CPUPPCState, sr[12])__builtin_offsetof(CPUPPCState, sr[12]) },
3175 { "sr13", offsetof(CPUPPCState, sr[13])__builtin_offsetof(CPUPPCState, sr[13]) },
3176 { "sr14", offsetof(CPUPPCState, sr[14])__builtin_offsetof(CPUPPCState, sr[14]) },
3177 { "sr15", offsetof(CPUPPCState, sr[15])__builtin_offsetof(CPUPPCState, sr[15]) },
3178 /* Too lazy to put BATs... */
3179 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR])__builtin_offsetof(CPUPPCState, spr[SPR_PVR]) },
3180
3181 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0])__builtin_offsetof(CPUPPCState, spr[SPR_SRR0]) },
3182 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1])__builtin_offsetof(CPUPPCState, spr[SPR_SRR1]) },
3183 { "dar", offsetof(CPUPPCState, spr[SPR_DAR])__builtin_offsetof(CPUPPCState, spr[SPR_DAR]) },
3184 { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR])__builtin_offsetof(CPUPPCState, spr[SPR_DSISR]) },
3185 { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR])__builtin_offsetof(CPUPPCState, spr[SPR_CFAR]) },
3186 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3187 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3188 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3189 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3190 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3191 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3192 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3193 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7])__builtin_offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3194 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3195 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3196 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3197 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3198 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3199 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3200 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3201 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3202 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE])__builtin_offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3203 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3204 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3205 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3206 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3207 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3208 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3209 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3210 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3211 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3212 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3213 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3214 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3215 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3216 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3217 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3218 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3219 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3220 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3221 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3222 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3223 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3224 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3225 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3226 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3227 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3228 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3229 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3230 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3231 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3232 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3233 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3234 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3235 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3236 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3237 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3238 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3239 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG])__builtin_offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3240 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3241 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3242 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3243 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3244 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3245 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR])__builtin_offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3246 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR])__builtin_offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3247 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3248 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2])__builtin_offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3249 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0])__builtin_offsetof(CPUPPCState, spr[SPR_HID0]) },
3250
3251#elif defined(TARGET_SPARC)
3252 { "g0", offsetof(CPUSPARCState, gregs[0])__builtin_offsetof(CPUSPARCState, gregs[0]) },
3253 { "g1", offsetof(CPUSPARCState, gregs[1])__builtin_offsetof(CPUSPARCState, gregs[1]) },
3254 { "g2", offsetof(CPUSPARCState, gregs[2])__builtin_offsetof(CPUSPARCState, gregs[2]) },
3255 { "g3", offsetof(CPUSPARCState, gregs[3])__builtin_offsetof(CPUSPARCState, gregs[3]) },
3256 { "g4", offsetof(CPUSPARCState, gregs[4])__builtin_offsetof(CPUSPARCState, gregs[4]) },
3257 { "g5", offsetof(CPUSPARCState, gregs[5])__builtin_offsetof(CPUSPARCState, gregs[5]) },
3258 { "g6", offsetof(CPUSPARCState, gregs[6])__builtin_offsetof(CPUSPARCState, gregs[6]) },
3259 { "g7", offsetof(CPUSPARCState, gregs[7])__builtin_offsetof(CPUSPARCState, gregs[7]) },
3260 { "o0", 0, monitor_get_reg },
3261 { "o1", 1, monitor_get_reg },
3262 { "o2", 2, monitor_get_reg },
3263 { "o3", 3, monitor_get_reg },
3264 { "o4", 4, monitor_get_reg },
3265 { "o5", 5, monitor_get_reg },
3266 { "o6", 6, monitor_get_reg },
3267 { "o7", 7, monitor_get_reg },
3268 { "l0", 8, monitor_get_reg },
3269 { "l1", 9, monitor_get_reg },
3270 { "l2", 10, monitor_get_reg },
3271 { "l3", 11, monitor_get_reg },
3272 { "l4", 12, monitor_get_reg },
3273 { "l5", 13, monitor_get_reg },
3274 { "l6", 14, monitor_get_reg },
3275 { "l7", 15, monitor_get_reg },
3276 { "i0", 16, monitor_get_reg },
3277 { "i1", 17, monitor_get_reg },
3278 { "i2", 18, monitor_get_reg },
3279 { "i3", 19, monitor_get_reg },
3280 { "i4", 20, monitor_get_reg },
3281 { "i5", 21, monitor_get_reg },
3282 { "i6", 22, monitor_get_reg },
3283 { "i7", 23, monitor_get_reg },
3284 { "pc", offsetof(CPUSPARCState, pc)__builtin_offsetof(CPUSPARCState, pc) },
3285 { "npc", offsetof(CPUSPARCState, npc)__builtin_offsetof(CPUSPARCState, npc) },
3286 { "y", offsetof(CPUSPARCState, y)__builtin_offsetof(CPUSPARCState, y) },
3287#ifndef TARGET_SPARC64
3288 { "psr", 0, &monitor_get_psr, },
3289 { "wim", offsetof(CPUSPARCState, wim)__builtin_offsetof(CPUSPARCState, wim) },
3290#endif
3291 { "tbr", offsetof(CPUSPARCState, tbr)__builtin_offsetof(CPUSPARCState, tbr) },
3292 { "fsr", offsetof(CPUSPARCState, fsr)__builtin_offsetof(CPUSPARCState, fsr) },
3293 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper)__builtin_offsetof(CPUSPARCState, fpr[0].l.upper) },
3294 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower)__builtin_offsetof(CPUSPARCState, fpr[0].l.lower) },
3295 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper)__builtin_offsetof(CPUSPARCState, fpr[1].l.upper) },
3296 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower)__builtin_offsetof(CPUSPARCState, fpr[1].l.lower) },
3297 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper)__builtin_offsetof(CPUSPARCState, fpr[2].l.upper) },
3298 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower)__builtin_offsetof(CPUSPARCState, fpr[2].l.lower) },
3299 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper)__builtin_offsetof(CPUSPARCState, fpr[3].l.upper) },
3300 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower)__builtin_offsetof(CPUSPARCState, fpr[3].l.lower) },
3301 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper)__builtin_offsetof(CPUSPARCState, fpr[4].l.upper) },
3302 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower)__builtin_offsetof(CPUSPARCState, fpr[4].l.lower) },
3303 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper)__builtin_offsetof(CPUSPARCState, fpr[5].l.upper) },
3304 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower)__builtin_offsetof(CPUSPARCState, fpr[5].l.lower) },
3305 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper)__builtin_offsetof(CPUSPARCState, fpr[6].l.upper) },
3306 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower)__builtin_offsetof(CPUSPARCState, fpr[6].l.lower) },
3307 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper)__builtin_offsetof(CPUSPARCState, fpr[7].l.upper) },
3308 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower)__builtin_offsetof(CPUSPARCState, fpr[7].l.lower) },
3309 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper)__builtin_offsetof(CPUSPARCState, fpr[8].l.upper) },
3310 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower)__builtin_offsetof(CPUSPARCState, fpr[8].l.lower) },
3311 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper)__builtin_offsetof(CPUSPARCState, fpr[9].l.upper) },
3312 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower)__builtin_offsetof(CPUSPARCState, fpr[9].l.lower) },
3313 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper)__builtin_offsetof(CPUSPARCState, fpr[10].l.upper) },
3314 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower)__builtin_offsetof(CPUSPARCState, fpr[10].l.lower) },
3315 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper)__builtin_offsetof(CPUSPARCState, fpr[11].l.upper) },
3316 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower)__builtin_offsetof(CPUSPARCState, fpr[11].l.lower) },
3317 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper)__builtin_offsetof(CPUSPARCState, fpr[12].l.upper) },
3318 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower)__builtin_offsetof(CPUSPARCState, fpr[12].l.lower) },
3319 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper)__builtin_offsetof(CPUSPARCState, fpr[13].l.upper) },
3320 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower)__builtin_offsetof(CPUSPARCState, fpr[13].l.lower) },
3321 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper)__builtin_offsetof(CPUSPARCState, fpr[14].l.upper) },
3322 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower)__builtin_offsetof(CPUSPARCState, fpr[14].l.lower) },
3323 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper)__builtin_offsetof(CPUSPARCState, fpr[15].l.upper) },
3324 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower)__builtin_offsetof(CPUSPARCState, fpr[15].l.lower) },
3325#ifdef TARGET_SPARC64
3326 { "f32", offsetof(CPUSPARCState, fpr[16])__builtin_offsetof(CPUSPARCState, fpr[16]) },
3327 { "f34", offsetof(CPUSPARCState, fpr[17])__builtin_offsetof(CPUSPARCState, fpr[17]) },
3328 { "f36", offsetof(CPUSPARCState, fpr[18])__builtin_offsetof(CPUSPARCState, fpr[18]) },
3329 { "f38", offsetof(CPUSPARCState, fpr[19])__builtin_offsetof(CPUSPARCState, fpr[19]) },
3330 { "f40", offsetof(CPUSPARCState, fpr[20])__builtin_offsetof(CPUSPARCState, fpr[20]) },
3331 { "f42", offsetof(CPUSPARCState, fpr[21])__builtin_offsetof(CPUSPARCState, fpr[21]) },
3332 { "f44", offsetof(CPUSPARCState, fpr[22])__builtin_offsetof(CPUSPARCState, fpr[22]) },
3333 { "f46", offsetof(CPUSPARCState, fpr[23])__builtin_offsetof(CPUSPARCState, fpr[23]) },
3334 { "f48", offsetof(CPUSPARCState, fpr[24])__builtin_offsetof(CPUSPARCState, fpr[24]) },
3335 { "f50", offsetof(CPUSPARCState, fpr[25])__builtin_offsetof(CPUSPARCState, fpr[25]) },
3336 { "f52", offsetof(CPUSPARCState, fpr[26])__builtin_offsetof(CPUSPARCState, fpr[26]) },
3337 { "f54", offsetof(CPUSPARCState, fpr[27])__builtin_offsetof(CPUSPARCState, fpr[27]) },
3338 { "f56", offsetof(CPUSPARCState, fpr[28])__builtin_offsetof(CPUSPARCState, fpr[28]) },
3339 { "f58", offsetof(CPUSPARCState, fpr[29])__builtin_offsetof(CPUSPARCState, fpr[29]) },
3340 { "f60", offsetof(CPUSPARCState, fpr[30])__builtin_offsetof(CPUSPARCState, fpr[30]) },
3341 { "f62", offsetof(CPUSPARCState, fpr[31])__builtin_offsetof(CPUSPARCState, fpr[31]) },
3342 { "asi", offsetof(CPUSPARCState, asi)__builtin_offsetof(CPUSPARCState, asi) },
3343 { "pstate", offsetof(CPUSPARCState, pstate)__builtin_offsetof(CPUSPARCState, pstate) },
3344 { "cansave", offsetof(CPUSPARCState, cansave)__builtin_offsetof(CPUSPARCState, cansave) },
3345 { "canrestore", offsetof(CPUSPARCState, canrestore)__builtin_offsetof(CPUSPARCState, canrestore) },
3346 { "otherwin", offsetof(CPUSPARCState, otherwin)__builtin_offsetof(CPUSPARCState, otherwin) },
3347 { "wstate", offsetof(CPUSPARCState, wstate)__builtin_offsetof(CPUSPARCState, wstate) },
3348 { "cleanwin", offsetof(CPUSPARCState, cleanwin)__builtin_offsetof(CPUSPARCState, cleanwin) },
3349 { "fprs", offsetof(CPUSPARCState, fprs)__builtin_offsetof(CPUSPARCState, fprs) },
3350#endif
3351#endif
3352 { NULL((void*)0) },
3353};
3354
3355static void GCC_FMT_ATTR(2, 3)__attribute__((format(printf, 2, 3))) QEMU_NORETURN__attribute__ ((__noreturn__))
3356expr_error(Monitor *mon, const char *fmt, ...)
3357{
3358 va_list ap;
3359 va_start(ap, fmt)__builtin_va_start(ap, fmt);
3360 monitor_vprintf(mon, fmt, ap);
3361 monitor_printf(mon, "\n");
3362 va_end(ap)__builtin_va_end(ap);
3363 siglongjmp(expr_env, 1);
3364}
3365
3366/* return 0 if OK, -1 if not found */
3367static int get_monitor_def(target_long *pval, const char *name)
3368{
3369 const MonitorDef *md;
3370 void *ptr;
3371
3372 for(md = monitor_defs; md->name != NULL((void*)0); md++) {
3373 if (compare_cmd(name, md->name)) {
3374 if (md->get_value) {
3375 *pval = md->get_value(md, md->offset);
3376 } else {
3377 CPUArchStatestruct CPUX86State *env = mon_get_cpu();
3378 ptr = (uint8_t *)env + md->offset;
3379 switch(md->type) {
3380 case MD_I321:
3381 *pval = *(int32_t *)ptr;
3382 break;
3383 case MD_TLONG0:
3384 *pval = *(target_long *)ptr;
3385 break;
3386 default:
3387 *pval = 0;
3388 break;
3389 }
3390 }
3391 return 0;
3392 }
3393 }
3394 return -1;
3395}
3396
3397static void next(void)
3398{
3399 if (*pch != '\0') {
3400 pch++;
3401 while (qemu_isspace(*pch)((*__ctype_b_loc ())[(int) (((unsigned char)(*pch)))] & (
unsigned short int) _ISspace)
)
3402 pch++;
3403 }
3404}
3405
3406static int64_t expr_sum(Monitor *mon);
3407
3408static int64_t expr_unary(Monitor *mon)
3409{
3410 int64_t n;
3411 char *p;
3412 int ret;
3413
3414 switch(*pch) {
3415 case '+':
3416 next();
3417 n = expr_unary(mon);
3418 break;
3419 case '-':
3420 next();
3421 n = -expr_unary(mon);
3422 break;
3423 case '~':
3424 next();
3425 n = ~expr_unary(mon);
3426 break;
3427 case '(':
3428 next();
3429 n = expr_sum(mon);
3430 if (*pch != ')') {
3431 expr_error(mon, "')' expected");
3432 }
3433 next();
3434 break;
3435 case '\'':
3436 pch++;
3437 if (*pch == '\0')
3438 expr_error(mon, "character constant expected");
3439 n = *pch;
3440 pch++;
3441 if (*pch != '\'')
3442 expr_error(mon, "missing terminating \' character");
3443 next();
3444 break;
3445 case '$':
3446 {
3447 char buf[128], *q;
3448 target_long reg=0;
3449
3450 pch++;
3451 q = buf;
3452 while ((*pch >= 'a' && *pch <= 'z') ||
3453 (*pch >= 'A' && *pch <= 'Z') ||
3454 (*pch >= '0' && *pch <= '9') ||
3455 *pch == '_' || *pch == '.') {
3456 if ((q - buf) < sizeof(buf) - 1)
3457 *q++ = *pch;
3458 pch++;
3459 }
3460 while (qemu_isspace(*pch)((*__ctype_b_loc ())[(int) (((unsigned char)(*pch)))] & (
unsigned short int) _ISspace)
)
3461 pch++;
3462 *q = 0;
3463 ret = get_monitor_def(&reg, buf);
3464 if (ret < 0)
3465 expr_error(mon, "unknown register");
3466 n = reg;
3467 }
3468 break;
3469 case '\0':
3470 expr_error(mon, "unexpected end of expression");
3471 n = 0;
3472 break;
3473 default:
3474 errno(*__errno_location ()) = 0;
3475 n = strtoull(pch, &p, 0);
3476 if (errno(*__errno_location ()) == ERANGE34) {
3477 expr_error(mon, "number too large");
3478 }
3479 if (pch == p) {
3480 expr_error(mon, "invalid char '%c' in expression", *p);
3481 }
3482 pch = p;
3483 while (qemu_isspace(*pch)((*__ctype_b_loc ())[(int) (((unsigned char)(*pch)))] & (
unsigned short int) _ISspace)
)
3484 pch++;
3485 break;
3486 }
3487 return n;
3488}
3489
3490
3491static int64_t expr_prod(Monitor *mon)
3492{
3493 int64_t val, val2;
3494 int op;
3495
3496 val = expr_unary(mon);
3497 for(;;) {
3498 op = *pch;
3499 if (op != '*' && op != '/' && op != '%')
3500 break;
3501 next();
3502 val2 = expr_unary(mon);
3503 switch(op) {
3504 default:
3505 case '*':
3506 val *= val2;
3507 break;
3508 case '/':
3509 case '%':
3510 if (val2 == 0)
3511 expr_error(mon, "division by zero");
3512 if (op == '/')
3513 val /= val2;
3514 else
3515 val %= val2;
3516 break;
3517 }
3518 }
3519 return val;
3520}
3521
3522static int64_t expr_logic(Monitor *mon)
3523{
3524 int64_t val, val2;
3525 int op;
3526
3527 val = expr_prod(mon);
3528 for(;;) {
3529 op = *pch;
3530 if (op != '&' && op != '|' && op != '^')
3531 break;
3532 next();
3533 val2 = expr_prod(mon);
3534 switch(op) {
3535 default:
3536 case '&':
3537 val &= val2;
3538 break;
3539 case '|':
3540 val |= val2;
3541 break;
3542 case '^':
3543 val ^= val2;
3544 break;
3545 }
3546 }
3547 return val;
3548}
3549
3550static int64_t expr_sum(Monitor *mon)
3551{
3552 int64_t val, val2;
3553 int op;
3554
3555 val = expr_logic(mon);
3556 for(;;) {
3557 op = *pch;
3558 if (op != '+' && op != '-')
3559 break;
3560 next();
3561 val2 = expr_logic(mon);
3562 if (op == '+')
3563 val += val2;
3564 else
3565 val -= val2;
3566 }
3567 return val;
3568}
3569
3570static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3571{
3572 pch = *pp;
3573 if (sigsetjmp(expr_env, 0)__sigsetjmp (expr_env, 0)) {
3574 *pp = pch;
3575 return -1;
3576 }
3577 while (qemu_isspace(*pch)((*__ctype_b_loc ())[(int) (((unsigned char)(*pch)))] & (
unsigned short int) _ISspace)
)
3578 pch++;
3579 *pval = expr_sum(mon);
3580 *pp = pch;
3581 return 0;
3582}
3583
3584static int get_double(Monitor *mon, double *pval, const char **pp)
3585{
3586 const char *p = *pp;
3587 char *tailp;
3588 double d;
3589
3590 d = strtod(p, &tailp);
3591 if (tailp == p) {
3592 monitor_printf(mon, "Number expected\n");
3593 return -1;
3594 }
3595 if (d != d || d - d != 0) {
3596 /* NaN or infinity */
3597 monitor_printf(mon, "Bad number\n");
3598 return -1;
3599 }
3600 *pval = d;
3601 *pp = tailp;
3602 return 0;
3603}
3604
3605/*
3606 * Store the command-name in cmdname, and return a pointer to
3607 * the remaining of the command string.
3608 */
3609static const char *get_command_name(const char *cmdline,
3610 char *cmdname, size_t nlen)
3611{
3612 size_t len;
3613 const char *p, *pstart;
3614
3615 p = cmdline;
3616 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3617 p++;
3618 if (*p == '\0')
3619 return NULL((void*)0);
3620 pstart = p;
3621 while (*p != '\0' && *p != '/' && !qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3622 p++;
3623 len = p - pstart;
3624 if (len > nlen - 1)
3625 len = nlen - 1;
3626 memcpy(cmdname, pstart, len);
3627 cmdname[len] = '\0';
3628 return p;
3629}
3630
3631/**
3632 * Read key of 'type' into 'key' and return the current
3633 * 'type' pointer.
3634 */
3635static char *key_get_info(const char *type, char **key)
3636{
3637 size_t len;
3638 char *p, *str;
3639
3640 if (*type == ',')
3641 type++;
3642
3643 p = strchr(type, ':');
3644 if (!p) {
3645 *key = NULL((void*)0);
3646 return NULL((void*)0);
3647 }
3648 len = p - type;
3649
3650 str = g_malloc(len + 1);
3651 memcpy(str, type, len);
3652 str[len] = '\0';
3653
3654 *key = str;
3655 return ++p;
3656}
3657
3658static int default_fmt_format = 'x';
3659static int default_fmt_size = 4;
3660
3661static int is_valid_option(const char *c, const char *typestr)
3662{
3663 char option[3];
3664
3665 option[0] = '-';
3666 option[1] = *c;
3667 option[2] = '\0';
3668
3669 typestr = strstr(typestr, option);
3670 return (typestr != NULL((void*)0));
3671}
3672
3673static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3674 const char *cmdname)
3675{
3676 const mon_cmd_t *cmd;
3677
3678 for (cmd = disp_table; cmd->name != NULL((void*)0); cmd++) {
3679 if (compare_cmd(cmdname, cmd->name)) {
3680 return cmd;
3681 }
3682 }
3683
3684 return NULL((void*)0);
3685}
3686
3687static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3688{
3689 return search_dispatch_table(qmp_cmds, cmdname);
3690}
3691
3692/*
3693 * Parse @cmdline according to command table @table.
3694 * If @cmdline is blank, return NULL.
3695 * If it can't be parsed, report to @mon, and return NULL.
3696 * Else, insert command arguments into @qdict, and return the command.
3697 * If a sub-command table exists, and if @cmdline contains an additional string
3698 * for a sub-command, this function will try to search the sub-command table.
3699 * If no additional string for a sub-command is present, this function will
3700 * return the command found in @table.
3701 * Do not assume the returned command points into @table! It doesn't
3702 * when the command is a sub-command.
3703 */
3704static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3705 const char *cmdline,
3706 int start,
3707 mon_cmd_t *table,
3708 QDict *qdict)
3709{
3710 const char *p, *typestr;
3711 int c;
3712 const mon_cmd_t *cmd;
3713 char cmdname[256];
3714 char buf[1024];
3715 char *key;
3716
3717#ifdef DEBUG
3718 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
3719#endif
3720
3721 /* extract the command name */
3722 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
3723 if (!p)
3724 return NULL((void*)0);
3725
3726 cmd = search_dispatch_table(table, cmdname);
3727 if (!cmd) {
3728 monitor_printf(mon, "unknown command: '%.*s'\n",
3729 (int)(p - cmdline), cmdline);
3730 return NULL((void*)0);
3731 }
3732
3733 /* filter out following useless space */
3734 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3735 p++;
3736 }
3737 /* search sub command */
3738 if (cmd->sub_table != NULL((void*)0)) {
3739 /* check if user set additional command */
3740 if (*p == '\0') {
3741 return cmd;
3742 }
3743 return monitor_parse_command(mon, cmdline, p - cmdline,
3744 cmd->sub_table, qdict);
3745 }
3746
3747 /* parse the parameters */
3748 typestr = cmd->args_type;
3749 for(;;) {
3750 typestr = key_get_info(typestr, &key);
3751 if (!typestr)
3752 break;
3753 c = *typestr;
3754 typestr++;
3755 switch(c) {
3756 case 'F':
3757 case 'B':
3758 case 's':
3759 {
3760 int ret;
3761
3762 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3763 p++;
3764 if (*typestr == '?') {
3765 typestr++;
3766 if (*p == '\0') {
3767 /* no optional string: NULL argument */
3768 break;
3769 }
3770 }
3771 ret = get_str(buf, sizeof(buf), &p);
3772 if (ret < 0) {
3773 switch(c) {
3774 case 'F':
3775 monitor_printf(mon, "%s: filename expected\n",
3776 cmdname);
3777 break;
3778 case 'B':
3779 monitor_printf(mon, "%s: block device name expected\n",
3780 cmdname);
3781 break;
3782 default:
3783 monitor_printf(mon, "%s: string expected\n", cmdname);
3784 break;
3785 }
3786 goto fail;
3787 }
3788 qdict_put(qdict, key, qstring_from_str(buf))qdict_put_obj(qdict, key, (&(qstring_from_str(buf))->base
))
;
3789 }
3790 break;
3791 case 'O':
3792 {
3793 QemuOptsList *opts_list;
3794 QemuOpts *opts;
3795
3796 opts_list = qemu_find_opts(key);
3797 if (!opts_list || opts_list->desc->name) {
3798 goto bad_type;
3799 }
3800 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3801 p++;
3802 }
3803 if (!*p)
3804 break;
3805 if (get_str(buf, sizeof(buf), &p) < 0) {
3806 goto fail;
3807 }
3808 opts = qemu_opts_parse(opts_list, buf, 1);
3809 if (!opts) {
3810 goto fail;
3811 }
3812 qemu_opts_to_qdict(opts, qdict);
3813 qemu_opts_del(opts);
3814 }
3815 break;
3816 case '/':
3817 {
3818 int count, format, size;
3819
3820 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3821 p++;
3822 if (*p == '/') {
3823 /* format found */
3824 p++;
3825 count = 1;
3826 if (qemu_isdigit(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISdigit)
) {
3827 count = 0;
3828 while (qemu_isdigit(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISdigit)
) {
3829 count = count * 10 + (*p - '0');
3830 p++;
3831 }
3832 }
3833 size = -1;
3834 format = -1;
3835 for(;;) {
3836 switch(*p) {
3837 case 'o':
3838 case 'd':
3839 case 'u':
3840 case 'x':
3841 case 'i':
3842 case 'c':
3843 format = *p++;
3844 break;
3845 case 'b':
3846 size = 1;
3847 p++;
3848 break;
3849 case 'h':
3850 size = 2;
3851 p++;
3852 break;
3853 case 'w':
3854 size = 4;
3855 p++;
3856 break;
3857 case 'g':
3858 case 'L':
3859 size = 8;
3860 p++;
3861 break;
3862 default:
3863 goto next;
3864 }
3865 }
3866 next:
3867 if (*p != '\0' && !qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3868 monitor_printf(mon, "invalid char in format: '%c'\n",
3869 *p);
3870 goto fail;
3871 }
3872 if (format < 0)
3873 format = default_fmt_format;
3874 if (format != 'i') {
3875 /* for 'i', not specifying a size gives -1 as size */
3876 if (size < 0)
3877 size = default_fmt_size;
3878 default_fmt_size = size;
3879 }
3880 default_fmt_format = format;
3881 } else {
3882 count = 1;
3883 format = default_fmt_format;
3884 if (format != 'i') {
3885 size = default_fmt_size;
3886 } else {
3887 size = -1;
3888 }
3889 }
3890 qdict_put(qdict, "count", qint_from_int(count))qdict_put_obj(qdict, "count", (&(qint_from_int(count))->
base))
;
3891 qdict_put(qdict, "format", qint_from_int(format))qdict_put_obj(qdict, "format", (&(qint_from_int(format))->
base))
;
3892 qdict_put(qdict, "size", qint_from_int(size))qdict_put_obj(qdict, "size", (&(qint_from_int(size))->
base))
;
3893 }
3894 break;
3895 case 'i':
3896 case 'l':
3897 case 'M':
3898 {
3899 int64_t val;
3900
3901 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3902 p++;
3903 if (*typestr == '?' || *typestr == '.') {
3904 if (*typestr == '?') {
3905 if (*p == '\0') {
3906 typestr++;
3907 break;
3908 }
3909 } else {
3910 if (*p == '.') {
3911 p++;
3912 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3913 p++;
3914 } else {
3915 typestr++;
3916 break;
3917 }
3918 }
3919 typestr++;
3920 }
3921 if (get_expr(mon, &val, &p))
3922 goto fail;
3923 /* Check if 'i' is greater than 32-bit */
3924 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3925 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3926 monitor_printf(mon, "integer is for 32-bit values\n");
3927 goto fail;
3928 } else if (c == 'M') {
3929 if (val < 0) {
3930 monitor_printf(mon, "enter a positive value\n");
3931 goto fail;
3932 }
3933 val <<= 20;
3934 }
3935 qdict_put(qdict, key, qint_from_int(val))qdict_put_obj(qdict, key, (&(qint_from_int(val))->base
))
;
3936 }
3937 break;
3938 case 'o':
3939 {
3940 int64_t val;
3941 char *end;
3942
3943 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3944 p++;
3945 }
3946 if (*typestr == '?') {
3947 typestr++;
3948 if (*p == '\0') {
3949 break;
3950 }
3951 }
3952 val = strtosz(p, &end);
3953 if (val < 0) {
3954 monitor_printf(mon, "invalid size\n");
3955 goto fail;
3956 }
3957 qdict_put(qdict, key, qint_from_int(val))qdict_put_obj(qdict, key, (&(qint_from_int(val))->base
))
;
3958 p = end;
3959 }
3960 break;
3961 case 'T':
3962 {
3963 double val;
3964
3965 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
3966 p++;
3967 if (*typestr == '?') {
3968 typestr++;
3969 if (*p == '\0') {
3970 break;
3971 }
3972 }
3973 if (get_double(mon, &val, &p) < 0) {
3974 goto fail;
3975 }
3976 if (p[0] && p[1] == 's') {
3977 switch (*p) {
3978 case 'm':
3979 val /= 1e3; p += 2; break;
3980 case 'u':
3981 val /= 1e6; p += 2; break;
3982 case 'n':
3983 val /= 1e9; p += 2; break;
3984 }
3985 }
3986 if (*p && !qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3987 monitor_printf(mon, "Unknown unit suffix\n");
3988 goto fail;
3989 }
3990 qdict_put(qdict, key, qfloat_from_double(val))qdict_put_obj(qdict, key, (&(qfloat_from_double(val))->
base))
;
3991 }
3992 break;
3993 case 'b':
3994 {
3995 const char *beg;
3996 int val;
3997
3998 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
3999 p++;
4000 }
4001 beg = p;
4002 while (qemu_isgraph(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISgraph)
) {
4003 p++;
4004 }
4005 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4006 val = 1;
4007 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4008 val = 0;
4009 } else {
4010 monitor_printf(mon, "Expected 'on' or 'off'\n");
4011 goto fail;
4012 }
4013 qdict_put(qdict, key, qbool_from_int(val))qdict_put_obj(qdict, key, (&(qbool_from_int(val))->base
))
;
4014 }
4015 break;
4016 case '-':
4017 {
4018 const char *tmp = p;
4019 int skip_key = 0;
4020 /* option */
4021
4022 c = *typestr++;
4023 if (c == '\0')
4024 goto bad_type;
4025 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
4026 p++;
4027 if (*p == '-') {
4028 p++;
4029 if(c != *p) {
4030 if(!is_valid_option(p, typestr)) {
4031
4032 monitor_printf(mon, "%s: unsupported option -%c\n",
4033 cmdname, *p);
4034 goto fail;
4035 } else {
4036 skip_key = 1;
4037 }
4038 }
4039 if(skip_key) {
4040 p = tmp;
4041 } else {
4042 /* has option */
4043 p++;
4044 qdict_put(qdict, key, qbool_from_int(1))qdict_put_obj(qdict, key, (&(qbool_from_int(1))->base)
)
;
4045 }
4046 }
4047 }
4048 break;
4049 case 'S':
4050 {
4051 /* package all remaining string */
4052 int len;
4053
4054 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
) {
4055 p++;
4056 }
4057 if (*typestr == '?') {
4058 typestr++;
4059 if (*p == '\0') {
4060 /* no remaining string: NULL argument */
4061 break;
4062 }
4063 }
4064 len = strlen(p);
4065 if (len <= 0) {
4066 monitor_printf(mon, "%s: string expected\n",
4067 cmdname);
4068 break;
4069 }
4070 qdict_put(qdict, key, qstring_from_str(p))qdict_put_obj(qdict, key, (&(qstring_from_str(p))->base
))
;
4071 p += len;
4072 }
4073 break;
4074 default:
4075 bad_type:
4076 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
4077 goto fail;
4078 }
4079 g_free(key);
4080 key = NULL((void*)0);
4081 }
4082 /* check that all arguments were parsed */
4083 while (qemu_isspace(*p)((*__ctype_b_loc ())[(int) (((unsigned char)(*p)))] & (unsigned
short int) _ISspace)
)
4084 p++;
4085 if (*p != '\0') {
4086 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4087 cmdname);
4088 goto fail;
4089 }
4090
4091 return cmd;
4092
4093fail:
4094 g_free(key);
4095 return NULL((void*)0);
4096}
4097
4098void monitor_set_error(Monitor *mon, QError *qerror)
4099{
4100 /* report only the first error */
4101 if (!mon->error) {
4102 mon->error = qerror;
4103 } else {
4104 QDECREF(qerror)qobject_decref(qerror ? (&(qerror)->base) : ((void*)0)
)
;
4105 }
4106}
4107
4108static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4109{
4110 if (ret && !monitor_has_error(mon)) {
4111 /*
4112 * If it returns failure, it must have passed on error.
4113 *
4114 * Action: Report an internal error to the client if in QMP.
4115 */
4116 qerror_report(QERR_UNDEFINED_ERRORERROR_CLASS_GENERIC_ERROR, "An undefined error has occurred");
4117 }
4118}
4119
4120static void handle_user_command(Monitor *mon, const char *cmdline)
4121{
4122 QDict *qdict;
4123 const mon_cmd_t *cmd;
4124
4125 qdict = qdict_new();
4126
4127 cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
4128 if (!cmd)
4129 goto out;
4130
4131 if (handler_is_async(cmd)) {
4132 user_async_cmd_handler(mon, cmd, qdict);
4133 } else if (handler_is_qobject(cmd)) {
4134 QObject *data = NULL((void*)0);
4135
4136 /* XXX: ignores the error code */
4137 cmd->mhandler.cmd_new(mon, qdict, &data);
4138 assert(!monitor_has_error(mon))((!monitor_has_error(mon)) ? (void) (0) : __assert_fail ("!monitor_has_error(mon)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4138, __PRETTY_FUNCTION__
))
;
4139 if (data) {
4140 cmd->user_print(mon, data);
4141 qobject_decref(data);
4142 }
4143 } else {
4144 cmd->mhandler.cmd(mon, qdict);
4145 }
4146
4147out:
4148 QDECREF(qdict)qobject_decref(qdict ? (&(qdict)->base) : ((void*)0));
4149}
4150
4151static void cmd_completion(Monitor *mon, const char *name, const char *list)
4152{
4153 const char *p, *pstart;
4154 char cmd[128];
4155 int len;
4156
4157 p = list;
4158 for(;;) {
4159 pstart = p;
4160 p = strchr(p, '|');
4161 if (!p)
4162 p = pstart + strlen(pstart);
4163 len = p - pstart;
4164 if (len > sizeof(cmd) - 2)
4165 len = sizeof(cmd) - 2;
4166 memcpy(cmd, pstart, len);
4167 cmd[len] = '\0';
4168 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
4169 readline_add_completion(mon->rs, cmd);
4170 }
4171 if (*p == '\0')
4172 break;
4173 p++;
4174 }
4175}
4176
4177static void file_completion(Monitor *mon, const char *input)
4178{
4179 DIR *ffs;
4180 struct dirent *d;
4181 char path[1024];
4182 char file[1024], file_prefix[1024];
4183 int input_path_len;
4184 const char *p;
4185
4186 p = strrchr(input, '/');
4187 if (!p) {
4188 input_path_len = 0;
4189 pstrcpy(file_prefix, sizeof(file_prefix), input);
4190 pstrcpy(path, sizeof(path), ".");
4191 } else {
4192 input_path_len = p - input + 1;
4193 memcpy(path, input, input_path_len);
4194 if (input_path_len > sizeof(path) - 1)
4195 input_path_len = sizeof(path) - 1;
4196 path[input_path_len] = '\0';
4197 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4198 }
4199#ifdef DEBUG_COMPLETION
4200 monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
4201 input, path, file_prefix);
4202#endif
4203 ffs = opendir(path);
4204 if (!ffs)
4205 return;
4206 for(;;) {
4207 struct stat sb;
4208 d = readdir(ffs);
4209 if (!d)
4210 break;
4211
4212 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4213 continue;
4214 }
4215
4216 if (strstart(d->d_name, file_prefix, NULL((void*)0))) {
4217 memcpy(file, input, input_path_len);
4218 if (input_path_len < sizeof(file))
4219 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4220 d->d_name);
4221 /* stat the file to find out if it's a directory.
4222 * In that case add a slash to speed up typing long paths
4223 */
4224 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)((((sb.st_mode)) & 0170000) == (0040000))) {
4225 pstrcat(file, sizeof(file), "/");
4226 }
4227 readline_add_completion(mon->rs, file);
4228 }
4229 }
4230 closedir(ffs);
4231}
4232
4233typedef struct MonitorBlockComplete {
4234 Monitor *mon;
4235 const char *input;
4236} MonitorBlockComplete;
4237
4238static void block_completion_it(void *opaque, BlockDriverState *bs)
4239{
4240 const char *name = bdrv_get_device_name(bs);
4241 MonitorBlockComplete *mbc = opaque;
4242 Monitor *mon = mbc->mon;
4243 const char *input = mbc->input;
4244
4245 if (input[0] == '\0' ||
4246 !strncmp(name, (char *)input, strlen(input))) {
4247 readline_add_completion(mon->rs, name);
4248 }
4249}
4250
4251static const char *next_arg_type(const char *typestr)
4252{
4253 const char *p = strchr(typestr, ':');
4254 return (p != NULL((void*)0) ? ++p : typestr);
4255}
4256
4257static void monitor_find_completion_by_table(Monitor *mon,
4258 const mon_cmd_t *cmd_table,
4259 char **args,
4260 int nb_args)
4261{
4262 const char *cmdname;
4263 int i;
4264 const char *ptype, *str;
4265 const mon_cmd_t *cmd;
4266 MonitorBlockComplete mbs;
4267
4268 if (nb_args <= 1) {
4269 /* command completion */
4270 if (nb_args == 0)
4271 cmdname = "";
4272 else
4273 cmdname = args[0];
4274 readline_set_completion_index(mon->rs, strlen(cmdname));
4275 for (cmd = cmd_table; cmd->name != NULL((void*)0); cmd++) {
4276 cmd_completion(mon, cmdname, cmd->name);
4277 }
4278 } else {
4279 /* find the command */
4280 for (cmd = cmd_table; cmd->name != NULL((void*)0); cmd++) {
4281 if (compare_cmd(args[0], cmd->name)) {
4282 break;
4283 }
4284 }
4285 if (!cmd->name) {
4286 return;
4287 }
4288
4289 if (cmd->sub_table) {
4290 /* do the job again */
4291 return monitor_find_completion_by_table(mon, cmd->sub_table,
4292 &args[1], nb_args - 1);
4293 }
4294
4295 ptype = next_arg_type(cmd->args_type);
4296 for(i = 0; i < nb_args - 2; i++) {
4297 if (*ptype != '\0') {
4298 ptype = next_arg_type(ptype);
4299 while (*ptype == '?')
4300 ptype = next_arg_type(ptype);
4301 }
4302 }
4303 str = args[nb_args - 1];
4304 if (*ptype == '-' && ptype[1] != '\0') {
4305 ptype = next_arg_type(ptype);
4306 }
4307 switch(*ptype) {
4308 case 'F':
4309 /* file completion */
4310 readline_set_completion_index(mon->rs, strlen(str));
4311 file_completion(mon, str);
4312 break;
4313 case 'B':
4314 /* block device name completion */
4315 mbs.mon = mon;
4316 mbs.input = str;
4317 readline_set_completion_index(mon->rs, strlen(str));
4318 bdrv_iterate(block_completion_it, &mbs);
4319 break;
4320 case 's':
4321 case 'S':
4322 if (!strcmp(cmd->name, "sendkey")) {
4323 char *sep = strrchr(str, '-');
4324 if (sep)
4325 str = sep + 1;
4326 readline_set_completion_index(mon->rs, strlen(str));
4327 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4328 cmd_completion(mon, str, QKeyCode_lookup[i]);
4329 }
4330 } else if (!strcmp(cmd->name, "help|?")) {
4331 monitor_find_completion_by_table(mon, cmd_table,
4332 &args[1], nb_args - 1);
4333 }
4334 break;
4335 default:
4336 break;
4337 }
4338 }
4339}
4340
4341static void monitor_find_completion(Monitor *mon,
4342 const char *cmdline)
4343{
4344 char *args[MAX_ARGS16];
4345 int nb_args, len;
4346
4347 /* 1. parse the cmdline */
4348 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4349 return;
4350 }
4351#ifdef DEBUG_COMPLETION
4352 for (i = 0; i < nb_args; i++) {
4353 monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4354 }
4355#endif
4356
4357 /* if the line ends with a space, it means we want to complete the
4358 next arg */
4359 len = strlen(cmdline);
4360 if (len > 0 && qemu_isspace(cmdline[len - 1])((*__ctype_b_loc ())[(int) (((unsigned char)(cmdline[len - 1]
)))] & (unsigned short int) _ISspace)
) {
4361 if (nb_args >= MAX_ARGS16) {
4362 goto cleanup;
4363 }
4364 args[nb_args++] = g_strdup("");
4365 }
4366
4367 /* 2. auto complete according to args */
4368 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4369
4370cleanup:
4371 free_cmdline_args(args, nb_args);
4372}
4373
4374static int monitor_can_read(void *opaque)
4375{
4376 Monitor *mon = opaque;
4377
4378 return (mon->suspend_cnt == 0) ? 1 : 0;
4379}
4380
4381static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4382{
4383 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4384 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4385}
4386
4387/*
4388 * Argument validation rules:
4389 *
4390 * 1. The argument must exist in cmd_args qdict
4391 * 2. The argument type must be the expected one
4392 *
4393 * Special case: If the argument doesn't exist in cmd_args and
4394 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4395 * checking is skipped for it.
4396 */
4397static int check_client_args_type(const QDict *client_args,
4398 const QDict *cmd_args, int flags)
4399{
4400 const QDictEntry *ent;
4401
4402 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4403 QObject *obj;
4404 QString *arg_type;
4405 const QObject *client_arg = qdict_entry_value(ent);
4406 const char *client_arg_name = qdict_entry_key(ent);
4407
4408 obj = qdict_get(cmd_args, client_arg_name);
4409 if (!obj) {
4410 if (flags & QMP_ACCEPT_UNKNOWNS1) {
4411 /* handler accepts unknowns */
4412 continue;
4413 }
4414 /* client arg doesn't exist */
4415 qerror_report(QERR_INVALID_PARAMETERERROR_CLASS_GENERIC_ERROR, "Invalid parameter '%s'", client_arg_name);
4416 return -1;
4417 }
4418
4419 arg_type = qobject_to_qstring(obj);
4420 assert(arg_type != NULL)((arg_type != ((void*)0)) ? (void) (0) : __assert_fail ("arg_type != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4420, __PRETTY_FUNCTION__
))
;
4421
4422 /* check if argument's type is correct */
4423 switch (qstring_get_str(arg_type)[0]) {
4424 case 'F':
4425 case 'B':
4426 case 's':
4427 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4428 qerror_report(QERR_INVALID_PARAMETER_TYPEERROR_CLASS_GENERIC_ERROR, "Invalid parameter type for '%s', expected: %s", client_arg_name,
4429 "string");
4430 return -1;
4431 }
4432 break;
4433 case 'i':
4434 case 'l':
4435 case 'M':
4436 case 'o':
4437 if (qobject_type(client_arg) != QTYPE_QINT) {
4438 qerror_report(QERR_INVALID_PARAMETER_TYPEERROR_CLASS_GENERIC_ERROR, "Invalid parameter type for '%s', expected: %s", client_arg_name,
4439 "int");
4440 return -1;
4441 }
4442 break;
4443 case 'T':
4444 if (qobject_type(client_arg) != QTYPE_QINT &&
4445 qobject_type(client_arg) != QTYPE_QFLOAT) {
4446 qerror_report(QERR_INVALID_PARAMETER_TYPEERROR_CLASS_GENERIC_ERROR, "Invalid parameter type for '%s', expected: %s", client_arg_name,
4447 "number");
4448 return -1;
4449 }
4450 break;
4451 case 'b':
4452 case '-':
4453 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4454 qerror_report(QERR_INVALID_PARAMETER_TYPEERROR_CLASS_GENERIC_ERROR, "Invalid parameter type for '%s', expected: %s", client_arg_name,
4455 "bool");
4456 return -1;
4457 }
4458 break;
4459 case 'O':
4460 assert(flags & QMP_ACCEPT_UNKNOWNS)((flags & 1) ? (void) (0) : __assert_fail ("flags & 1"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4460, __PRETTY_FUNCTION__
))
;
4461 break;
4462 case 'q':
4463 /* Any QObject can be passed. */
4464 break;
4465 case '/':
4466 case '.':
4467 /*
4468 * These types are not supported by QMP and thus are not
4469 * handled here. Fall through.
4470 */
4471 default:
4472 abort();
4473 }
4474 }
4475
4476 return 0;
4477}
4478
4479/*
4480 * - Check if the client has passed all mandatory args
4481 * - Set special flags for argument validation
4482 */
4483static int check_mandatory_args(const QDict *cmd_args,
4484 const QDict *client_args, int *flags)
4485{
4486 const QDictEntry *ent;
4487
4488 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4489 const char *cmd_arg_name = qdict_entry_key(ent);
4490 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4491 assert(type != NULL)((type != ((void*)0)) ? (void) (0) : __assert_fail ("type != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4491, __PRETTY_FUNCTION__
))
;
4492
4493 if (qstring_get_str(type)[0] == 'O') {
4494 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0)(((*flags & 1) == 0) ? (void) (0) : __assert_fail ("(*flags & 1) == 0"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4494, __PRETTY_FUNCTION__
))
;
4495 *flags |= QMP_ACCEPT_UNKNOWNS1;
4496 } else if (qstring_get_str(type)[0] != '-' &&
4497 qstring_get_str(type)[1] != '?' &&
4498 !qdict_haskey(client_args, cmd_arg_name)) {
4499 qerror_report(QERR_MISSING_PARAMETERERROR_CLASS_GENERIC_ERROR, "Parameter '%s' is missing", cmd_arg_name);
4500 return -1;
4501 }
4502 }
4503
4504 return 0;
4505}
4506
4507static QDict *qdict_from_args_type(const char *args_type)
4508{
4509 int i;
4510 QDict *qdict;
4511 QString *key, *type, *cur_qs;
4512
4513 assert(args_type != NULL)((args_type != ((void*)0)) ? (void) (0) : __assert_fail ("args_type != ((void*)0)"
, "/home/stefan/src/qemu/qemu.org/qemu/monitor.c", 4513, __PRETTY_FUNCTION__
))
;
4514
4515 qdict = qdict_new();
4516
4517 if (args_type == NULL((void*)0) || args_type[0] == '\0') {
4518 /* no args, empty qdict */
4519 goto out;
4520 }
4521
4522 key = qstring_new();
4523 type = qstring_new();
4524
4525 cur_qs = key;
4526
4527 for (i = 0;; i++) {
4528 switch (args_type[i]) {
4529 case ',':
4530 case '\0':
4531 qdict_put(qdict, qstring_get_str(key), type)qdict_put_obj(qdict, qstring_get_str(key), (&(type)->base
))
;
4532 QDECREF(key)qobject_decref(key ? (&(key)->base) : ((void*)0));
4533 if (args_type[i] == '\0') {
4534 goto out;
4535 }
4536 type = qstring_new(); /* qdict has ref */
4537 cur_qs = key = qstring_new();
4538 break;
4539 case ':':
4540 cur_qs = type;
4541 break;
4542 default:
4543 qstring_append_chr(cur_qs, args_type[i]);
4544 break;
4545 }
4546 }
4547
4548out:
4549 return qdict;
4550}
4551
4552/*
4553 * Client argument checking rules:
4554 *
4555 * 1. Client must provide all mandatory arguments
4556 * 2. Each argument provided by the client must be expected
4557 * 3. Each argument provided by the client must have the type expected
4558 * by the command
4559 */
4560static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4561{
4562 int flags, err;
4563 QDict *cmd_args;
4564
4565 cmd_args = qdict_from_args_type(cmd->args_type);
4566
4567 flags = 0;
4568 err = check_mandatory_args(cmd_args, client_args, &flags);
4569 if (err) {
4570 goto out;
4571 }
4572
4573 err = check_client_args_type(client_args, cmd_args, flags);
4574
4575out:
4576 QDECREF(cmd_args)qobject_decref(cmd_args ? (&(cmd_args)->base) : ((void
*)0))
;
4577 return err;
4578}
4579
4580/*
4581 * Input object checking rules
4582 *
4583 * 1. Input object must be a dict
4584 * 2. The "execute" key must exist
4585 * 3. The "execute" key must be a string
4586 * 4. If the "arguments" key exists, it must be a dict
4587 * 5. If the "id" key exists, it can be anything (ie. json-value)
4588 * 6. Any argument not listed above is considered invalid
4589 */
4590static QDict *qmp_check_input_obj(QObject *input_obj)
4591{
4592 const QDictEntry *ent;
4593 int has_exec_key = 0;
4594 QDict *input_dict;
4595
4596 if (qobject_type(input_obj) != QTYPE_QDICT) {
4597 qerror_report(QERR_QMP_BAD_INPUT_OBJECTERROR_CLASS_GENERIC_ERROR, "Expected '%s' in QMP input", "object");
4598 return NULL((void*)0);
4599 }
4600
4601 input_dict = qobject_to_qdict(input_obj);
4602
4603 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4604 const char *arg_name = qdict_entry_key(ent);
4605 const QObject *arg_obj = qdict_entry_value(ent);
4606
4607 if (!strcmp(arg_name, "execute")) {
4608 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4609 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBERERROR_CLASS_GENERIC_ERROR, "QMP input object member '%s' expects '%s'", "execute",
4610 "string");
4611 return NULL((void*)0);
4612 }
4613 has_exec_key = 1;
4614 } else if (!strcmp(arg_name, "arguments")) {
4615 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4616 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBERERROR_CLASS_GENERIC_ERROR, "QMP input object member '%s' expects '%s'", "arguments",
4617 "object");
4618 return NULL((void*)0);
4619 }
4620 } else if (!strcmp(arg_name, "id")) {
4621 /* FIXME: check duplicated IDs for async commands */
4622 } else {
4623 qerror_report(QERR_QMP_EXTRA_MEMBERERROR_CLASS_GENERIC_ERROR, "QMP input object member '%s' is unexpected", arg_name);
4624 return NULL((void*)0);
4625 }
4626 }
4627
4628 if (!has_exec_key) {
4629 qerror_report(QERR_QMP_BAD_INPUT_OBJECTERROR_CLASS_GENERIC_ERROR, "Expected '%s' in QMP input", "execute");
4630 return NULL((void*)0);
4631 }
4632
4633 return input_dict;
4634}
4635
4636static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4637 const QDict *params)
4638{
4639 int ret;
4640 QObject *data = NULL((void*)0);
4641
4642 ret = cmd->mhandler.cmd_new(mon, params, &data);
4643 handler_audit(mon, cmd, ret);
4644 monitor_protocol_emitter(mon, data);
4645 qobject_decref(data);
4646}
4647
4648static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4649{
4650 int err;
4651 QObject *obj;
4652 QDict *input, *args;
4653 const mon_cmd_t *cmd;
4654 const char *cmd_name;
4655 Monitor *mon = cur_mon;
4656
4657 args = input = NULL((void*)0);
4658
4659 obj = json_parser_parse(tokens, NULL((void*)0));
4660 if (!obj) {
4661 // FIXME: should be triggered in json_parser_parse()
4662 qerror_report(QERR_JSON_PARSINGERROR_CLASS_GENERIC_ERROR, "Invalid JSON syntax");
4663 goto err_out;
4664 }
4665
4666 input = qmp_check_input_obj(obj);
4667 if (!input) {
4668 qobject_decref(obj);
4669 goto err_out;
4670 }
4671
4672 mon->mc->id = qdict_get(input, "id");
4673 qobject_incref(mon->mc->id);
4674
4675 cmd_name = qdict_get_str(input, "execute");
4676 trace_handle_qmp_command(mon, cmd_name);
4677 if (invalid_qmp_mode(mon, cmd_name)) {
4678 qerror_report(QERR_COMMAND_NOT_FOUNDERROR_CLASS_COMMAND_NOT_FOUND, "The command %s has not been found", cmd_name);
4679 goto err_out;
4680 }
4681
4682 cmd = qmp_find_cmd(cmd_name);
4683 if (!cmd) {
4684 qerror_report(QERR_COMMAND_NOT_FOUNDERROR_CLASS_COMMAND_NOT_FOUND, "The command %s has not been found", cmd_name);
4685 goto err_out;
4686 }
4687
4688 obj = qdict_get(input, "arguments");
4689 if (!obj) {
4690 args = qdict_new();
4691 } else {
4692 args = qobject_to_qdict(obj);
4693 QINCREF(args)qobject_incref((&(args)->base));
4694 }
4695
4696 err = qmp_check_client_args(cmd, args);
4697 if (err < 0) {
4698 goto err_out;
4699 }
4700
4701 if (handler_is_async(cmd)) {
4702 err = qmp_async_cmd_handler(mon, cmd, args);
4703 if (err) {
4704 /* emit the error response */
4705 goto err_out;
4706 }
4707 } else {
4708 qmp_call_cmd(mon, cmd, args);
4709 }
4710
4711 goto out;
4712
4713err_out:
4714 monitor_protocol_emitter(mon, NULL((void*)0));
4715out:
4716 QDECREF(input)qobject_decref(input ? (&(input)->base) : ((void*)0));
4717 QDECREF(args)qobject_decref(args ? (&(args)->base) : ((void*)0));
4718}
4719
4720/**
4721 * monitor_control_read(): Read and handle QMP input
4722 */
4723static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4724{
4725 Monitor *old_mon = cur_mon;
4726
4727 cur_mon = opaque;
4728
4729 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4730
4731 cur_mon = old_mon;
4732}
4733
4734static void monitor_read(void *opaque, const uint8_t *buf, int size)
4735{
4736 Monitor *old_mon = cur_mon;
4737 int i;
4738
4739 cur_mon = opaque;
4740
4741 if (cur_mon->rs) {
4742 for (i = 0; i < size; i++)
4743 readline_handle_byte(cur_mon->rs, buf[i]);
4744 } else {
4745 if (size == 0 || buf[size - 1] != 0)
4746 monitor_printf(cur_mon, "corrupted command\n");
4747 else
4748 handle_user_command(cur_mon, (char *)buf);
4749 }
4750
4751 cur_mon = old_mon;
4752}
4753
4754static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4755{
4756 monitor_suspend(mon);
4757 handle_user_command(mon, cmdline);
4758 monitor_resume(mon);
4759}
4760
4761int monitor_suspend(Monitor *mon)
4762{
4763 if (!mon->rs)
4764 return -ENOTTY25;
4765 mon->suspend_cnt++;
4766 return 0;
4767}
4768
4769void monitor_resume(Monitor *mon)
4770{
4771 if (!mon->rs)
4772 return;
4773 if (--mon->suspend_cnt == 0)
4774 readline_show_prompt(mon->rs);
4775}
4776
4777static QObject *get_qmp_greeting(void)
4778{
4779 QObject *ver = NULL((void*)0);
4780
4781 qmp_marshal_input_query_version(NULL((void*)0), NULL((void*)0), &ver);
4782 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4783}
4784
4785/**
4786 * monitor_control_event(): Print QMP gretting
4787 */
4788static void monitor_control_event(void *opaque, int event)
4789{
4790 QObject *data;
4791 Monitor *mon = opaque;
4792
4793 switch (event) {
4794 case CHR_EVENT_OPENED2:
4795 mon->mc->command_mode = 0;
4796 data = get_qmp_greeting();
4797 monitor_json_emitter(mon, data);
4798 qobject_decref(data);
4799 mon_refcount++;
4800 break;
4801 case CHR_EVENT_CLOSED5:
4802 json_message_parser_destroy(&mon->mc->parser);
4803 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4804 mon_refcount--;
4805 monitor_fdsets_cleanup();
4806 break;
4807 }
4808}
4809
4810static void monitor_event(void *opaque, int event)
4811{
4812 Monitor *mon = opaque;
4813
4814 switch (event) {
4815 case CHR_EVENT_MUX_IN3:
4816 mon->mux_out = 0;
4817 if (mon->reset_seen) {
4818 readline_restart(mon->rs);
4819 monitor_resume(mon);
4820 monitor_flush(mon);
4821 } else {
4822 mon->suspend_cnt = 0;
4823 }
4824 break;
4825
4826 case CHR_EVENT_MUX_OUT4:
4827 if (mon->reset_seen) {
4828 if (mon->suspend_cnt == 0) {
4829 monitor_printf(mon, "\n");
4830 }
4831 monitor_flush(mon);
4832 monitor_suspend(mon);
4833 } else {
4834 mon->suspend_cnt++;
4835 }
4836 mon->mux_out = 1;
4837 break;
4838
4839 case CHR_EVENT_OPENED2:
4840 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4841 "information\n", QEMU_VERSION"1.7.50");
4842 if (!mon->mux_out) {
4843 readline_show_prompt(mon->rs);
4844 }
4845 mon->reset_seen = 1;
4846 mon_refcount++;
4847 break;
4848
4849 case CHR_EVENT_CLOSED5:
4850 mon_refcount--;
4851 monitor_fdsets_cleanup();
4852 break;
4853 }
4854}
4855
4856static int
4857compare_mon_cmd(const void *a, const void *b)
4858{
4859 return strcmp(((const mon_cmd_t *)a)->name,
4860 ((const mon_cmd_t *)b)->name);
4861}
4862
4863static void sortcmdlist(void)
4864{
4865 int array_num;
4866 int elem_size = sizeof(mon_cmd_t);
4867
4868 array_num = sizeof(mon_cmds)/elem_size-1;
4869 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4870
4871 array_num = sizeof(info_cmds)/elem_size-1;
4872 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4873}
4874
4875
4876/*
4877 * Local variables:
4878 * c-indent-level: 4
4879 * c-basic-offset: 4
4880 * tab-width: 8
4881 * End:
4882 */
4883
4884void monitor_init(CharDriverState *chr, int flags)
4885{
4886 static int is_first_init = 1;
4887 Monitor *mon;
4888
4889 if (is_first_init) {
4890 monitor_protocol_event_init();
4891 sortcmdlist();
4892 is_first_init = 0;
4893 }
4894
4895 mon = g_malloc(sizeof(*mon));
4896 monitor_data_init(mon);
4897
4898 mon->chr = chr;
4899 mon->flags = flags;
4900 if (flags & MONITOR_USE_READLINE0x02) {
4901 mon->rs = readline_init(mon, monitor_find_completion);
4902 monitor_read_command(mon, 0);
4903 }
4904
4905 if (monitor_ctrl_mode(mon)) {
4906 mon->mc = g_malloc0(sizeof(MonitorControl));
4907 /* Control mode requires special handlers */
4908 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4909 monitor_control_event, mon);
4910 qemu_chr_fe_set_echo(chr, true1);
4911
4912 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4913 } else {
4914 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4915 monitor_event, mon);
4916 }
4917
4918 QLIST_INSERT_HEAD(&mon_list, mon, entry)do { if (((mon)->entry.le_next = (&mon_list)->lh_first
) != ((void*)0)) (&mon_list)->lh_first->entry.le_prev
= &(mon)->entry.le_next; (&mon_list)->lh_first
= (mon); (mon)->entry.le_prev = &(&mon_list)->
lh_first; } while ( 0)
;
4919 if (!default_mon || (flags & MONITOR_IS_DEFAULT0x01))
4920 default_mon = mon;
4921}
4922
4923static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4924{
4925 BlockDriverState *bs = opaque;
4926 int ret = 0;
4927
4928 if (bdrv_set_key(bs, password) != 0) {
4929 monitor_printf(mon, "invalid password\n");
4930 ret = -EPERM1;
4931 }
4932 if (mon->password_completion_cb)
4933 mon->password_completion_cb(mon->password_opaque, ret);
4934
4935 monitor_read_command(mon, 1);
4936}
4937
4938ReadLineState *monitor_get_rs(Monitor *mon)
4939{
4940 return mon->rs;
4941}
4942
4943int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4944 BlockDriverCompletionFunc *completion_cb,
4945 void *opaque)
4946{
4947 int err;
4948
4949 if (!bdrv_key_required(bs)) {
4950 if (completion_cb)
4951 completion_cb(opaque, 0);
4952 return 0;
4953 }
4954
4955 if (monitor_ctrl_mode(mon)) {
4956 qerror_report(QERR_DEVICE_ENCRYPTEDERROR_CLASS_DEVICE_ENCRYPTED, "'%s' (%s) is encrypted", bdrv_get_device_name(bs),
4957 bdrv_get_encrypted_filename(bs));
4958 return -1;
4959 }
4960
4961 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4962 bdrv_get_encrypted_filename(bs));
4963
4964 mon->password_completion_cb = completion_cb;
4965 mon->password_opaque = opaque;
4966
4967 err = monitor_read_password(mon, bdrv_password_cb, bs);
4968
4969 if (err && completion_cb)
4970 completion_cb(opaque, err);
4971
4972 return err;
4973}
4974
4975int monitor_read_block_device_key(Monitor *mon, const char *device,
4976 BlockDriverCompletionFunc *completion_cb,
4977 void *opaque)
4978{
4979 BlockDriverState *bs;
4980
4981 bs = bdrv_find(device);
4982 if (!bs) {
4983 monitor_printf(mon, "Device not found %s\n", device);
4984 return -1;
4985 }
4986
4987 return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
4988}
4989
4990QemuOptsList qemu_mon_opts = {
4991 .name = "mon",
4992 .implied_opt_name = "chardev",
4993 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head){ ((void*)0), &(qemu_mon_opts.head).tqh_first },
4994 .desc = {
4995 {
4996 .name = "mode",
4997 .type = QEMU_OPT_STRING,
4998 },{
4999 .name = "chardev",
5000 .type = QEMU_OPT_STRING,
5001 },{
5002 .name = "default",
5003 .type = QEMU_OPT_BOOL,
5004 },{
5005 .name = "pretty",
5006 .type = QEMU_OPT_BOOL,
5007 },
5008 { /* end of list */ }
5009 },
5010};