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

Bug Summary

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