/home/stefan/src/qemu/qemu.org/qemu/monitor.c

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
114	typedef struct MonitorCompletionData MonitorCompletionData;
115	struct MonitorCompletionData {
116	Monitor *mon;
117	void (user_print)(Monitor mon, const QObject *data);
118	};
119
120	typedef 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 */
141	typedef struct mon_fd_t mon_fd_t;
142	struct 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 */
149	typedef struct MonFdsetFd MonFdsetFd;
150	struct 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 */
158	typedef struct MonFdset MonFdset;
159	struct 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
166	typedef 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	*/
177	typedef 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
185	struct 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
208	static QLIST_HEAD(mon_list, Monitor)struct mon_list { struct Monitor *lh_first; } mon_list;
209	static QLIST_HEAD(mon_fdsets, MonFdset)struct mon_fdsets { struct MonFdset *lh_first; } mon_fdsets;
210	static int mon_refcount;
211
212	static mon_cmd_t mon_cmds[];
213	static mon_cmd_t info_cmds[];
214
215	static const mon_cmd_t qmp_cmds[];
216
217	Monitor *cur_mon;
218	Monitor *default_mon;
219
220	static void monitor_command_cb(Monitor mon, const char cmdline,
221	void *opaque);
222
223	static 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 */
229	static 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. */
235	int monitor_cur_is_qmp(void)
236	{
237	return cur_mon && monitor_ctrl_mode(cur_mon);
238	}
239
240	void 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
250	int 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
266	static 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
276	void 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 */
311	static 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
329	void 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
345	void 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
353	void 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
380	static 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
390	static void monitor_user_noop(Monitor mon, const QObject data) { }
391
392	static inline int handler_is_qobject(const mon_cmd_t *cmd)
393	{
394	return cmd->user_print != NULL((void*)0);
395	}
396
397	static inline bool_Bool handler_is_async(const mon_cmd_t *cmd)
398	{
399	return cmd->flags & MONITOR_CMD_ASYNC0x0001;
400	}
401
402	static inline int monitor_has_error(const Monitor *mon)
403	{
404	return mon->error != NULL((void*)0);
405	}
406
407	static 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
421	static 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
432	static 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
464	static 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
481	static 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	};
511	QEMU_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
513	MonitorEventState monitor_event_state[QEVENT_MAX];
514
515	/*
516	* Emits the event to every monitor instance
517	*/
518	static void
519	monitor_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	*/
537	static void
538	monitor_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	*/
584	static 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	*/
611	static void
612	monitor_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 */
634	static 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	*/
647	void 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
670	static 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
681	static void handle_user_command(Monitor mon, const char cmdline);
682
683	static 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
691	static void monitor_data_destroy(Monitor *mon)
692	{
693	QDECREF(mon->outbuf)qobject_decref(mon->outbuf ? (&(mon->outbuf)->base ) : ((void*)0));
694	}
695
696	char 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
727	out:
728	monitor_data_destroy(&hmp);
729	return output;
730	}
731
732	static 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
752	static 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
820	static 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	*/
845	static 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
879	static 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 */
893	static 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
921	static 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
950	static void do_help_cmd(Monitor mon, const QDict qdict)
951	{
952	help_cmd(mon, qdict_get_try_str(qdict, "name"));
953	}
954
955	static 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
976	static 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
1000	static 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
1011	static void qmp_monitor_complete(void opaque, QObject ret_data)
1012	{
1013	monitor_protocol_emitter(opaque, ret_data);
1014	}
1015
1016	static 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
1022	static 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
1039	static void do_info_help(Monitor mon, const QDict qdict)
1040	{
1041	help_cmd(mon, "info");
1042	}
1043
1044	CommandInfoList 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
1061	EventInfoList 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 */
1081	int 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
1093	static 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
1102	int 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
1108	static 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
1117	static void do_info_jit(Monitor mon, const QDict qdict)
1118	{
1119	dump_exec_info((FILE *)mon, monitor_fprintf);
1120	}
1121
1122	static 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
1139	static 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
1149	static void do_trace_print_events(Monitor mon, const QDict qdict)
1150	{
1151	trace_print_events((FILE *)mon, &monitor_fprintf);
1152	}
1153
1154	static 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
1188	static void do_logfile(Monitor mon, const QDict qdict)
1189	{
1190	qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1191	}
1192
1193	static 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
1210	static 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
1222	static 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
1238	static 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
1246	static 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
1273	static 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_64
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"%08x" ":", (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
1393	static 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
1403	static 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
1413	static 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
1439	static 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
1456	static int mouse_button_state;
1457
1458	static 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
1472	static 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
1479	static 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
1513	static 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
1535	static 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)
1552	static void print_pte(Monitor *mon, hwaddr addr,
1553	hwaddr pte,
1554	hwaddr mask)
1555	{
1556	#ifdef TARGET_X86_64
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
1576	static 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
1604	static 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_64
1644	static 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
1701	static 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_64
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
1725	static 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
1748	static 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
1789	static 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_64
1846	static 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
1924	static 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_64
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
1951	static 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
1963	static 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)
1979	static 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
1987	static void do_info_mtree(Monitor mon, const QDict qdict)
1988	{
1989	mtree_info((fprintf_function)monitor_printf, mon);
1990	}
1991
1992	static 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
2013	int64_t qemu_time;
2014	int64_t dev_time;
2015
2016	static 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
2030	static 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 */
2037	static QLIST_HEAD (capture_list_head, CaptureState)struct capture_list_head { struct CaptureState *lh_first; } capture_head;
2038
2039	static 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
2050	static 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
2066	static 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
2091	static 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
2101	static 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
2119	static 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
2130	static 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
2150	static 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
2181	static 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)
2198	static 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))), ("i386-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
2222	void 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
2256	void 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
2275	static 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
2287	int 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
2312	static 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
2334	static 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
2344	AddfdInfo *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
2363	error:
2364	if (fd != -1) {
2365	close(fd);
2366	}
2367	return NULL((void*)0);
2368	}
2369
2370	void 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
2398	error:
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
2408	FdsetInfoList 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
2447	AddfdInfo *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
2528	int 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
2558	int 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
2580	static 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
2601	int monitor_fdset_dup_fd_find(int dup_fd)
2602	{
2603	return monitor_fdset_dup_fd_find_remove(dup_fd, false0);
2604	}
2605
2606	int monitor_fdset_dup_fd_remove(int dup_fd)
2607	{
2608	return monitor_fdset_dup_fd_find_remove(dup_fd, true1);
2609	}
2610
2611	int 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 */
2632	static 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 */
2951	static mon_cmd_t mon_cmds[] = {
2952	#include "hmp-commands.h"
2953	{ NULL((void)0), NULL((void)0), },
2954	};
2955
2956	static const mon_cmd_t qmp_cmds[] = {
2957	#include "qmp-commands-old.h"
2958	{ /* NULL */ },
2959	};
2960
2961	/*******************************************************************/
2962
2963	static const char *pch;
2964	static sigjmp_buf expr_env;
2965
2966	#define MD_TLONG0 0
2967	#define MD_I321 1
2968
2969	typedef 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)
2977	static 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)
2985	static 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
2998	static 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
3004	static 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
3010	static 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
3016	static 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
3022	static 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
3031	static 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
3039	static 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
3046	static 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_64
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
3355	static void GCC_FMT_ATTR(2, 3)__attribute__((format(printf, 2, 3))) QEMU_NORETURN__attribute__ ((__noreturn__))
3356	expr_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 */
3367	static 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
3397	static 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
3406	static int64_t expr_sum(Monitor *mon);
3407
3408	static 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
3491	static 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
3522	static 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
3550	static 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
3570	static 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
3584	static 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	*/
3609	static 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	*/
3635	static 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
3658	static int default_fmt_format = 'x';
3659	static int default_fmt_size = 4;
3660
3661	static 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
3673	static 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
3687	static 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	*/
3704	static 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
4093	fail:
4094	g_free(key);
4095	return NULL((void*)0);
4096	}
4097
4098	void 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
4108	static 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
4120	static 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
4147	out:
4148	QDECREF(qdict)qobject_decref(qdict ? (&(qdict)->base) : ((void*)0));
4149	}
4150
4151	static 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
4177	static 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
4233	typedef struct MonitorBlockComplete {
4234	Monitor *mon;
4235	const char *input;
4236	} MonitorBlockComplete;
4237
4238	static 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
4251	static 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
4257	static 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
4341	static 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
4370	cleanup:
4371	free_cmdline_args(args, nb_args);
4372	}
4373
4374	static int monitor_can_read(void *opaque)
4375	{
4376	Monitor *mon = opaque;
4377
4378	return (mon->suspend_cnt == 0) ? 1 : 0;
4379	}
4380
4381	static 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	*/
4397	static 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	*/
4483	static 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
4507	static 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
4548	out:
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	*/
4560	static 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
4575	out:
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	*/
4590	static 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
4636	static 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
4648	static 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
4713	err_out:
4714	monitor_protocol_emitter(mon, NULL((void*)0));
4715	out:
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	*/
4723	static 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
4734	static 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
4754	static 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
4761	int monitor_suspend(Monitor *mon)
4762	{
4763	if (!mon->rs)
4764	return -ENOTTY25;
4765	mon->suspend_cnt++;
4766	return 0;
4767	}
4768
4769	void 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
4777	static 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	*/
4788	static 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
4810	static 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
4856	static int
4857	compare_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
4863	static 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
4884	void 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
4923	static 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
4938	ReadLineState monitor_get_rs(Monitor mon)
4939	{
4940	return mon->rs;
4941	}
4942
4943	int 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
4975	int 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
4990	QemuOptsList 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	};