]> git.proxmox.com Git - qemu.git/blob - monitor.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
vnc_refresh: return if vd->timer is NULL
[qemu.git] / monitor.c
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 "sysemu.h"
38 #include "monitor.h"
39 #include "readline.h"
40 #include "console.h"
41 #include "block.h"
42 #include "audio/audio.h"
43 #include "disas.h"
44 #include "balloon.h"
45 #include "qemu-timer.h"
46 #include "migration.h"
47 #include "kvm.h"
48 #include "acl.h"
49 #include "qint.h"
50 #include "qlist.h"
51 #include "qdict.h"
52 #include "qbool.h"
53 #include "qstring.h"
54 #include "qerror.h"
55 #include "qjson.h"
56 #include "json-streamer.h"
57 #include "json-parser.h"
58 #include "osdep.h"
59
60 //#define DEBUG
61 //#define DEBUG_COMPLETION
62
63 /*
64 * Supported types:
65 *
66 * 'F' filename
67 * 'B' block device name
68 * 's' string (accept optional quote)
69 * 'i' 32 bit integer
70 * 'l' target long (32 or 64 bit)
71 * '/' optional gdb-like print format (like "/10x")
72 *
73 * '?' optional type (for all types, except '/')
74 * '.' other form of optional type (for 'i' and 'l')
75 * '-' optional parameter (eg. '-f')
76 *
77 */
78
79 typedef struct mon_cmd_t {
80 const char *name;
81 const char *args_type;
82 const char *params;
83 const char *help;
84 void (*user_print)(Monitor *mon, const QObject *data);
85 union {
86 void (*info)(Monitor *mon);
87 void (*info_new)(Monitor *mon, QObject **ret_data);
88 void (*cmd)(Monitor *mon, const QDict *qdict);
89 void (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
90 } mhandler;
91 } mon_cmd_t;
92
93 /* file descriptors passed via SCM_RIGHTS */
94 typedef struct mon_fd_t mon_fd_t;
95 struct mon_fd_t {
96 char *name;
97 int fd;
98 QLIST_ENTRY(mon_fd_t) next;
99 };
100
101 typedef struct MonitorControl {
102 QObject *id;
103 int print_enabled;
104 JSONMessageParser parser;
105 } MonitorControl;
106
107 struct Monitor {
108 CharDriverState *chr;
109 int mux_out;
110 int reset_seen;
111 int flags;
112 int suspend_cnt;
113 uint8_t outbuf[1024];
114 int outbuf_index;
115 ReadLineState *rs;
116 MonitorControl *mc;
117 CPUState *mon_cpu;
118 BlockDriverCompletionFunc *password_completion_cb;
119 void *password_opaque;
120 QError *error;
121 QLIST_HEAD(,mon_fd_t) fds;
122 QLIST_ENTRY(Monitor) entry;
123 };
124
125 static QLIST_HEAD(mon_list, Monitor) mon_list;
126
127 static const mon_cmd_t mon_cmds[];
128 static const mon_cmd_t info_cmds[];
129
130 Monitor *cur_mon = NULL;
131
132 static void monitor_command_cb(Monitor *mon, const char *cmdline,
133 void *opaque);
134
135 /* Return true if in control mode, false otherwise */
136 static inline int monitor_ctrl_mode(const Monitor *mon)
137 {
138 return (mon->flags & MONITOR_USE_CONTROL);
139 }
140
141 static void monitor_read_command(Monitor *mon, int show_prompt)
142 {
143 if (!mon->rs)
144 return;
145
146 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
147 if (show_prompt)
148 readline_show_prompt(mon->rs);
149 }
150
151 static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
152 void *opaque)
153 {
154 if (monitor_ctrl_mode(mon)) {
155 qemu_error_new(QERR_MISSING_PARAMETER, "password");
156 return -EINVAL;
157 } else if (mon->rs) {
158 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
159 /* prompt is printed on return from the command handler */
160 return 0;
161 } else {
162 monitor_printf(mon, "terminal does not support password prompting\n");
163 return -ENOTTY;
164 }
165 }
166
167 void monitor_flush(Monitor *mon)
168 {
169 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
170 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
171 mon->outbuf_index = 0;
172 }
173 }
174
175 /* flush at every end of line or if the buffer is full */
176 static void monitor_puts(Monitor *mon, const char *str)
177 {
178 char c;
179
180 for(;;) {
181 c = *str++;
182 if (c == '\0')
183 break;
184 if (c == '\n')
185 mon->outbuf[mon->outbuf_index++] = '\r';
186 mon->outbuf[mon->outbuf_index++] = c;
187 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
188 || c == '\n')
189 monitor_flush(mon);
190 }
191 }
192
193 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
194 {
195 if (!mon)
196 return;
197
198 if (mon->mc && !mon->mc->print_enabled) {
199 qemu_error_new(QERR_UNDEFINED_ERROR);
200 } else {
201 char buf[4096];
202 vsnprintf(buf, sizeof(buf), fmt, ap);
203 monitor_puts(mon, buf);
204 }
205 }
206
207 void monitor_printf(Monitor *mon, const char *fmt, ...)
208 {
209 va_list ap;
210 va_start(ap, fmt);
211 monitor_vprintf(mon, fmt, ap);
212 va_end(ap);
213 }
214
215 void monitor_print_filename(Monitor *mon, const char *filename)
216 {
217 int i;
218
219 for (i = 0; filename[i]; i++) {
220 switch (filename[i]) {
221 case ' ':
222 case '"':
223 case '\\':
224 monitor_printf(mon, "\\%c", filename[i]);
225 break;
226 case '\t':
227 monitor_printf(mon, "\\t");
228 break;
229 case '\r':
230 monitor_printf(mon, "\\r");
231 break;
232 case '\n':
233 monitor_printf(mon, "\\n");
234 break;
235 default:
236 monitor_printf(mon, "%c", filename[i]);
237 break;
238 }
239 }
240 }
241
242 static int monitor_fprintf(FILE *stream, const char *fmt, ...)
243 {
244 va_list ap;
245 va_start(ap, fmt);
246 monitor_vprintf((Monitor *)stream, fmt, ap);
247 va_end(ap);
248 return 0;
249 }
250
251 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
252
253 static inline int monitor_handler_ported(const mon_cmd_t *cmd)
254 {
255 return cmd->user_print != NULL;
256 }
257
258 static inline int monitor_has_error(const Monitor *mon)
259 {
260 return mon->error != NULL;
261 }
262
263 static void monitor_json_emitter(Monitor *mon, const QObject *data)
264 {
265 QString *json;
266
267 json = qobject_to_json(data);
268 assert(json != NULL);
269
270 mon->mc->print_enabled = 1;
271 monitor_printf(mon, "%s\n", qstring_get_str(json));
272 mon->mc->print_enabled = 0;
273
274 QDECREF(json);
275 }
276
277 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
278 {
279 QDict *qmp;
280
281 qmp = qdict_new();
282
283 if (!monitor_has_error(mon)) {
284 /* success response */
285 if (data) {
286 qobject_incref(data);
287 qdict_put_obj(qmp, "return", data);
288 } else {
289 /* return an empty QDict by default */
290 qdict_put(qmp, "return", qdict_new());
291 }
292 } else {
293 /* error response */
294 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
295 qdict_put(qmp, "error", mon->error->error);
296 QINCREF(mon->error->error);
297 QDECREF(mon->error);
298 mon->error = NULL;
299 }
300
301 if (mon->mc->id) {
302 qdict_put_obj(qmp, "id", mon->mc->id);
303 mon->mc->id = NULL;
304 }
305
306 monitor_json_emitter(mon, QOBJECT(qmp));
307 QDECREF(qmp);
308 }
309
310 static void timestamp_put(QDict *qdict)
311 {
312 int err;
313 QObject *obj;
314 qemu_timeval tv;
315
316 err = qemu_gettimeofday(&tv);
317 if (err < 0)
318 return;
319
320 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
321 "'microseconds': %" PRId64 " }",
322 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
323 assert(obj != NULL);
324
325 qdict_put_obj(qdict, "timestamp", obj);
326 }
327
328 /**
329 * monitor_protocol_event(): Generate a Monitor event
330 *
331 * Event-specific data can be emitted through the (optional) 'data' parameter.
332 */
333 void monitor_protocol_event(MonitorEvent event, QObject *data)
334 {
335 QDict *qmp;
336 const char *event_name;
337 Monitor *mon = cur_mon;
338
339 assert(event < QEVENT_MAX);
340
341 if (!monitor_ctrl_mode(mon))
342 return;
343
344 switch (event) {
345 case QEVENT_DEBUG:
346 event_name = "DEBUG";
347 break;
348 case QEVENT_SHUTDOWN:
349 event_name = "SHUTDOWN";
350 break;
351 case QEVENT_RESET:
352 event_name = "RESET";
353 break;
354 case QEVENT_POWERDOWN:
355 event_name = "POWERDOWN";
356 break;
357 case QEVENT_STOP:
358 event_name = "STOP";
359 break;
360 default:
361 abort();
362 break;
363 }
364
365 qmp = qdict_new();
366 timestamp_put(qmp);
367 qdict_put(qmp, "event", qstring_from_str(event_name));
368 if (data) {
369 qobject_incref(data);
370 qdict_put_obj(qmp, "data", data);
371 }
372
373 monitor_json_emitter(mon, QOBJECT(qmp));
374 QDECREF(qmp);
375 }
376
377 static int compare_cmd(const char *name, const char *list)
378 {
379 const char *p, *pstart;
380 int len;
381 len = strlen(name);
382 p = list;
383 for(;;) {
384 pstart = p;
385 p = strchr(p, '|');
386 if (!p)
387 p = pstart + strlen(pstart);
388 if ((p - pstart) == len && !memcmp(pstart, name, len))
389 return 1;
390 if (*p == '\0')
391 break;
392 p++;
393 }
394 return 0;
395 }
396
397 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
398 const char *prefix, const char *name)
399 {
400 const mon_cmd_t *cmd;
401
402 for(cmd = cmds; cmd->name != NULL; cmd++) {
403 if (!name || !strcmp(name, cmd->name))
404 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
405 cmd->params, cmd->help);
406 }
407 }
408
409 static void help_cmd(Monitor *mon, const char *name)
410 {
411 if (name && !strcmp(name, "info")) {
412 help_cmd_dump(mon, info_cmds, "info ", NULL);
413 } else {
414 help_cmd_dump(mon, mon_cmds, "", name);
415 if (name && !strcmp(name, "log")) {
416 const CPULogItem *item;
417 monitor_printf(mon, "Log items (comma separated):\n");
418 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
419 for(item = cpu_log_items; item->mask != 0; item++) {
420 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
421 }
422 }
423 }
424 }
425
426 static void do_help_cmd(Monitor *mon, const QDict *qdict)
427 {
428 help_cmd(mon, qdict_get_try_str(qdict, "name"));
429 }
430
431 static void do_commit(Monitor *mon, const QDict *qdict)
432 {
433 int all_devices;
434 DriveInfo *dinfo;
435 const char *device = qdict_get_str(qdict, "device");
436
437 all_devices = !strcmp(device, "all");
438 QTAILQ_FOREACH(dinfo, &drives, next) {
439 if (!all_devices)
440 if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
441 continue;
442 bdrv_commit(dinfo->bdrv);
443 }
444 }
445
446 static void do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
447 {
448 const mon_cmd_t *cmd;
449 const char *item = qdict_get_try_str(qdict, "item");
450
451 if (!item) {
452 assert(monitor_ctrl_mode(mon) == 0);
453 goto help;
454 }
455
456 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
457 if (compare_cmd(item, cmd->name))
458 break;
459 }
460
461 if (cmd->name == NULL) {
462 if (monitor_ctrl_mode(mon)) {
463 qemu_error_new(QERR_COMMAND_NOT_FOUND, item);
464 return;
465 }
466 goto help;
467 }
468
469 if (monitor_handler_ported(cmd)) {
470 cmd->mhandler.info_new(mon, ret_data);
471
472 if (!monitor_ctrl_mode(mon)) {
473 /*
474 * User Protocol function is called here, Monitor Protocol is
475 * handled by monitor_call_handler()
476 */
477 if (*ret_data)
478 cmd->user_print(mon, *ret_data);
479 }
480 } else {
481 if (monitor_ctrl_mode(mon)) {
482 /* handler not converted yet */
483 qemu_error_new(QERR_COMMAND_NOT_FOUND, item);
484 } else {
485 cmd->mhandler.info(mon);
486 }
487 }
488
489 return;
490
491 help:
492 help_cmd(mon, "info");
493 }
494
495 static void do_info_version_print(Monitor *mon, const QObject *data)
496 {
497 QDict *qdict;
498
499 qdict = qobject_to_qdict(data);
500
501 monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),
502 qdict_get_str(qdict, "package"));
503 }
504
505 /**
506 * do_info_version(): Show QEMU version
507 *
508 * Return a QDict with the following information:
509 *
510 * - "qemu": QEMU's version
511 * - "package": package's version
512 *
513 * Example:
514 *
515 * { "qemu": "0.11.50", "package": "" }
516 */
517 static void do_info_version(Monitor *mon, QObject **ret_data)
518 {
519 *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
520 QEMU_VERSION, QEMU_PKGVERSION);
521 }
522
523 static void do_info_name_print(Monitor *mon, const QObject *data)
524 {
525 QDict *qdict;
526
527 qdict = qobject_to_qdict(data);
528 if (qdict_size(qdict) == 0) {
529 return;
530 }
531
532 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
533 }
534
535 /**
536 * do_info_name(): Show VM name
537 *
538 * Return a QDict with the following information:
539 *
540 * - "name": VM's name (optional)
541 *
542 * Example:
543 *
544 * { "name": "qemu-name" }
545 */
546 static void do_info_name(Monitor *mon, QObject **ret_data)
547 {
548 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
549 qobject_from_jsonf("{}");
550 }
551
552 static QObject *get_cmd_dict(const char *name)
553 {
554 const char *p;
555
556 /* Remove '|' from some commands */
557 p = strchr(name, '|');
558 if (p) {
559 p++;
560 } else {
561 p = name;
562 }
563
564 return qobject_from_jsonf("{ 'name': %s }", p);
565 }
566
567 /**
568 * do_info_commands(): List QMP available commands
569 *
570 * Each command is represented by a QDict, the returned QObject is a QList
571 * of all commands.
572 *
573 * The QDict contains:
574 *
575 * - "name": command's name
576 *
577 * Example:
578 *
579 * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
580 */
581 static void do_info_commands(Monitor *mon, QObject **ret_data)
582 {
583 QList *cmd_list;
584 const mon_cmd_t *cmd;
585
586 cmd_list = qlist_new();
587
588 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
589 if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
590 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
591 }
592 }
593
594 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
595 if (monitor_handler_ported(cmd)) {
596 char buf[128];
597 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
598 qlist_append_obj(cmd_list, get_cmd_dict(buf));
599 }
600 }
601
602 *ret_data = QOBJECT(cmd_list);
603 }
604
605 #if defined(TARGET_I386)
606 static void do_info_hpet_print(Monitor *mon, const QObject *data)
607 {
608 monitor_printf(mon, "HPET is %s by QEMU\n",
609 qdict_get_bool(qobject_to_qdict(data), "enabled") ?
610 "enabled" : "disabled");
611 }
612
613 /**
614 * do_info_hpet(): Show HPET state
615 *
616 * Return a QDict with the following information:
617 *
618 * - "enabled": true if hpet if enabled, false otherwise
619 *
620 * Example:
621 *
622 * { "enabled": true }
623 */
624 static void do_info_hpet(Monitor *mon, QObject **ret_data)
625 {
626 *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
627 }
628 #endif
629
630 static void do_info_uuid_print(Monitor *mon, const QObject *data)
631 {
632 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
633 }
634
635 /**
636 * do_info_uuid(): Show VM UUID
637 *
638 * Return a QDict with the following information:
639 *
640 * - "UUID": Universally Unique Identifier
641 *
642 * Example:
643 *
644 * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
645 */
646 static void do_info_uuid(Monitor *mon, QObject **ret_data)
647 {
648 char uuid[64];
649
650 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
651 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
652 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
653 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
654 qemu_uuid[14], qemu_uuid[15]);
655 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
656 }
657
658 /* get the current CPU defined by the user */
659 static int mon_set_cpu(int cpu_index)
660 {
661 CPUState *env;
662
663 for(env = first_cpu; env != NULL; env = env->next_cpu) {
664 if (env->cpu_index == cpu_index) {
665 cur_mon->mon_cpu = env;
666 return 0;
667 }
668 }
669 return -1;
670 }
671
672 static CPUState *mon_get_cpu(void)
673 {
674 if (!cur_mon->mon_cpu) {
675 mon_set_cpu(0);
676 }
677 cpu_synchronize_state(cur_mon->mon_cpu);
678 return cur_mon->mon_cpu;
679 }
680
681 static void do_info_registers(Monitor *mon)
682 {
683 CPUState *env;
684 env = mon_get_cpu();
685 if (!env)
686 return;
687 #ifdef TARGET_I386
688 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
689 X86_DUMP_FPU);
690 #else
691 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
692 0);
693 #endif
694 }
695
696 static void print_cpu_iter(QObject *obj, void *opaque)
697 {
698 QDict *cpu;
699 int active = ' ';
700 Monitor *mon = opaque;
701
702 assert(qobject_type(obj) == QTYPE_QDICT);
703 cpu = qobject_to_qdict(obj);
704
705 if (qdict_get_bool(cpu, "current")) {
706 active = '*';
707 }
708
709 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
710
711 #if defined(TARGET_I386)
712 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
713 (target_ulong) qdict_get_int(cpu, "pc"));
714 #elif defined(TARGET_PPC)
715 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
716 (target_long) qdict_get_int(cpu, "nip"));
717 #elif defined(TARGET_SPARC)
718 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
719 (target_long) qdict_get_int(cpu, "pc"));
720 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
721 (target_long) qdict_get_int(cpu, "npc"));
722 #elif defined(TARGET_MIPS)
723 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
724 (target_long) qdict_get_int(cpu, "PC"));
725 #endif
726
727 if (qdict_get_bool(cpu, "halted")) {
728 monitor_printf(mon, " (halted)");
729 }
730
731 monitor_printf(mon, "\n");
732 }
733
734 static void monitor_print_cpus(Monitor *mon, const QObject *data)
735 {
736 QList *cpu_list;
737
738 assert(qobject_type(data) == QTYPE_QLIST);
739 cpu_list = qobject_to_qlist(data);
740 qlist_iter(cpu_list, print_cpu_iter, mon);
741 }
742
743 /**
744 * do_info_cpus(): Show CPU information
745 *
746 * Return a QList. Each CPU is represented by a QDict, which contains:
747 *
748 * - "cpu": CPU index
749 * - "current": true if this is the current CPU, false otherwise
750 * - "halted": true if the cpu is halted, false otherwise
751 * - Current program counter. The key's name depends on the architecture:
752 * "pc": i386/x86)64
753 * "nip": PPC
754 * "pc" and "npc": sparc
755 * "PC": mips
756 *
757 * Example:
758 *
759 * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
760 * { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
761 */
762 static void do_info_cpus(Monitor *mon, QObject **ret_data)
763 {
764 CPUState *env;
765 QList *cpu_list;
766
767 cpu_list = qlist_new();
768
769 /* just to set the default cpu if not already done */
770 mon_get_cpu();
771
772 for(env = first_cpu; env != NULL; env = env->next_cpu) {
773 QDict *cpu;
774 QObject *obj;
775
776 cpu_synchronize_state(env);
777
778 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
779 env->cpu_index, env == mon->mon_cpu,
780 env->halted);
781 assert(obj != NULL);
782
783 cpu = qobject_to_qdict(obj);
784
785 #if defined(TARGET_I386)
786 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
787 #elif defined(TARGET_PPC)
788 qdict_put(cpu, "nip", qint_from_int(env->nip));
789 #elif defined(TARGET_SPARC)
790 qdict_put(cpu, "pc", qint_from_int(env->pc));
791 qdict_put(cpu, "npc", qint_from_int(env->npc));
792 #elif defined(TARGET_MIPS)
793 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
794 #endif
795
796 qlist_append(cpu_list, cpu);
797 }
798
799 *ret_data = QOBJECT(cpu_list);
800 }
801
802 static void do_cpu_set(Monitor *mon, const QDict *qdict)
803 {
804 int index = qdict_get_int(qdict, "index");
805 if (mon_set_cpu(index) < 0)
806 monitor_printf(mon, "Invalid CPU index\n");
807 }
808
809 static void do_info_jit(Monitor *mon)
810 {
811 dump_exec_info((FILE *)mon, monitor_fprintf);
812 }
813
814 static void do_info_history(Monitor *mon)
815 {
816 int i;
817 const char *str;
818
819 if (!mon->rs)
820 return;
821 i = 0;
822 for(;;) {
823 str = readline_get_history(mon->rs, i);
824 if (!str)
825 break;
826 monitor_printf(mon, "%d: '%s'\n", i, str);
827 i++;
828 }
829 }
830
831 #if defined(TARGET_PPC)
832 /* XXX: not implemented in other targets */
833 static void do_info_cpu_stats(Monitor *mon)
834 {
835 CPUState *env;
836
837 env = mon_get_cpu();
838 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
839 }
840 #endif
841
842 /**
843 * do_quit(): Quit QEMU execution
844 */
845 static void do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
846 {
847 exit(0);
848 }
849
850 static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
851 {
852 if (bdrv_is_inserted(bs)) {
853 if (!force) {
854 if (!bdrv_is_removable(bs)) {
855 qemu_error_new(QERR_DEVICE_NOT_REMOVABLE,
856 bdrv_get_device_name(bs));
857 return -1;
858 }
859 if (bdrv_is_locked(bs)) {
860 qemu_error_new(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
861 return -1;
862 }
863 }
864 bdrv_close(bs);
865 }
866 return 0;
867 }
868
869 static void do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
870 {
871 BlockDriverState *bs;
872 int force = qdict_get_int(qdict, "force");
873 const char *filename = qdict_get_str(qdict, "device");
874
875 bs = bdrv_find(filename);
876 if (!bs) {
877 qemu_error_new(QERR_DEVICE_NOT_FOUND, filename);
878 return;
879 }
880 eject_device(mon, bs, force);
881 }
882
883 static void do_block_set_passwd(Monitor *mon, const QDict *qdict,
884 QObject **ret_data)
885 {
886 BlockDriverState *bs;
887
888 bs = bdrv_find(qdict_get_str(qdict, "device"));
889 if (!bs) {
890 qemu_error_new(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
891 return;
892 }
893
894 if (bdrv_set_key(bs, qdict_get_str(qdict, "password")) < 0) {
895 qemu_error_new(QERR_INVALID_PASSWORD);
896 }
897 }
898
899 static void do_change_block(Monitor *mon, const char *device,
900 const char *filename, const char *fmt)
901 {
902 BlockDriverState *bs;
903 BlockDriver *drv = NULL;
904
905 bs = bdrv_find(device);
906 if (!bs) {
907 qemu_error_new(QERR_DEVICE_NOT_FOUND, device);
908 return;
909 }
910 if (fmt) {
911 drv = bdrv_find_whitelisted_format(fmt);
912 if (!drv) {
913 qemu_error_new(QERR_INVALID_BLOCK_FORMAT, fmt);
914 return;
915 }
916 }
917 if (eject_device(mon, bs, 0) < 0)
918 return;
919 bdrv_open2(bs, filename, 0, drv);
920 monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
921 }
922
923 static void change_vnc_password(const char *password)
924 {
925 if (vnc_display_password(NULL, password) < 0)
926 qemu_error_new(QERR_SET_PASSWD_FAILED);
927
928 }
929
930 static void change_vnc_password_cb(Monitor *mon, const char *password,
931 void *opaque)
932 {
933 change_vnc_password(password);
934 monitor_read_command(mon, 1);
935 }
936
937 static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
938 {
939 if (strcmp(target, "passwd") == 0 ||
940 strcmp(target, "password") == 0) {
941 if (arg) {
942 char password[9];
943 strncpy(password, arg, sizeof(password));
944 password[sizeof(password) - 1] = '\0';
945 change_vnc_password(password);
946 } else {
947 monitor_read_password(mon, change_vnc_password_cb, NULL);
948 }
949 } else {
950 if (vnc_display_open(NULL, target) < 0)
951 qemu_error_new(QERR_VNC_SERVER_FAILED, target);
952 }
953 }
954
955 /**
956 * do_change(): Change a removable medium, or VNC configuration
957 */
958 static void do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
959 {
960 const char *device = qdict_get_str(qdict, "device");
961 const char *target = qdict_get_str(qdict, "target");
962 const char *arg = qdict_get_try_str(qdict, "arg");
963 if (strcmp(device, "vnc") == 0) {
964 do_change_vnc(mon, target, arg);
965 } else {
966 do_change_block(mon, device, target, arg);
967 }
968 }
969
970 static void do_screen_dump(Monitor *mon, const QDict *qdict)
971 {
972 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
973 }
974
975 static void do_logfile(Monitor *mon, const QDict *qdict)
976 {
977 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
978 }
979
980 static void do_log(Monitor *mon, const QDict *qdict)
981 {
982 int mask;
983 const char *items = qdict_get_str(qdict, "items");
984
985 if (!strcmp(items, "none")) {
986 mask = 0;
987 } else {
988 mask = cpu_str_to_log_mask(items);
989 if (!mask) {
990 help_cmd(mon, "log");
991 return;
992 }
993 }
994 cpu_set_log(mask);
995 }
996
997 static void do_singlestep(Monitor *mon, const QDict *qdict)
998 {
999 const char *option = qdict_get_try_str(qdict, "option");
1000 if (!option || !strcmp(option, "on")) {
1001 singlestep = 1;
1002 } else if (!strcmp(option, "off")) {
1003 singlestep = 0;
1004 } else {
1005 monitor_printf(mon, "unexpected option %s\n", option);
1006 }
1007 }
1008
1009 /**
1010 * do_stop(): Stop VM execution
1011 */
1012 static void do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1013 {
1014 vm_stop(EXCP_INTERRUPT);
1015 }
1016
1017 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1018
1019 struct bdrv_iterate_context {
1020 Monitor *mon;
1021 int err;
1022 };
1023
1024 /**
1025 * do_cont(): Resume emulation.
1026 */
1027 static void do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1028 {
1029 struct bdrv_iterate_context context = { mon, 0 };
1030
1031 bdrv_iterate(encrypted_bdrv_it, &context);
1032 /* only resume the vm if all keys are set and valid */
1033 if (!context.err)
1034 vm_start();
1035 }
1036
1037 static void bdrv_key_cb(void *opaque, int err)
1038 {
1039 Monitor *mon = opaque;
1040
1041 /* another key was set successfully, retry to continue */
1042 if (!err)
1043 do_cont(mon, NULL, NULL);
1044 }
1045
1046 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1047 {
1048 struct bdrv_iterate_context *context = opaque;
1049
1050 if (!context->err && bdrv_key_required(bs)) {
1051 context->err = -EBUSY;
1052 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1053 context->mon);
1054 }
1055 }
1056
1057 static void do_gdbserver(Monitor *mon, const QDict *qdict)
1058 {
1059 const char *device = qdict_get_try_str(qdict, "device");
1060 if (!device)
1061 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1062 if (gdbserver_start(device) < 0) {
1063 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1064 device);
1065 } else if (strcmp(device, "none") == 0) {
1066 monitor_printf(mon, "Disabled gdbserver\n");
1067 } else {
1068 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1069 device);
1070 }
1071 }
1072
1073 static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1074 {
1075 const char *action = qdict_get_str(qdict, "action");
1076 if (select_watchdog_action(action) == -1) {
1077 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1078 }
1079 }
1080
1081 static void monitor_printc(Monitor *mon, int c)
1082 {
1083 monitor_printf(mon, "'");
1084 switch(c) {
1085 case '\'':
1086 monitor_printf(mon, "\\'");
1087 break;
1088 case '\\':
1089 monitor_printf(mon, "\\\\");
1090 break;
1091 case '\n':
1092 monitor_printf(mon, "\\n");
1093 break;
1094 case '\r':
1095 monitor_printf(mon, "\\r");
1096 break;
1097 default:
1098 if (c >= 32 && c <= 126) {
1099 monitor_printf(mon, "%c", c);
1100 } else {
1101 monitor_printf(mon, "\\x%02x", c);
1102 }
1103 break;
1104 }
1105 monitor_printf(mon, "'");
1106 }
1107
1108 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1109 target_phys_addr_t addr, int is_physical)
1110 {
1111 CPUState *env;
1112 int nb_per_line, l, line_size, i, max_digits, len;
1113 uint8_t buf[16];
1114 uint64_t v;
1115
1116 if (format == 'i') {
1117 int flags;
1118 flags = 0;
1119 env = mon_get_cpu();
1120 if (!env && !is_physical)
1121 return;
1122 #ifdef TARGET_I386
1123 if (wsize == 2) {
1124 flags = 1;
1125 } else if (wsize == 4) {
1126 flags = 0;
1127 } else {
1128 /* as default we use the current CS size */
1129 flags = 0;
1130 if (env) {
1131 #ifdef TARGET_X86_64
1132 if ((env->efer & MSR_EFER_LMA) &&
1133 (env->segs[R_CS].flags & DESC_L_MASK))
1134 flags = 2;
1135 else
1136 #endif
1137 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1138 flags = 1;
1139 }
1140 }
1141 #endif
1142 monitor_disas(mon, env, addr, count, is_physical, flags);
1143 return;
1144 }
1145
1146 len = wsize * count;
1147 if (wsize == 1)
1148 line_size = 8;
1149 else
1150 line_size = 16;
1151 nb_per_line = line_size / wsize;
1152 max_digits = 0;
1153
1154 switch(format) {
1155 case 'o':
1156 max_digits = (wsize * 8 + 2) / 3;
1157 break;
1158 default:
1159 case 'x':
1160 max_digits = (wsize * 8) / 4;
1161 break;
1162 case 'u':
1163 case 'd':
1164 max_digits = (wsize * 8 * 10 + 32) / 33;
1165 break;
1166 case 'c':
1167 wsize = 1;
1168 break;
1169 }
1170
1171 while (len > 0) {
1172 if (is_physical)
1173 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1174 else
1175 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1176 l = len;
1177 if (l > line_size)
1178 l = line_size;
1179 if (is_physical) {
1180 cpu_physical_memory_rw(addr, buf, l, 0);
1181 } else {
1182 env = mon_get_cpu();
1183 if (!env)
1184 break;
1185 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1186 monitor_printf(mon, " Cannot access memory\n");
1187 break;
1188 }
1189 }
1190 i = 0;
1191 while (i < l) {
1192 switch(wsize) {
1193 default:
1194 case 1:
1195 v = ldub_raw(buf + i);
1196 break;
1197 case 2:
1198 v = lduw_raw(buf + i);
1199 break;
1200 case 4:
1201 v = (uint32_t)ldl_raw(buf + i);
1202 break;
1203 case 8:
1204 v = ldq_raw(buf + i);
1205 break;
1206 }
1207 monitor_printf(mon, " ");
1208 switch(format) {
1209 case 'o':
1210 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1211 break;
1212 case 'x':
1213 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1214 break;
1215 case 'u':
1216 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1217 break;
1218 case 'd':
1219 monitor_printf(mon, "%*" PRId64, max_digits, v);
1220 break;
1221 case 'c':
1222 monitor_printc(mon, v);
1223 break;
1224 }
1225 i += wsize;
1226 }
1227 monitor_printf(mon, "\n");
1228 addr += l;
1229 len -= l;
1230 }
1231 }
1232
1233 static void do_memory_dump(Monitor *mon, const QDict *qdict)
1234 {
1235 int count = qdict_get_int(qdict, "count");
1236 int format = qdict_get_int(qdict, "format");
1237 int size = qdict_get_int(qdict, "size");
1238 target_long addr = qdict_get_int(qdict, "addr");
1239
1240 memory_dump(mon, count, format, size, addr, 0);
1241 }
1242
1243 static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1244 {
1245 int count = qdict_get_int(qdict, "count");
1246 int format = qdict_get_int(qdict, "format");
1247 int size = qdict_get_int(qdict, "size");
1248 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1249
1250 memory_dump(mon, count, format, size, addr, 1);
1251 }
1252
1253 static void do_print(Monitor *mon, const QDict *qdict)
1254 {
1255 int format = qdict_get_int(qdict, "format");
1256 target_phys_addr_t val = qdict_get_int(qdict, "val");
1257
1258 #if TARGET_PHYS_ADDR_BITS == 32
1259 switch(format) {
1260 case 'o':
1261 monitor_printf(mon, "%#o", val);
1262 break;
1263 case 'x':
1264 monitor_printf(mon, "%#x", val);
1265 break;
1266 case 'u':
1267 monitor_printf(mon, "%u", val);
1268 break;
1269 default:
1270 case 'd':
1271 monitor_printf(mon, "%d", val);
1272 break;
1273 case 'c':
1274 monitor_printc(mon, val);
1275 break;
1276 }
1277 #else
1278 switch(format) {
1279 case 'o':
1280 monitor_printf(mon, "%#" PRIo64, val);
1281 break;
1282 case 'x':
1283 monitor_printf(mon, "%#" PRIx64, val);
1284 break;
1285 case 'u':
1286 monitor_printf(mon, "%" PRIu64, val);
1287 break;
1288 default:
1289 case 'd':
1290 monitor_printf(mon, "%" PRId64, val);
1291 break;
1292 case 'c':
1293 monitor_printc(mon, val);
1294 break;
1295 }
1296 #endif
1297 monitor_printf(mon, "\n");
1298 }
1299
1300 static void do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
1301 {
1302 FILE *f;
1303 uint32_t size = qdict_get_int(qdict, "size");
1304 const char *filename = qdict_get_str(qdict, "filename");
1305 target_long addr = qdict_get_int(qdict, "val");
1306 uint32_t l;
1307 CPUState *env;
1308 uint8_t buf[1024];
1309
1310 env = mon_get_cpu();
1311 if (!env)
1312 return;
1313
1314 f = fopen(filename, "wb");
1315 if (!f) {
1316 monitor_printf(mon, "could not open '%s'\n", filename);
1317 return;
1318 }
1319 while (size != 0) {
1320 l = sizeof(buf);
1321 if (l > size)
1322 l = size;
1323 cpu_memory_rw_debug(env, addr, buf, l, 0);
1324 fwrite(buf, 1, l, f);
1325 addr += l;
1326 size -= l;
1327 }
1328 fclose(f);
1329 }
1330
1331 static void do_physical_memory_save(Monitor *mon, const QDict *qdict,
1332 QObject **ret_data)
1333 {
1334 FILE *f;
1335 uint32_t l;
1336 uint8_t buf[1024];
1337 uint32_t size = qdict_get_int(qdict, "size");
1338 const char *filename = qdict_get_str(qdict, "filename");
1339 target_phys_addr_t addr = qdict_get_int(qdict, "val");
1340
1341 f = fopen(filename, "wb");
1342 if (!f) {
1343 monitor_printf(mon, "could not open '%s'\n", filename);
1344 return;
1345 }
1346 while (size != 0) {
1347 l = sizeof(buf);
1348 if (l > size)
1349 l = size;
1350 cpu_physical_memory_rw(addr, buf, l, 0);
1351 fwrite(buf, 1, l, f);
1352 fflush(f);
1353 addr += l;
1354 size -= l;
1355 }
1356 fclose(f);
1357 }
1358
1359 static void do_sum(Monitor *mon, const QDict *qdict)
1360 {
1361 uint32_t addr;
1362 uint8_t buf[1];
1363 uint16_t sum;
1364 uint32_t start = qdict_get_int(qdict, "start");
1365 uint32_t size = qdict_get_int(qdict, "size");
1366
1367 sum = 0;
1368 for(addr = start; addr < (start + size); addr++) {
1369 cpu_physical_memory_rw(addr, buf, 1, 0);
1370 /* BSD sum algorithm ('sum' Unix command) */
1371 sum = (sum >> 1) | (sum << 15);
1372 sum += buf[0];
1373 }
1374 monitor_printf(mon, "%05d\n", sum);
1375 }
1376
1377 typedef struct {
1378 int keycode;
1379 const char *name;
1380 } KeyDef;
1381
1382 static const KeyDef key_defs[] = {
1383 { 0x2a, "shift" },
1384 { 0x36, "shift_r" },
1385
1386 { 0x38, "alt" },
1387 { 0xb8, "alt_r" },
1388 { 0x64, "altgr" },
1389 { 0xe4, "altgr_r" },
1390 { 0x1d, "ctrl" },
1391 { 0x9d, "ctrl_r" },
1392
1393 { 0xdd, "menu" },
1394
1395 { 0x01, "esc" },
1396
1397 { 0x02, "1" },
1398 { 0x03, "2" },
1399 { 0x04, "3" },
1400 { 0x05, "4" },
1401 { 0x06, "5" },
1402 { 0x07, "6" },
1403 { 0x08, "7" },
1404 { 0x09, "8" },
1405 { 0x0a, "9" },
1406 { 0x0b, "0" },
1407 { 0x0c, "minus" },
1408 { 0x0d, "equal" },
1409 { 0x0e, "backspace" },
1410
1411 { 0x0f, "tab" },
1412 { 0x10, "q" },
1413 { 0x11, "w" },
1414 { 0x12, "e" },
1415 { 0x13, "r" },
1416 { 0x14, "t" },
1417 { 0x15, "y" },
1418 { 0x16, "u" },
1419 { 0x17, "i" },
1420 { 0x18, "o" },
1421 { 0x19, "p" },
1422
1423 { 0x1c, "ret" },
1424
1425 { 0x1e, "a" },
1426 { 0x1f, "s" },
1427 { 0x20, "d" },
1428 { 0x21, "f" },
1429 { 0x22, "g" },
1430 { 0x23, "h" },
1431 { 0x24, "j" },
1432 { 0x25, "k" },
1433 { 0x26, "l" },
1434
1435 { 0x2c, "z" },
1436 { 0x2d, "x" },
1437 { 0x2e, "c" },
1438 { 0x2f, "v" },
1439 { 0x30, "b" },
1440 { 0x31, "n" },
1441 { 0x32, "m" },
1442 { 0x33, "comma" },
1443 { 0x34, "dot" },
1444 { 0x35, "slash" },
1445
1446 { 0x37, "asterisk" },
1447
1448 { 0x39, "spc" },
1449 { 0x3a, "caps_lock" },
1450 { 0x3b, "f1" },
1451 { 0x3c, "f2" },
1452 { 0x3d, "f3" },
1453 { 0x3e, "f4" },
1454 { 0x3f, "f5" },
1455 { 0x40, "f6" },
1456 { 0x41, "f7" },
1457 { 0x42, "f8" },
1458 { 0x43, "f9" },
1459 { 0x44, "f10" },
1460 { 0x45, "num_lock" },
1461 { 0x46, "scroll_lock" },
1462
1463 { 0xb5, "kp_divide" },
1464 { 0x37, "kp_multiply" },
1465 { 0x4a, "kp_subtract" },
1466 { 0x4e, "kp_add" },
1467 { 0x9c, "kp_enter" },
1468 { 0x53, "kp_decimal" },
1469 { 0x54, "sysrq" },
1470
1471 { 0x52, "kp_0" },
1472 { 0x4f, "kp_1" },
1473 { 0x50, "kp_2" },
1474 { 0x51, "kp_3" },
1475 { 0x4b, "kp_4" },
1476 { 0x4c, "kp_5" },
1477 { 0x4d, "kp_6" },
1478 { 0x47, "kp_7" },
1479 { 0x48, "kp_8" },
1480 { 0x49, "kp_9" },
1481
1482 { 0x56, "<" },
1483
1484 { 0x57, "f11" },
1485 { 0x58, "f12" },
1486
1487 { 0xb7, "print" },
1488
1489 { 0xc7, "home" },
1490 { 0xc9, "pgup" },
1491 { 0xd1, "pgdn" },
1492 { 0xcf, "end" },
1493
1494 { 0xcb, "left" },
1495 { 0xc8, "up" },
1496 { 0xd0, "down" },
1497 { 0xcd, "right" },
1498
1499 { 0xd2, "insert" },
1500 { 0xd3, "delete" },
1501 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1502 { 0xf0, "stop" },
1503 { 0xf1, "again" },
1504 { 0xf2, "props" },
1505 { 0xf3, "undo" },
1506 { 0xf4, "front" },
1507 { 0xf5, "copy" },
1508 { 0xf6, "open" },
1509 { 0xf7, "paste" },
1510 { 0xf8, "find" },
1511 { 0xf9, "cut" },
1512 { 0xfa, "lf" },
1513 { 0xfb, "help" },
1514 { 0xfc, "meta_l" },
1515 { 0xfd, "meta_r" },
1516 { 0xfe, "compose" },
1517 #endif
1518 { 0, NULL },
1519 };
1520
1521 static int get_keycode(const char *key)
1522 {
1523 const KeyDef *p;
1524 char *endp;
1525 int ret;
1526
1527 for(p = key_defs; p->name != NULL; p++) {
1528 if (!strcmp(key, p->name))
1529 return p->keycode;
1530 }
1531 if (strstart(key, "0x", NULL)) {
1532 ret = strtoul(key, &endp, 0);
1533 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1534 return ret;
1535 }
1536 return -1;
1537 }
1538
1539 #define MAX_KEYCODES 16
1540 static uint8_t keycodes[MAX_KEYCODES];
1541 static int nb_pending_keycodes;
1542 static QEMUTimer *key_timer;
1543
1544 static void release_keys(void *opaque)
1545 {
1546 int keycode;
1547
1548 while (nb_pending_keycodes > 0) {
1549 nb_pending_keycodes--;
1550 keycode = keycodes[nb_pending_keycodes];
1551 if (keycode & 0x80)
1552 kbd_put_keycode(0xe0);
1553 kbd_put_keycode(keycode | 0x80);
1554 }
1555 }
1556
1557 static void do_sendkey(Monitor *mon, const QDict *qdict)
1558 {
1559 char keyname_buf[16];
1560 char *separator;
1561 int keyname_len, keycode, i;
1562 const char *string = qdict_get_str(qdict, "string");
1563 int has_hold_time = qdict_haskey(qdict, "hold_time");
1564 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1565
1566 if (nb_pending_keycodes > 0) {
1567 qemu_del_timer(key_timer);
1568 release_keys(NULL);
1569 }
1570 if (!has_hold_time)
1571 hold_time = 100;
1572 i = 0;
1573 while (1) {
1574 separator = strchr(string, '-');
1575 keyname_len = separator ? separator - string : strlen(string);
1576 if (keyname_len > 0) {
1577 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1578 if (keyname_len > sizeof(keyname_buf) - 1) {
1579 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1580 return;
1581 }
1582 if (i == MAX_KEYCODES) {
1583 monitor_printf(mon, "too many keys\n");
1584 return;
1585 }
1586 keyname_buf[keyname_len] = 0;
1587 keycode = get_keycode(keyname_buf);
1588 if (keycode < 0) {
1589 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1590 return;
1591 }
1592 keycodes[i++] = keycode;
1593 }
1594 if (!separator)
1595 break;
1596 string = separator + 1;
1597 }
1598 nb_pending_keycodes = i;
1599 /* key down events */
1600 for (i = 0; i < nb_pending_keycodes; i++) {
1601 keycode = keycodes[i];
1602 if (keycode & 0x80)
1603 kbd_put_keycode(0xe0);
1604 kbd_put_keycode(keycode & 0x7f);
1605 }
1606 /* delayed key up events */
1607 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1608 muldiv64(get_ticks_per_sec(), hold_time, 1000));
1609 }
1610
1611 static int mouse_button_state;
1612
1613 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1614 {
1615 int dx, dy, dz;
1616 const char *dx_str = qdict_get_str(qdict, "dx_str");
1617 const char *dy_str = qdict_get_str(qdict, "dy_str");
1618 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1619 dx = strtol(dx_str, NULL, 0);
1620 dy = strtol(dy_str, NULL, 0);
1621 dz = 0;
1622 if (dz_str)
1623 dz = strtol(dz_str, NULL, 0);
1624 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1625 }
1626
1627 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1628 {
1629 int button_state = qdict_get_int(qdict, "button_state");
1630 mouse_button_state = button_state;
1631 kbd_mouse_event(0, 0, 0, mouse_button_state);
1632 }
1633
1634 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1635 {
1636 int size = qdict_get_int(qdict, "size");
1637 int addr = qdict_get_int(qdict, "addr");
1638 int has_index = qdict_haskey(qdict, "index");
1639 uint32_t val;
1640 int suffix;
1641
1642 if (has_index) {
1643 int index = qdict_get_int(qdict, "index");
1644 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1645 addr++;
1646 }
1647 addr &= 0xffff;
1648
1649 switch(size) {
1650 default:
1651 case 1:
1652 val = cpu_inb(addr);
1653 suffix = 'b';
1654 break;
1655 case 2:
1656 val = cpu_inw(addr);
1657 suffix = 'w';
1658 break;
1659 case 4:
1660 val = cpu_inl(addr);
1661 suffix = 'l';
1662 break;
1663 }
1664 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1665 suffix, addr, size * 2, val);
1666 }
1667
1668 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1669 {
1670 int size = qdict_get_int(qdict, "size");
1671 int addr = qdict_get_int(qdict, "addr");
1672 int val = qdict_get_int(qdict, "val");
1673
1674 addr &= IOPORTS_MASK;
1675
1676 switch (size) {
1677 default:
1678 case 1:
1679 cpu_outb(addr, val);
1680 break;
1681 case 2:
1682 cpu_outw(addr, val);
1683 break;
1684 case 4:
1685 cpu_outl(addr, val);
1686 break;
1687 }
1688 }
1689
1690 static void do_boot_set(Monitor *mon, const QDict *qdict)
1691 {
1692 int res;
1693 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1694
1695 res = qemu_boot_set(bootdevice);
1696 if (res == 0) {
1697 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1698 } else if (res > 0) {
1699 monitor_printf(mon, "setting boot device list failed\n");
1700 } else {
1701 monitor_printf(mon, "no function defined to set boot device list for "
1702 "this architecture\n");
1703 }
1704 }
1705
1706 /**
1707 * do_system_reset(): Issue a machine reset
1708 */
1709 static void do_system_reset(Monitor *mon, const QDict *qdict,
1710 QObject **ret_data)
1711 {
1712 qemu_system_reset_request();
1713 }
1714
1715 /**
1716 * do_system_powerdown(): Issue a machine powerdown
1717 */
1718 static void do_system_powerdown(Monitor *mon, const QDict *qdict,
1719 QObject **ret_data)
1720 {
1721 qemu_system_powerdown_request();
1722 }
1723
1724 #if defined(TARGET_I386)
1725 static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1726 {
1727 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1728 addr,
1729 pte & mask,
1730 pte & PG_GLOBAL_MASK ? 'G' : '-',
1731 pte & PG_PSE_MASK ? 'P' : '-',
1732 pte & PG_DIRTY_MASK ? 'D' : '-',
1733 pte & PG_ACCESSED_MASK ? 'A' : '-',
1734 pte & PG_PCD_MASK ? 'C' : '-',
1735 pte & PG_PWT_MASK ? 'T' : '-',
1736 pte & PG_USER_MASK ? 'U' : '-',
1737 pte & PG_RW_MASK ? 'W' : '-');
1738 }
1739
1740 static void tlb_info(Monitor *mon)
1741 {
1742 CPUState *env;
1743 int l1, l2;
1744 uint32_t pgd, pde, pte;
1745
1746 env = mon_get_cpu();
1747 if (!env)
1748 return;
1749
1750 if (!(env->cr[0] & CR0_PG_MASK)) {
1751 monitor_printf(mon, "PG disabled\n");
1752 return;
1753 }
1754 pgd = env->cr[3] & ~0xfff;
1755 for(l1 = 0; l1 < 1024; l1++) {
1756 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1757 pde = le32_to_cpu(pde);
1758 if (pde & PG_PRESENT_MASK) {
1759 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1760 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1761 } else {
1762 for(l2 = 0; l2 < 1024; l2++) {
1763 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1764 (uint8_t *)&pte, 4);
1765 pte = le32_to_cpu(pte);
1766 if (pte & PG_PRESENT_MASK) {
1767 print_pte(mon, (l1 << 22) + (l2 << 12),
1768 pte & ~PG_PSE_MASK,
1769 ~0xfff);
1770 }
1771 }
1772 }
1773 }
1774 }
1775 }
1776
1777 static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1778 uint32_t end, int prot)
1779 {
1780 int prot1;
1781 prot1 = *plast_prot;
1782 if (prot != prot1) {
1783 if (*pstart != -1) {
1784 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1785 *pstart, end, end - *pstart,
1786 prot1 & PG_USER_MASK ? 'u' : '-',
1787 'r',
1788 prot1 & PG_RW_MASK ? 'w' : '-');
1789 }
1790 if (prot != 0)
1791 *pstart = end;
1792 else
1793 *pstart = -1;
1794 *plast_prot = prot;
1795 }
1796 }
1797
1798 static void mem_info(Monitor *mon)
1799 {
1800 CPUState *env;
1801 int l1, l2, prot, last_prot;
1802 uint32_t pgd, pde, pte, start, end;
1803
1804 env = mon_get_cpu();
1805 if (!env)
1806 return;
1807
1808 if (!(env->cr[0] & CR0_PG_MASK)) {
1809 monitor_printf(mon, "PG disabled\n");
1810 return;
1811 }
1812 pgd = env->cr[3] & ~0xfff;
1813 last_prot = 0;
1814 start = -1;
1815 for(l1 = 0; l1 < 1024; l1++) {
1816 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1817 pde = le32_to_cpu(pde);
1818 end = l1 << 22;
1819 if (pde & PG_PRESENT_MASK) {
1820 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1821 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1822 mem_print(mon, &start, &last_prot, end, prot);
1823 } else {
1824 for(l2 = 0; l2 < 1024; l2++) {
1825 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1826 (uint8_t *)&pte, 4);
1827 pte = le32_to_cpu(pte);
1828 end = (l1 << 22) + (l2 << 12);
1829 if (pte & PG_PRESENT_MASK) {
1830 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1831 } else {
1832 prot = 0;
1833 }
1834 mem_print(mon, &start, &last_prot, end, prot);
1835 }
1836 }
1837 } else {
1838 prot = 0;
1839 mem_print(mon, &start, &last_prot, end, prot);
1840 }
1841 }
1842 }
1843 #endif
1844
1845 #if defined(TARGET_SH4)
1846
1847 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1848 {
1849 monitor_printf(mon, " tlb%i:\t"
1850 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1851 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1852 "dirty=%hhu writethrough=%hhu\n",
1853 idx,
1854 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1855 tlb->v, tlb->sh, tlb->c, tlb->pr,
1856 tlb->d, tlb->wt);
1857 }
1858
1859 static void tlb_info(Monitor *mon)
1860 {
1861 CPUState *env = mon_get_cpu();
1862 int i;
1863
1864 monitor_printf (mon, "ITLB:\n");
1865 for (i = 0 ; i < ITLB_SIZE ; i++)
1866 print_tlb (mon, i, &env->itlb[i]);
1867 monitor_printf (mon, "UTLB:\n");
1868 for (i = 0 ; i < UTLB_SIZE ; i++)
1869 print_tlb (mon, i, &env->utlb[i]);
1870 }
1871
1872 #endif
1873
1874 static void do_info_kvm_print(Monitor *mon, const QObject *data)
1875 {
1876 QDict *qdict;
1877
1878 qdict = qobject_to_qdict(data);
1879
1880 monitor_printf(mon, "kvm support: ");
1881 if (qdict_get_bool(qdict, "present")) {
1882 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
1883 "enabled" : "disabled");
1884 } else {
1885 monitor_printf(mon, "not compiled\n");
1886 }
1887 }
1888
1889 /**
1890 * do_info_kvm(): Show KVM information
1891 *
1892 * Return a QDict with the following information:
1893 *
1894 * - "enabled": true if KVM support is enabled, false otherwise
1895 * - "present": true if QEMU has KVM support, false otherwise
1896 *
1897 * Example:
1898 *
1899 * { "enabled": true, "present": true }
1900 */
1901 static void do_info_kvm(Monitor *mon, QObject **ret_data)
1902 {
1903 #ifdef CONFIG_KVM
1904 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
1905 kvm_enabled());
1906 #else
1907 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
1908 #endif
1909 }
1910
1911 static void do_info_numa(Monitor *mon)
1912 {
1913 int i;
1914 CPUState *env;
1915
1916 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1917 for (i = 0; i < nb_numa_nodes; i++) {
1918 monitor_printf(mon, "node %d cpus:", i);
1919 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1920 if (env->numa_node == i) {
1921 monitor_printf(mon, " %d", env->cpu_index);
1922 }
1923 }
1924 monitor_printf(mon, "\n");
1925 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1926 node_mem[i] >> 20);
1927 }
1928 }
1929
1930 #ifdef CONFIG_PROFILER
1931
1932 int64_t qemu_time;
1933 int64_t dev_time;
1934
1935 static void do_info_profile(Monitor *mon)
1936 {
1937 int64_t total;
1938 total = qemu_time;
1939 if (total == 0)
1940 total = 1;
1941 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1942 dev_time, dev_time / (double)get_ticks_per_sec());
1943 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1944 qemu_time, qemu_time / (double)get_ticks_per_sec());
1945 qemu_time = 0;
1946 dev_time = 0;
1947 }
1948 #else
1949 static void do_info_profile(Monitor *mon)
1950 {
1951 monitor_printf(mon, "Internal profiler not compiled\n");
1952 }
1953 #endif
1954
1955 /* Capture support */
1956 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1957
1958 static void do_info_capture(Monitor *mon)
1959 {
1960 int i;
1961 CaptureState *s;
1962
1963 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1964 monitor_printf(mon, "[%d]: ", i);
1965 s->ops.info (s->opaque);
1966 }
1967 }
1968
1969 #ifdef HAS_AUDIO
1970 static void do_stop_capture(Monitor *mon, const QDict *qdict)
1971 {
1972 int i;
1973 int n = qdict_get_int(qdict, "n");
1974 CaptureState *s;
1975
1976 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1977 if (i == n) {
1978 s->ops.destroy (s->opaque);
1979 QLIST_REMOVE (s, entries);
1980 qemu_free (s);
1981 return;
1982 }
1983 }
1984 }
1985
1986 static void do_wav_capture(Monitor *mon, const QDict *qdict)
1987 {
1988 const char *path = qdict_get_str(qdict, "path");
1989 int has_freq = qdict_haskey(qdict, "freq");
1990 int freq = qdict_get_try_int(qdict, "freq", -1);
1991 int has_bits = qdict_haskey(qdict, "bits");
1992 int bits = qdict_get_try_int(qdict, "bits", -1);
1993 int has_channels = qdict_haskey(qdict, "nchannels");
1994 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1995 CaptureState *s;
1996
1997 s = qemu_mallocz (sizeof (*s));
1998
1999 freq = has_freq ? freq : 44100;
2000 bits = has_bits ? bits : 16;
2001 nchannels = has_channels ? nchannels : 2;
2002
2003 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2004 monitor_printf(mon, "Faied to add wave capture\n");
2005 qemu_free (s);
2006 }
2007 QLIST_INSERT_HEAD (&capture_head, s, entries);
2008 }
2009 #endif
2010
2011 #if defined(TARGET_I386)
2012 static void do_inject_nmi(Monitor *mon, const QDict *qdict)
2013 {
2014 CPUState *env;
2015 int cpu_index = qdict_get_int(qdict, "cpu_index");
2016
2017 for (env = first_cpu; env != NULL; env = env->next_cpu)
2018 if (env->cpu_index == cpu_index) {
2019 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2020 break;
2021 }
2022 }
2023 #endif
2024
2025 static void do_info_status_print(Monitor *mon, const QObject *data)
2026 {
2027 QDict *qdict;
2028
2029 qdict = qobject_to_qdict(data);
2030
2031 monitor_printf(mon, "VM status: ");
2032 if (qdict_get_bool(qdict, "running")) {
2033 monitor_printf(mon, "running");
2034 if (qdict_get_bool(qdict, "singlestep")) {
2035 monitor_printf(mon, " (single step mode)");
2036 }
2037 } else {
2038 monitor_printf(mon, "paused");
2039 }
2040
2041 monitor_printf(mon, "\n");
2042 }
2043
2044 /**
2045 * do_info_status(): VM status
2046 *
2047 * Return a QDict with the following information:
2048 *
2049 * - "running": true if the VM is running, or false if it is paused
2050 * - "singlestep": true if the VM is in single step mode, false otherwise
2051 *
2052 * Example:
2053 *
2054 * { "running": true, "singlestep": false }
2055 */
2056 static void do_info_status(Monitor *mon, QObject **ret_data)
2057 {
2058 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2059 vm_running, singlestep);
2060 }
2061
2062 static ram_addr_t balloon_get_value(void)
2063 {
2064 ram_addr_t actual;
2065
2066 if (kvm_enabled() && !kvm_has_sync_mmu()) {
2067 qemu_error_new(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
2068 return 0;
2069 }
2070
2071 actual = qemu_balloon_status();
2072 if (actual == 0) {
2073 qemu_error_new(QERR_DEVICE_NOT_ACTIVE, "balloon");
2074 return 0;
2075 }
2076
2077 return actual;
2078 }
2079
2080 /**
2081 * do_balloon(): Request VM to change its memory allocation
2082 */
2083 static void do_balloon(Monitor *mon, const QDict *qdict, QObject **ret_data)
2084 {
2085 if (balloon_get_value()) {
2086 /* ballooning is active */
2087 qemu_balloon(qdict_get_int(qdict, "value"));
2088 }
2089 }
2090
2091 static void monitor_print_balloon(Monitor *mon, const QObject *data)
2092 {
2093 QDict *qdict;
2094
2095 qdict = qobject_to_qdict(data);
2096
2097 monitor_printf(mon, "balloon: actual=%" PRId64 "\n",
2098 qdict_get_int(qdict, "balloon") >> 20);
2099 }
2100
2101 /**
2102 * do_info_balloon(): Balloon information
2103 *
2104 * Return a QDict with the following information:
2105 *
2106 * - "balloon": current balloon value in bytes
2107 *
2108 * Example:
2109 *
2110 * { "balloon": 1073741824 }
2111 */
2112 static void do_info_balloon(Monitor *mon, QObject **ret_data)
2113 {
2114 ram_addr_t actual;
2115
2116 actual = balloon_get_value();
2117 if (actual != 0) {
2118 *ret_data = qobject_from_jsonf("{ 'balloon': %" PRId64 "}",
2119 (int64_t) actual);
2120 }
2121 }
2122
2123 static qemu_acl *find_acl(Monitor *mon, const char *name)
2124 {
2125 qemu_acl *acl = qemu_acl_find(name);
2126
2127 if (!acl) {
2128 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2129 }
2130 return acl;
2131 }
2132
2133 static void do_acl_show(Monitor *mon, const QDict *qdict)
2134 {
2135 const char *aclname = qdict_get_str(qdict, "aclname");
2136 qemu_acl *acl = find_acl(mon, aclname);
2137 qemu_acl_entry *entry;
2138 int i = 0;
2139
2140 if (acl) {
2141 monitor_printf(mon, "policy: %s\n",
2142 acl->defaultDeny ? "deny" : "allow");
2143 QTAILQ_FOREACH(entry, &acl->entries, next) {
2144 i++;
2145 monitor_printf(mon, "%d: %s %s\n", i,
2146 entry->deny ? "deny" : "allow", entry->match);
2147 }
2148 }
2149 }
2150
2151 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2152 {
2153 const char *aclname = qdict_get_str(qdict, "aclname");
2154 qemu_acl *acl = find_acl(mon, aclname);
2155
2156 if (acl) {
2157 qemu_acl_reset(acl);
2158 monitor_printf(mon, "acl: removed all rules\n");
2159 }
2160 }
2161
2162 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2163 {
2164 const char *aclname = qdict_get_str(qdict, "aclname");
2165 const char *policy = qdict_get_str(qdict, "policy");
2166 qemu_acl *acl = find_acl(mon, aclname);
2167
2168 if (acl) {
2169 if (strcmp(policy, "allow") == 0) {
2170 acl->defaultDeny = 0;
2171 monitor_printf(mon, "acl: policy set to 'allow'\n");
2172 } else if (strcmp(policy, "deny") == 0) {
2173 acl->defaultDeny = 1;
2174 monitor_printf(mon, "acl: policy set to 'deny'\n");
2175 } else {
2176 monitor_printf(mon, "acl: unknown policy '%s', "
2177 "expected 'deny' or 'allow'\n", policy);
2178 }
2179 }
2180 }
2181
2182 static void do_acl_add(Monitor *mon, const QDict *qdict)
2183 {
2184 const char *aclname = qdict_get_str(qdict, "aclname");
2185 const char *match = qdict_get_str(qdict, "match");
2186 const char *policy = qdict_get_str(qdict, "policy");
2187 int has_index = qdict_haskey(qdict, "index");
2188 int index = qdict_get_try_int(qdict, "index", -1);
2189 qemu_acl *acl = find_acl(mon, aclname);
2190 int deny, ret;
2191
2192 if (acl) {
2193 if (strcmp(policy, "allow") == 0) {
2194 deny = 0;
2195 } else if (strcmp(policy, "deny") == 0) {
2196 deny = 1;
2197 } else {
2198 monitor_printf(mon, "acl: unknown policy '%s', "
2199 "expected 'deny' or 'allow'\n", policy);
2200 return;
2201 }
2202 if (has_index)
2203 ret = qemu_acl_insert(acl, deny, match, index);
2204 else
2205 ret = qemu_acl_append(acl, deny, match);
2206 if (ret < 0)
2207 monitor_printf(mon, "acl: unable to add acl entry\n");
2208 else
2209 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2210 }
2211 }
2212
2213 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2214 {
2215 const char *aclname = qdict_get_str(qdict, "aclname");
2216 const char *match = qdict_get_str(qdict, "match");
2217 qemu_acl *acl = find_acl(mon, aclname);
2218 int ret;
2219
2220 if (acl) {
2221 ret = qemu_acl_remove(acl, match);
2222 if (ret < 0)
2223 monitor_printf(mon, "acl: no matching acl entry\n");
2224 else
2225 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2226 }
2227 }
2228
2229 #if defined(TARGET_I386)
2230 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2231 {
2232 CPUState *cenv;
2233 int cpu_index = qdict_get_int(qdict, "cpu_index");
2234 int bank = qdict_get_int(qdict, "bank");
2235 uint64_t status = qdict_get_int(qdict, "status");
2236 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2237 uint64_t addr = qdict_get_int(qdict, "addr");
2238 uint64_t misc = qdict_get_int(qdict, "misc");
2239
2240 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2241 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2242 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2243 break;
2244 }
2245 }
2246 #endif
2247
2248 static void do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2249 {
2250 const char *fdname = qdict_get_str(qdict, "fdname");
2251 mon_fd_t *monfd;
2252 int fd;
2253
2254 fd = qemu_chr_get_msgfd(mon->chr);
2255 if (fd == -1) {
2256 qemu_error_new(QERR_FD_NOT_SUPPLIED);
2257 return;
2258 }
2259
2260 if (qemu_isdigit(fdname[0])) {
2261 qemu_error_new(QERR_INVALID_PARAMETER, "fdname");
2262 return;
2263 }
2264
2265 fd = dup(fd);
2266 if (fd == -1) {
2267 if (errno == EMFILE)
2268 qemu_error_new(QERR_TOO_MANY_FILES);
2269 else
2270 qemu_error_new(QERR_UNDEFINED_ERROR);
2271 return;
2272 }
2273
2274 QLIST_FOREACH(monfd, &mon->fds, next) {
2275 if (strcmp(monfd->name, fdname) != 0) {
2276 continue;
2277 }
2278
2279 close(monfd->fd);
2280 monfd->fd = fd;
2281 return;
2282 }
2283
2284 monfd = qemu_mallocz(sizeof(mon_fd_t));
2285 monfd->name = qemu_strdup(fdname);
2286 monfd->fd = fd;
2287
2288 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2289 }
2290
2291 static void do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2292 {
2293 const char *fdname = qdict_get_str(qdict, "fdname");
2294 mon_fd_t *monfd;
2295
2296 QLIST_FOREACH(monfd, &mon->fds, next) {
2297 if (strcmp(monfd->name, fdname) != 0) {
2298 continue;
2299 }
2300
2301 QLIST_REMOVE(monfd, next);
2302 close(monfd->fd);
2303 qemu_free(monfd->name);
2304 qemu_free(monfd);
2305 return;
2306 }
2307
2308 qemu_error_new(QERR_FD_NOT_FOUND, fdname);
2309 }
2310
2311 static void do_loadvm(Monitor *mon, const QDict *qdict)
2312 {
2313 int saved_vm_running = vm_running;
2314 const char *name = qdict_get_str(qdict, "name");
2315
2316 vm_stop(0);
2317
2318 if (load_vmstate(mon, name) >= 0 && saved_vm_running)
2319 vm_start();
2320 }
2321
2322 int monitor_get_fd(Monitor *mon, const char *fdname)
2323 {
2324 mon_fd_t *monfd;
2325
2326 QLIST_FOREACH(monfd, &mon->fds, next) {
2327 int fd;
2328
2329 if (strcmp(monfd->name, fdname) != 0) {
2330 continue;
2331 }
2332
2333 fd = monfd->fd;
2334
2335 /* caller takes ownership of fd */
2336 QLIST_REMOVE(monfd, next);
2337 qemu_free(monfd->name);
2338 qemu_free(monfd);
2339
2340 return fd;
2341 }
2342
2343 return -1;
2344 }
2345
2346 static const mon_cmd_t mon_cmds[] = {
2347 #include "qemu-monitor.h"
2348 { NULL, NULL, },
2349 };
2350
2351 /* Please update qemu-monitor.hx when adding or changing commands */
2352 static const mon_cmd_t info_cmds[] = {
2353 {
2354 .name = "version",
2355 .args_type = "",
2356 .params = "",
2357 .help = "show the version of QEMU",
2358 .user_print = do_info_version_print,
2359 .mhandler.info_new = do_info_version,
2360 },
2361 {
2362 .name = "commands",
2363 .args_type = "",
2364 .params = "",
2365 .help = "list QMP available commands",
2366 .user_print = monitor_user_noop,
2367 .mhandler.info_new = do_info_commands,
2368 },
2369 {
2370 .name = "network",
2371 .args_type = "",
2372 .params = "",
2373 .help = "show the network state",
2374 .mhandler.info = do_info_network,
2375 },
2376 {
2377 .name = "chardev",
2378 .args_type = "",
2379 .params = "",
2380 .help = "show the character devices",
2381 .user_print = qemu_chr_info_print,
2382 .mhandler.info_new = qemu_chr_info,
2383 },
2384 {
2385 .name = "block",
2386 .args_type = "",
2387 .params = "",
2388 .help = "show the block devices",
2389 .user_print = bdrv_info_print,
2390 .mhandler.info_new = bdrv_info,
2391 },
2392 {
2393 .name = "blockstats",
2394 .args_type = "",
2395 .params = "",
2396 .help = "show block device statistics",
2397 .user_print = bdrv_stats_print,
2398 .mhandler.info_new = bdrv_info_stats,
2399 },
2400 {
2401 .name = "registers",
2402 .args_type = "",
2403 .params = "",
2404 .help = "show the cpu registers",
2405 .mhandler.info = do_info_registers,
2406 },
2407 {
2408 .name = "cpus",
2409 .args_type = "",
2410 .params = "",
2411 .help = "show infos for each CPU",
2412 .user_print = monitor_print_cpus,
2413 .mhandler.info_new = do_info_cpus,
2414 },
2415 {
2416 .name = "history",
2417 .args_type = "",
2418 .params = "",
2419 .help = "show the command line history",
2420 .mhandler.info = do_info_history,
2421 },
2422 {
2423 .name = "irq",
2424 .args_type = "",
2425 .params = "",
2426 .help = "show the interrupts statistics (if available)",
2427 .mhandler.info = irq_info,
2428 },
2429 {
2430 .name = "pic",
2431 .args_type = "",
2432 .params = "",
2433 .help = "show i8259 (PIC) state",
2434 .mhandler.info = pic_info,
2435 },
2436 {
2437 .name = "pci",
2438 .args_type = "",
2439 .params = "",
2440 .help = "show PCI info",
2441 .mhandler.info = pci_info,
2442 },
2443 #if defined(TARGET_I386) || defined(TARGET_SH4)
2444 {
2445 .name = "tlb",
2446 .args_type = "",
2447 .params = "",
2448 .help = "show virtual to physical memory mappings",
2449 .mhandler.info = tlb_info,
2450 },
2451 #endif
2452 #if defined(TARGET_I386)
2453 {
2454 .name = "mem",
2455 .args_type = "",
2456 .params = "",
2457 .help = "show the active virtual memory mappings",
2458 .mhandler.info = mem_info,
2459 },
2460 {
2461 .name = "hpet",
2462 .args_type = "",
2463 .params = "",
2464 .help = "show state of HPET",
2465 .user_print = do_info_hpet_print,
2466 .mhandler.info_new = do_info_hpet,
2467 },
2468 #endif
2469 {
2470 .name = "jit",
2471 .args_type = "",
2472 .params = "",
2473 .help = "show dynamic compiler info",
2474 .mhandler.info = do_info_jit,
2475 },
2476 {
2477 .name = "kvm",
2478 .args_type = "",
2479 .params = "",
2480 .help = "show KVM information",
2481 .user_print = do_info_kvm_print,
2482 .mhandler.info_new = do_info_kvm,
2483 },
2484 {
2485 .name = "numa",
2486 .args_type = "",
2487 .params = "",
2488 .help = "show NUMA information",
2489 .mhandler.info = do_info_numa,
2490 },
2491 {
2492 .name = "usb",
2493 .args_type = "",
2494 .params = "",
2495 .help = "show guest USB devices",
2496 .mhandler.info = usb_info,
2497 },
2498 {
2499 .name = "usbhost",
2500 .args_type = "",
2501 .params = "",
2502 .help = "show host USB devices",
2503 .mhandler.info = usb_host_info,
2504 },
2505 {
2506 .name = "profile",
2507 .args_type = "",
2508 .params = "",
2509 .help = "show profiling information",
2510 .mhandler.info = do_info_profile,
2511 },
2512 {
2513 .name = "capture",
2514 .args_type = "",
2515 .params = "",
2516 .help = "show capture information",
2517 .mhandler.info = do_info_capture,
2518 },
2519 {
2520 .name = "snapshots",
2521 .args_type = "",
2522 .params = "",
2523 .help = "show the currently saved VM snapshots",
2524 .mhandler.info = do_info_snapshots,
2525 },
2526 {
2527 .name = "status",
2528 .args_type = "",
2529 .params = "",
2530 .help = "show the current VM status (running|paused)",
2531 .user_print = do_info_status_print,
2532 .mhandler.info_new = do_info_status,
2533 },
2534 {
2535 .name = "pcmcia",
2536 .args_type = "",
2537 .params = "",
2538 .help = "show guest PCMCIA status",
2539 .mhandler.info = pcmcia_info,
2540 },
2541 {
2542 .name = "mice",
2543 .args_type = "",
2544 .params = "",
2545 .help = "show which guest mouse is receiving events",
2546 .user_print = do_info_mice_print,
2547 .mhandler.info_new = do_info_mice,
2548 },
2549 {
2550 .name = "vnc",
2551 .args_type = "",
2552 .params = "",
2553 .help = "show the vnc server status",
2554 .user_print = do_info_vnc_print,
2555 .mhandler.info_new = do_info_vnc,
2556 },
2557 {
2558 .name = "name",
2559 .args_type = "",
2560 .params = "",
2561 .help = "show the current VM name",
2562 .user_print = do_info_name_print,
2563 .mhandler.info_new = do_info_name,
2564 },
2565 {
2566 .name = "uuid",
2567 .args_type = "",
2568 .params = "",
2569 .help = "show the current VM UUID",
2570 .user_print = do_info_uuid_print,
2571 .mhandler.info_new = do_info_uuid,
2572 },
2573 #if defined(TARGET_PPC)
2574 {
2575 .name = "cpustats",
2576 .args_type = "",
2577 .params = "",
2578 .help = "show CPU statistics",
2579 .mhandler.info = do_info_cpu_stats,
2580 },
2581 #endif
2582 #if defined(CONFIG_SLIRP)
2583 {
2584 .name = "usernet",
2585 .args_type = "",
2586 .params = "",
2587 .help = "show user network stack connection states",
2588 .mhandler.info = do_info_usernet,
2589 },
2590 #endif
2591 {
2592 .name = "migrate",
2593 .args_type = "",
2594 .params = "",
2595 .help = "show migration status",
2596 .user_print = do_info_migrate_print,
2597 .mhandler.info_new = do_info_migrate,
2598 },
2599 {
2600 .name = "balloon",
2601 .args_type = "",
2602 .params = "",
2603 .help = "show balloon information",
2604 .user_print = monitor_print_balloon,
2605 .mhandler.info_new = do_info_balloon,
2606 },
2607 {
2608 .name = "qtree",
2609 .args_type = "",
2610 .params = "",
2611 .help = "show device tree",
2612 .mhandler.info = do_info_qtree,
2613 },
2614 {
2615 .name = "qdm",
2616 .args_type = "",
2617 .params = "",
2618 .help = "show qdev device model list",
2619 .mhandler.info = do_info_qdm,
2620 },
2621 {
2622 .name = "roms",
2623 .args_type = "",
2624 .params = "",
2625 .help = "show roms",
2626 .mhandler.info = do_info_roms,
2627 },
2628 {
2629 .name = NULL,
2630 },
2631 };
2632
2633 /*******************************************************************/
2634
2635 static const char *pch;
2636 static jmp_buf expr_env;
2637
2638 #define MD_TLONG 0
2639 #define MD_I32 1
2640
2641 typedef struct MonitorDef {
2642 const char *name;
2643 int offset;
2644 target_long (*get_value)(const struct MonitorDef *md, int val);
2645 int type;
2646 } MonitorDef;
2647
2648 #if defined(TARGET_I386)
2649 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2650 {
2651 CPUState *env = mon_get_cpu();
2652 if (!env)
2653 return 0;
2654 return env->eip + env->segs[R_CS].base;
2655 }
2656 #endif
2657
2658 #if defined(TARGET_PPC)
2659 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2660 {
2661 CPUState *env = mon_get_cpu();
2662 unsigned int u;
2663 int i;
2664
2665 if (!env)
2666 return 0;
2667
2668 u = 0;
2669 for (i = 0; i < 8; i++)
2670 u |= env->crf[i] << (32 - (4 * i));
2671
2672 return u;
2673 }
2674
2675 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2676 {
2677 CPUState *env = mon_get_cpu();
2678 if (!env)
2679 return 0;
2680 return env->msr;
2681 }
2682
2683 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2684 {
2685 CPUState *env = mon_get_cpu();
2686 if (!env)
2687 return 0;
2688 return env->xer;
2689 }
2690
2691 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2692 {
2693 CPUState *env = mon_get_cpu();
2694 if (!env)
2695 return 0;
2696 return cpu_ppc_load_decr(env);
2697 }
2698
2699 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2700 {
2701 CPUState *env = mon_get_cpu();
2702 if (!env)
2703 return 0;
2704 return cpu_ppc_load_tbu(env);
2705 }
2706
2707 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2708 {
2709 CPUState *env = mon_get_cpu();
2710 if (!env)
2711 return 0;
2712 return cpu_ppc_load_tbl(env);
2713 }
2714 #endif
2715
2716 #if defined(TARGET_SPARC)
2717 #ifndef TARGET_SPARC64
2718 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2719 {
2720 CPUState *env = mon_get_cpu();
2721 if (!env)
2722 return 0;
2723 return GET_PSR(env);
2724 }
2725 #endif
2726
2727 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2728 {
2729 CPUState *env = mon_get_cpu();
2730 if (!env)
2731 return 0;
2732 return env->regwptr[val];
2733 }
2734 #endif
2735
2736 static const MonitorDef monitor_defs[] = {
2737 #ifdef TARGET_I386
2738
2739 #define SEG(name, seg) \
2740 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2741 { name ".base", offsetof(CPUState, segs[seg].base) },\
2742 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2743
2744 { "eax", offsetof(CPUState, regs[0]) },
2745 { "ecx", offsetof(CPUState, regs[1]) },
2746 { "edx", offsetof(CPUState, regs[2]) },
2747 { "ebx", offsetof(CPUState, regs[3]) },
2748 { "esp|sp", offsetof(CPUState, regs[4]) },
2749 { "ebp|fp", offsetof(CPUState, regs[5]) },
2750 { "esi", offsetof(CPUState, regs[6]) },
2751 { "edi", offsetof(CPUState, regs[7]) },
2752 #ifdef TARGET_X86_64
2753 { "r8", offsetof(CPUState, regs[8]) },
2754 { "r9", offsetof(CPUState, regs[9]) },
2755 { "r10", offsetof(CPUState, regs[10]) },
2756 { "r11", offsetof(CPUState, regs[11]) },
2757 { "r12", offsetof(CPUState, regs[12]) },
2758 { "r13", offsetof(CPUState, regs[13]) },
2759 { "r14", offsetof(CPUState, regs[14]) },
2760 { "r15", offsetof(CPUState, regs[15]) },
2761 #endif
2762 { "eflags", offsetof(CPUState, eflags) },
2763 { "eip", offsetof(CPUState, eip) },
2764 SEG("cs", R_CS)
2765 SEG("ds", R_DS)
2766 SEG("es", R_ES)
2767 SEG("ss", R_SS)
2768 SEG("fs", R_FS)
2769 SEG("gs", R_GS)
2770 { "pc", 0, monitor_get_pc, },
2771 #elif defined(TARGET_PPC)
2772 /* General purpose registers */
2773 { "r0", offsetof(CPUState, gpr[0]) },
2774 { "r1", offsetof(CPUState, gpr[1]) },
2775 { "r2", offsetof(CPUState, gpr[2]) },
2776 { "r3", offsetof(CPUState, gpr[3]) },
2777 { "r4", offsetof(CPUState, gpr[4]) },
2778 { "r5", offsetof(CPUState, gpr[5]) },
2779 { "r6", offsetof(CPUState, gpr[6]) },
2780 { "r7", offsetof(CPUState, gpr[7]) },
2781 { "r8", offsetof(CPUState, gpr[8]) },
2782 { "r9", offsetof(CPUState, gpr[9]) },
2783 { "r10", offsetof(CPUState, gpr[10]) },
2784 { "r11", offsetof(CPUState, gpr[11]) },
2785 { "r12", offsetof(CPUState, gpr[12]) },
2786 { "r13", offsetof(CPUState, gpr[13]) },
2787 { "r14", offsetof(CPUState, gpr[14]) },
2788 { "r15", offsetof(CPUState, gpr[15]) },
2789 { "r16", offsetof(CPUState, gpr[16]) },
2790 { "r17", offsetof(CPUState, gpr[17]) },
2791 { "r18", offsetof(CPUState, gpr[18]) },
2792 { "r19", offsetof(CPUState, gpr[19]) },
2793 { "r20", offsetof(CPUState, gpr[20]) },
2794 { "r21", offsetof(CPUState, gpr[21]) },
2795 { "r22", offsetof(CPUState, gpr[22]) },
2796 { "r23", offsetof(CPUState, gpr[23]) },
2797 { "r24", offsetof(CPUState, gpr[24]) },
2798 { "r25", offsetof(CPUState, gpr[25]) },
2799 { "r26", offsetof(CPUState, gpr[26]) },
2800 { "r27", offsetof(CPUState, gpr[27]) },
2801 { "r28", offsetof(CPUState, gpr[28]) },
2802 { "r29", offsetof(CPUState, gpr[29]) },
2803 { "r30", offsetof(CPUState, gpr[30]) },
2804 { "r31", offsetof(CPUState, gpr[31]) },
2805 /* Floating point registers */
2806 { "f0", offsetof(CPUState, fpr[0]) },
2807 { "f1", offsetof(CPUState, fpr[1]) },
2808 { "f2", offsetof(CPUState, fpr[2]) },
2809 { "f3", offsetof(CPUState, fpr[3]) },
2810 { "f4", offsetof(CPUState, fpr[4]) },
2811 { "f5", offsetof(CPUState, fpr[5]) },
2812 { "f6", offsetof(CPUState, fpr[6]) },
2813 { "f7", offsetof(CPUState, fpr[7]) },
2814 { "f8", offsetof(CPUState, fpr[8]) },
2815 { "f9", offsetof(CPUState, fpr[9]) },
2816 { "f10", offsetof(CPUState, fpr[10]) },
2817 { "f11", offsetof(CPUState, fpr[11]) },
2818 { "f12", offsetof(CPUState, fpr[12]) },
2819 { "f13", offsetof(CPUState, fpr[13]) },
2820 { "f14", offsetof(CPUState, fpr[14]) },
2821 { "f15", offsetof(CPUState, fpr[15]) },
2822 { "f16", offsetof(CPUState, fpr[16]) },
2823 { "f17", offsetof(CPUState, fpr[17]) },
2824 { "f18", offsetof(CPUState, fpr[18]) },
2825 { "f19", offsetof(CPUState, fpr[19]) },
2826 { "f20", offsetof(CPUState, fpr[20]) },
2827 { "f21", offsetof(CPUState, fpr[21]) },
2828 { "f22", offsetof(CPUState, fpr[22]) },
2829 { "f23", offsetof(CPUState, fpr[23]) },
2830 { "f24", offsetof(CPUState, fpr[24]) },
2831 { "f25", offsetof(CPUState, fpr[25]) },
2832 { "f26", offsetof(CPUState, fpr[26]) },
2833 { "f27", offsetof(CPUState, fpr[27]) },
2834 { "f28", offsetof(CPUState, fpr[28]) },
2835 { "f29", offsetof(CPUState, fpr[29]) },
2836 { "f30", offsetof(CPUState, fpr[30]) },
2837 { "f31", offsetof(CPUState, fpr[31]) },
2838 { "fpscr", offsetof(CPUState, fpscr) },
2839 /* Next instruction pointer */
2840 { "nip|pc", offsetof(CPUState, nip) },
2841 { "lr", offsetof(CPUState, lr) },
2842 { "ctr", offsetof(CPUState, ctr) },
2843 { "decr", 0, &monitor_get_decr, },
2844 { "ccr", 0, &monitor_get_ccr, },
2845 /* Machine state register */
2846 { "msr", 0, &monitor_get_msr, },
2847 { "xer", 0, &monitor_get_xer, },
2848 { "tbu", 0, &monitor_get_tbu, },
2849 { "tbl", 0, &monitor_get_tbl, },
2850 #if defined(TARGET_PPC64)
2851 /* Address space register */
2852 { "asr", offsetof(CPUState, asr) },
2853 #endif
2854 /* Segment registers */
2855 { "sdr1", offsetof(CPUState, sdr1) },
2856 { "sr0", offsetof(CPUState, sr[0]) },
2857 { "sr1", offsetof(CPUState, sr[1]) },
2858 { "sr2", offsetof(CPUState, sr[2]) },
2859 { "sr3", offsetof(CPUState, sr[3]) },
2860 { "sr4", offsetof(CPUState, sr[4]) },
2861 { "sr5", offsetof(CPUState, sr[5]) },
2862 { "sr6", offsetof(CPUState, sr[6]) },
2863 { "sr7", offsetof(CPUState, sr[7]) },
2864 { "sr8", offsetof(CPUState, sr[8]) },
2865 { "sr9", offsetof(CPUState, sr[9]) },
2866 { "sr10", offsetof(CPUState, sr[10]) },
2867 { "sr11", offsetof(CPUState, sr[11]) },
2868 { "sr12", offsetof(CPUState, sr[12]) },
2869 { "sr13", offsetof(CPUState, sr[13]) },
2870 { "sr14", offsetof(CPUState, sr[14]) },
2871 { "sr15", offsetof(CPUState, sr[15]) },
2872 /* Too lazy to put BATs and SPRs ... */
2873 #elif defined(TARGET_SPARC)
2874 { "g0", offsetof(CPUState, gregs[0]) },
2875 { "g1", offsetof(CPUState, gregs[1]) },
2876 { "g2", offsetof(CPUState, gregs[2]) },
2877 { "g3", offsetof(CPUState, gregs[3]) },
2878 { "g4", offsetof(CPUState, gregs[4]) },
2879 { "g5", offsetof(CPUState, gregs[5]) },
2880 { "g6", offsetof(CPUState, gregs[6]) },
2881 { "g7", offsetof(CPUState, gregs[7]) },
2882 { "o0", 0, monitor_get_reg },
2883 { "o1", 1, monitor_get_reg },
2884 { "o2", 2, monitor_get_reg },
2885 { "o3", 3, monitor_get_reg },
2886 { "o4", 4, monitor_get_reg },
2887 { "o5", 5, monitor_get_reg },
2888 { "o6", 6, monitor_get_reg },
2889 { "o7", 7, monitor_get_reg },
2890 { "l0", 8, monitor_get_reg },
2891 { "l1", 9, monitor_get_reg },
2892 { "l2", 10, monitor_get_reg },
2893 { "l3", 11, monitor_get_reg },
2894 { "l4", 12, monitor_get_reg },
2895 { "l5", 13, monitor_get_reg },
2896 { "l6", 14, monitor_get_reg },
2897 { "l7", 15, monitor_get_reg },
2898 { "i0", 16, monitor_get_reg },
2899 { "i1", 17, monitor_get_reg },
2900 { "i2", 18, monitor_get_reg },
2901 { "i3", 19, monitor_get_reg },
2902 { "i4", 20, monitor_get_reg },
2903 { "i5", 21, monitor_get_reg },
2904 { "i6", 22, monitor_get_reg },
2905 { "i7", 23, monitor_get_reg },
2906 { "pc", offsetof(CPUState, pc) },
2907 { "npc", offsetof(CPUState, npc) },
2908 { "y", offsetof(CPUState, y) },
2909 #ifndef TARGET_SPARC64
2910 { "psr", 0, &monitor_get_psr, },
2911 { "wim", offsetof(CPUState, wim) },
2912 #endif
2913 { "tbr", offsetof(CPUState, tbr) },
2914 { "fsr", offsetof(CPUState, fsr) },
2915 { "f0", offsetof(CPUState, fpr[0]) },
2916 { "f1", offsetof(CPUState, fpr[1]) },
2917 { "f2", offsetof(CPUState, fpr[2]) },
2918 { "f3", offsetof(CPUState, fpr[3]) },
2919 { "f4", offsetof(CPUState, fpr[4]) },
2920 { "f5", offsetof(CPUState, fpr[5]) },
2921 { "f6", offsetof(CPUState, fpr[6]) },
2922 { "f7", offsetof(CPUState, fpr[7]) },
2923 { "f8", offsetof(CPUState, fpr[8]) },
2924 { "f9", offsetof(CPUState, fpr[9]) },
2925 { "f10", offsetof(CPUState, fpr[10]) },
2926 { "f11", offsetof(CPUState, fpr[11]) },
2927 { "f12", offsetof(CPUState, fpr[12]) },
2928 { "f13", offsetof(CPUState, fpr[13]) },
2929 { "f14", offsetof(CPUState, fpr[14]) },
2930 { "f15", offsetof(CPUState, fpr[15]) },
2931 { "f16", offsetof(CPUState, fpr[16]) },
2932 { "f17", offsetof(CPUState, fpr[17]) },
2933 { "f18", offsetof(CPUState, fpr[18]) },
2934 { "f19", offsetof(CPUState, fpr[19]) },
2935 { "f20", offsetof(CPUState, fpr[20]) },
2936 { "f21", offsetof(CPUState, fpr[21]) },
2937 { "f22", offsetof(CPUState, fpr[22]) },
2938 { "f23", offsetof(CPUState, fpr[23]) },
2939 { "f24", offsetof(CPUState, fpr[24]) },
2940 { "f25", offsetof(CPUState, fpr[25]) },
2941 { "f26", offsetof(CPUState, fpr[26]) },
2942 { "f27", offsetof(CPUState, fpr[27]) },
2943 { "f28", offsetof(CPUState, fpr[28]) },
2944 { "f29", offsetof(CPUState, fpr[29]) },
2945 { "f30", offsetof(CPUState, fpr[30]) },
2946 { "f31", offsetof(CPUState, fpr[31]) },
2947 #ifdef TARGET_SPARC64
2948 { "f32", offsetof(CPUState, fpr[32]) },
2949 { "f34", offsetof(CPUState, fpr[34]) },
2950 { "f36", offsetof(CPUState, fpr[36]) },
2951 { "f38", offsetof(CPUState, fpr[38]) },
2952 { "f40", offsetof(CPUState, fpr[40]) },
2953 { "f42", offsetof(CPUState, fpr[42]) },
2954 { "f44", offsetof(CPUState, fpr[44]) },
2955 { "f46", offsetof(CPUState, fpr[46]) },
2956 { "f48", offsetof(CPUState, fpr[48]) },
2957 { "f50", offsetof(CPUState, fpr[50]) },
2958 { "f52", offsetof(CPUState, fpr[52]) },
2959 { "f54", offsetof(CPUState, fpr[54]) },
2960 { "f56", offsetof(CPUState, fpr[56]) },
2961 { "f58", offsetof(CPUState, fpr[58]) },
2962 { "f60", offsetof(CPUState, fpr[60]) },
2963 { "f62", offsetof(CPUState, fpr[62]) },
2964 { "asi", offsetof(CPUState, asi) },
2965 { "pstate", offsetof(CPUState, pstate) },
2966 { "cansave", offsetof(CPUState, cansave) },
2967 { "canrestore", offsetof(CPUState, canrestore) },
2968 { "otherwin", offsetof(CPUState, otherwin) },
2969 { "wstate", offsetof(CPUState, wstate) },
2970 { "cleanwin", offsetof(CPUState, cleanwin) },
2971 { "fprs", offsetof(CPUState, fprs) },
2972 #endif
2973 #endif
2974 { NULL },
2975 };
2976
2977 static void expr_error(Monitor *mon, const char *msg)
2978 {
2979 monitor_printf(mon, "%s\n", msg);
2980 longjmp(expr_env, 1);
2981 }
2982
2983 /* return 0 if OK, -1 if not found, -2 if no CPU defined */
2984 static int get_monitor_def(target_long *pval, const char *name)
2985 {
2986 const MonitorDef *md;
2987 void *ptr;
2988
2989 for(md = monitor_defs; md->name != NULL; md++) {
2990 if (compare_cmd(name, md->name)) {
2991 if (md->get_value) {
2992 *pval = md->get_value(md, md->offset);
2993 } else {
2994 CPUState *env = mon_get_cpu();
2995 if (!env)
2996 return -2;
2997 ptr = (uint8_t *)env + md->offset;
2998 switch(md->type) {
2999 case MD_I32:
3000 *pval = *(int32_t *)ptr;
3001 break;
3002 case MD_TLONG:
3003 *pval = *(target_long *)ptr;
3004 break;
3005 default:
3006 *pval = 0;
3007 break;
3008 }
3009 }
3010 return 0;
3011 }
3012 }
3013 return -1;
3014 }
3015
3016 static void next(void)
3017 {
3018 if (*pch != '\0') {
3019 pch++;
3020 while (qemu_isspace(*pch))
3021 pch++;
3022 }
3023 }
3024
3025 static int64_t expr_sum(Monitor *mon);
3026
3027 static int64_t expr_unary(Monitor *mon)
3028 {
3029 int64_t n;
3030 char *p;
3031 int ret;
3032
3033 switch(*pch) {
3034 case '+':
3035 next();
3036 n = expr_unary(mon);
3037 break;
3038 case '-':
3039 next();
3040 n = -expr_unary(mon);
3041 break;
3042 case '~':
3043 next();
3044 n = ~expr_unary(mon);
3045 break;
3046 case '(':
3047 next();
3048 n = expr_sum(mon);
3049 if (*pch != ')') {
3050 expr_error(mon, "')' expected");
3051 }
3052 next();
3053 break;
3054 case '\'':
3055 pch++;
3056 if (*pch == '\0')
3057 expr_error(mon, "character constant expected");
3058 n = *pch;
3059 pch++;
3060 if (*pch != '\'')
3061 expr_error(mon, "missing terminating \' character");
3062 next();
3063 break;
3064 case '$':
3065 {
3066 char buf[128], *q;
3067 target_long reg=0;
3068
3069 pch++;
3070 q = buf;
3071 while ((*pch >= 'a' && *pch <= 'z') ||
3072 (*pch >= 'A' && *pch <= 'Z') ||
3073 (*pch >= '0' && *pch <= '9') ||
3074 *pch == '_' || *pch == '.') {
3075 if ((q - buf) < sizeof(buf) - 1)
3076 *q++ = *pch;
3077 pch++;
3078 }
3079 while (qemu_isspace(*pch))
3080 pch++;
3081 *q = 0;
3082 ret = get_monitor_def(&reg, buf);
3083 if (ret == -1)
3084 expr_error(mon, "unknown register");
3085 else if (ret == -2)
3086 expr_error(mon, "no cpu defined");
3087 n = reg;
3088 }
3089 break;
3090 case '\0':
3091 expr_error(mon, "unexpected end of expression");
3092 n = 0;
3093 break;
3094 default:
3095 #if TARGET_PHYS_ADDR_BITS > 32
3096 n = strtoull(pch, &p, 0);
3097 #else
3098 n = strtoul(pch, &p, 0);
3099 #endif
3100 if (pch == p) {
3101 expr_error(mon, "invalid char in expression");
3102 }
3103 pch = p;
3104 while (qemu_isspace(*pch))
3105 pch++;
3106 break;
3107 }
3108 return n;
3109 }
3110
3111
3112 static int64_t expr_prod(Monitor *mon)
3113 {
3114 int64_t val, val2;
3115 int op;
3116
3117 val = expr_unary(mon);
3118 for(;;) {
3119 op = *pch;
3120 if (op != '*' && op != '/' && op != '%')
3121 break;
3122 next();
3123 val2 = expr_unary(mon);
3124 switch(op) {
3125 default:
3126 case '*':
3127 val *= val2;
3128 break;
3129 case '/':
3130 case '%':
3131 if (val2 == 0)
3132 expr_error(mon, "division by zero");
3133 if (op == '/')
3134 val /= val2;
3135 else
3136 val %= val2;
3137 break;
3138 }
3139 }
3140 return val;
3141 }
3142
3143 static int64_t expr_logic(Monitor *mon)
3144 {
3145 int64_t val, val2;
3146 int op;
3147
3148 val = expr_prod(mon);
3149 for(;;) {
3150 op = *pch;
3151 if (op != '&' && op != '|' && op != '^')
3152 break;
3153 next();
3154 val2 = expr_prod(mon);
3155 switch(op) {
3156 default:
3157 case '&':
3158 val &= val2;
3159 break;
3160 case '|':
3161 val |= val2;
3162 break;
3163 case '^':
3164 val ^= val2;
3165 break;
3166 }
3167 }
3168 return val;
3169 }
3170
3171 static int64_t expr_sum(Monitor *mon)
3172 {
3173 int64_t val, val2;
3174 int op;
3175
3176 val = expr_logic(mon);
3177 for(;;) {
3178 op = *pch;
3179 if (op != '+' && op != '-')
3180 break;
3181 next();
3182 val2 = expr_logic(mon);
3183 if (op == '+')
3184 val += val2;
3185 else
3186 val -= val2;
3187 }
3188 return val;
3189 }
3190
3191 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3192 {
3193 pch = *pp;
3194 if (setjmp(expr_env)) {
3195 *pp = pch;
3196 return -1;
3197 }
3198 while (qemu_isspace(*pch))
3199 pch++;
3200 *pval = expr_sum(mon);
3201 *pp = pch;
3202 return 0;
3203 }
3204
3205 static int get_str(char *buf, int buf_size, const char **pp)
3206 {
3207 const char *p;
3208 char *q;
3209 int c;
3210
3211 q = buf;
3212 p = *pp;
3213 while (qemu_isspace(*p))
3214 p++;
3215 if (*p == '\0') {
3216 fail:
3217 *q = '\0';
3218 *pp = p;
3219 return -1;
3220 }
3221 if (*p == '\"') {
3222 p++;
3223 while (*p != '\0' && *p != '\"') {
3224 if (*p == '\\') {
3225 p++;
3226 c = *p++;
3227 switch(c) {
3228 case 'n':
3229 c = '\n';
3230 break;
3231 case 'r':
3232 c = '\r';
3233 break;
3234 case '\\':
3235 case '\'':
3236 case '\"':
3237 break;
3238 default:
3239 qemu_printf("unsupported escape code: '\\%c'\n", c);
3240 goto fail;
3241 }
3242 if ((q - buf) < buf_size - 1) {
3243 *q++ = c;
3244 }
3245 } else {
3246 if ((q - buf) < buf_size - 1) {
3247 *q++ = *p;
3248 }
3249 p++;
3250 }
3251 }
3252 if (*p != '\"') {
3253 qemu_printf("unterminated string\n");
3254 goto fail;
3255 }
3256 p++;
3257 } else {
3258 while (*p != '\0' && !qemu_isspace(*p)) {
3259 if ((q - buf) < buf_size - 1) {
3260 *q++ = *p;
3261 }
3262 p++;
3263 }
3264 }
3265 *q = '\0';
3266 *pp = p;
3267 return 0;
3268 }
3269
3270 /*
3271 * Store the command-name in cmdname, and return a pointer to
3272 * the remaining of the command string.
3273 */
3274 static const char *get_command_name(const char *cmdline,
3275 char *cmdname, size_t nlen)
3276 {
3277 size_t len;
3278 const char *p, *pstart;
3279
3280 p = cmdline;
3281 while (qemu_isspace(*p))
3282 p++;
3283 if (*p == '\0')
3284 return NULL;
3285 pstart = p;
3286 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3287 p++;
3288 len = p - pstart;
3289 if (len > nlen - 1)
3290 len = nlen - 1;
3291 memcpy(cmdname, pstart, len);
3292 cmdname[len] = '\0';
3293 return p;
3294 }
3295
3296 /**
3297 * Read key of 'type' into 'key' and return the current
3298 * 'type' pointer.
3299 */
3300 static char *key_get_info(const char *type, char **key)
3301 {
3302 size_t len;
3303 char *p, *str;
3304
3305 if (*type == ',')
3306 type++;
3307
3308 p = strchr(type, ':');
3309 if (!p) {
3310 *key = NULL;
3311 return NULL;
3312 }
3313 len = p - type;
3314
3315 str = qemu_malloc(len + 1);
3316 memcpy(str, type, len);
3317 str[len] = '\0';
3318
3319 *key = str;
3320 return ++p;
3321 }
3322
3323 static int default_fmt_format = 'x';
3324 static int default_fmt_size = 4;
3325
3326 #define MAX_ARGS 16
3327
3328 static int is_valid_option(const char *c, const char *typestr)
3329 {
3330 char option[3];
3331
3332 option[0] = '-';
3333 option[1] = *c;
3334 option[2] = '\0';
3335
3336 typestr = strstr(typestr, option);
3337 return (typestr != NULL);
3338 }
3339
3340 static const mon_cmd_t *monitor_find_command(const char *cmdname)
3341 {
3342 const mon_cmd_t *cmd;
3343
3344 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3345 if (compare_cmd(cmdname, cmd->name)) {
3346 return cmd;
3347 }
3348 }
3349
3350 return NULL;
3351 }
3352
3353 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3354 const char *cmdline,
3355 QDict *qdict)
3356 {
3357 const char *p, *typestr;
3358 int c;
3359 const mon_cmd_t *cmd;
3360 char cmdname[256];
3361 char buf[1024];
3362 char *key;
3363
3364 #ifdef DEBUG
3365 monitor_printf(mon, "command='%s'\n", cmdline);
3366 #endif
3367
3368 /* extract the command name */
3369 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3370 if (!p)
3371 return NULL;
3372
3373 cmd = monitor_find_command(cmdname);
3374 if (!cmd) {
3375 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3376 return NULL;
3377 }
3378
3379 /* parse the parameters */
3380 typestr = cmd->args_type;
3381 for(;;) {
3382 typestr = key_get_info(typestr, &key);
3383 if (!typestr)
3384 break;
3385 c = *typestr;
3386 typestr++;
3387 switch(c) {
3388 case 'F':
3389 case 'B':
3390 case 's':
3391 {
3392 int ret;
3393
3394 while (qemu_isspace(*p))
3395 p++;
3396 if (*typestr == '?') {
3397 typestr++;
3398 if (*p == '\0') {
3399 /* no optional string: NULL argument */
3400 break;
3401 }
3402 }
3403 ret = get_str(buf, sizeof(buf), &p);
3404 if (ret < 0) {
3405 switch(c) {
3406 case 'F':
3407 monitor_printf(mon, "%s: filename expected\n",
3408 cmdname);
3409 break;
3410 case 'B':
3411 monitor_printf(mon, "%s: block device name expected\n",
3412 cmdname);
3413 break;
3414 default:
3415 monitor_printf(mon, "%s: string expected\n", cmdname);
3416 break;
3417 }
3418 goto fail;
3419 }
3420 qdict_put(qdict, key, qstring_from_str(buf));
3421 }
3422 break;
3423 case '/':
3424 {
3425 int count, format, size;
3426
3427 while (qemu_isspace(*p))
3428 p++;
3429 if (*p == '/') {
3430 /* format found */
3431 p++;
3432 count = 1;
3433 if (qemu_isdigit(*p)) {
3434 count = 0;
3435 while (qemu_isdigit(*p)) {
3436 count = count * 10 + (*p - '0');
3437 p++;
3438 }
3439 }
3440 size = -1;
3441 format = -1;
3442 for(;;) {
3443 switch(*p) {
3444 case 'o':
3445 case 'd':
3446 case 'u':
3447 case 'x':
3448 case 'i':
3449 case 'c':
3450 format = *p++;
3451 break;
3452 case 'b':
3453 size = 1;
3454 p++;
3455 break;
3456 case 'h':
3457 size = 2;
3458 p++;
3459 break;
3460 case 'w':
3461 size = 4;
3462 p++;
3463 break;
3464 case 'g':
3465 case 'L':
3466 size = 8;
3467 p++;
3468 break;
3469 default:
3470 goto next;
3471 }
3472 }
3473 next:
3474 if (*p != '\0' && !qemu_isspace(*p)) {
3475 monitor_printf(mon, "invalid char in format: '%c'\n",
3476 *p);
3477 goto fail;
3478 }
3479 if (format < 0)
3480 format = default_fmt_format;
3481 if (format != 'i') {
3482 /* for 'i', not specifying a size gives -1 as size */
3483 if (size < 0)
3484 size = default_fmt_size;
3485 default_fmt_size = size;
3486 }
3487 default_fmt_format = format;
3488 } else {
3489 count = 1;
3490 format = default_fmt_format;
3491 if (format != 'i') {
3492 size = default_fmt_size;
3493 } else {
3494 size = -1;
3495 }
3496 }
3497 qdict_put(qdict, "count", qint_from_int(count));
3498 qdict_put(qdict, "format", qint_from_int(format));
3499 qdict_put(qdict, "size", qint_from_int(size));
3500 }
3501 break;
3502 case 'i':
3503 case 'l':
3504 case 'M':
3505 {
3506 int64_t val;
3507
3508 while (qemu_isspace(*p))
3509 p++;
3510 if (*typestr == '?' || *typestr == '.') {
3511 if (*typestr == '?') {
3512 if (*p == '\0') {
3513 typestr++;
3514 break;
3515 }
3516 } else {
3517 if (*p == '.') {
3518 p++;
3519 while (qemu_isspace(*p))
3520 p++;
3521 } else {
3522 typestr++;
3523 break;
3524 }
3525 }
3526 typestr++;
3527 }
3528 if (get_expr(mon, &val, &p))
3529 goto fail;
3530 /* Check if 'i' is greater than 32-bit */
3531 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3532 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3533 monitor_printf(mon, "integer is for 32-bit values\n");
3534 goto fail;
3535 } else if (c == 'M') {
3536 val <<= 20;
3537 }
3538 qdict_put(qdict, key, qint_from_int(val));
3539 }
3540 break;
3541 case '-':
3542 {
3543 const char *tmp = p;
3544 int has_option, skip_key = 0;
3545 /* option */
3546
3547 c = *typestr++;
3548 if (c == '\0')
3549 goto bad_type;
3550 while (qemu_isspace(*p))
3551 p++;
3552 has_option = 0;
3553 if (*p == '-') {
3554 p++;
3555 if(c != *p) {
3556 if(!is_valid_option(p, typestr)) {
3557
3558 monitor_printf(mon, "%s: unsupported option -%c\n",
3559 cmdname, *p);
3560 goto fail;
3561 } else {
3562 skip_key = 1;
3563 }
3564 }
3565 if(skip_key) {
3566 p = tmp;
3567 } else {
3568 p++;
3569 has_option = 1;
3570 }
3571 }
3572 qdict_put(qdict, key, qint_from_int(has_option));
3573 }
3574 break;
3575 default:
3576 bad_type:
3577 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3578 goto fail;
3579 }
3580 qemu_free(key);
3581 key = NULL;
3582 }
3583 /* check that all arguments were parsed */
3584 while (qemu_isspace(*p))
3585 p++;
3586 if (*p != '\0') {
3587 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3588 cmdname);
3589 goto fail;
3590 }
3591
3592 return cmd;
3593
3594 fail:
3595 qemu_free(key);
3596 return NULL;
3597 }
3598
3599 static void monitor_print_error(Monitor *mon)
3600 {
3601 qerror_print(mon->error);
3602 QDECREF(mon->error);
3603 mon->error = NULL;
3604 }
3605
3606 static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3607 const QDict *params)
3608 {
3609 QObject *data = NULL;
3610
3611 cmd->mhandler.cmd_new(mon, params, &data);
3612
3613 if (monitor_ctrl_mode(mon)) {
3614 /* Monitor Protocol */
3615 monitor_protocol_emitter(mon, data);
3616 } else {
3617 /* User Protocol */
3618 if (data)
3619 cmd->user_print(mon, data);
3620 }
3621
3622 qobject_decref(data);
3623 }
3624
3625 static void handle_user_command(Monitor *mon, const char *cmdline)
3626 {
3627 QDict *qdict;
3628 const mon_cmd_t *cmd;
3629
3630 qdict = qdict_new();
3631
3632 cmd = monitor_parse_command(mon, cmdline, qdict);
3633 if (!cmd)
3634 goto out;
3635
3636 qemu_errors_to_mon(mon);
3637
3638 if (monitor_handler_ported(cmd)) {
3639 monitor_call_handler(mon, cmd, qdict);
3640 } else {
3641 cmd->mhandler.cmd(mon, qdict);
3642 }
3643
3644 if (monitor_has_error(mon))
3645 monitor_print_error(mon);
3646
3647 qemu_errors_to_previous();
3648
3649 out:
3650 QDECREF(qdict);
3651 }
3652
3653 static void cmd_completion(const char *name, const char *list)
3654 {
3655 const char *p, *pstart;
3656 char cmd[128];
3657 int len;
3658
3659 p = list;
3660 for(;;) {
3661 pstart = p;
3662 p = strchr(p, '|');
3663 if (!p)
3664 p = pstart + strlen(pstart);
3665 len = p - pstart;
3666 if (len > sizeof(cmd) - 2)
3667 len = sizeof(cmd) - 2;
3668 memcpy(cmd, pstart, len);
3669 cmd[len] = '\0';
3670 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3671 readline_add_completion(cur_mon->rs, cmd);
3672 }
3673 if (*p == '\0')
3674 break;
3675 p++;
3676 }
3677 }
3678
3679 static void file_completion(const char *input)
3680 {
3681 DIR *ffs;
3682 struct dirent *d;
3683 char path[1024];
3684 char file[1024], file_prefix[1024];
3685 int input_path_len;
3686 const char *p;
3687
3688 p = strrchr(input, '/');
3689 if (!p) {
3690 input_path_len = 0;
3691 pstrcpy(file_prefix, sizeof(file_prefix), input);
3692 pstrcpy(path, sizeof(path), ".");
3693 } else {
3694 input_path_len = p - input + 1;
3695 memcpy(path, input, input_path_len);
3696 if (input_path_len > sizeof(path) - 1)
3697 input_path_len = sizeof(path) - 1;
3698 path[input_path_len] = '\0';
3699 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3700 }
3701 #ifdef DEBUG_COMPLETION
3702 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3703 input, path, file_prefix);
3704 #endif
3705 ffs = opendir(path);
3706 if (!ffs)
3707 return;
3708 for(;;) {
3709 struct stat sb;
3710 d = readdir(ffs);
3711 if (!d)
3712 break;
3713 if (strstart(d->d_name, file_prefix, NULL)) {
3714 memcpy(file, input, input_path_len);
3715 if (input_path_len < sizeof(file))
3716 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3717 d->d_name);
3718 /* stat the file to find out if it's a directory.
3719 * In that case add a slash to speed up typing long paths
3720 */
3721 stat(file, &sb);
3722 if(S_ISDIR(sb.st_mode))
3723 pstrcat(file, sizeof(file), "/");
3724 readline_add_completion(cur_mon->rs, file);
3725 }
3726 }
3727 closedir(ffs);
3728 }
3729
3730 static void block_completion_it(void *opaque, BlockDriverState *bs)
3731 {
3732 const char *name = bdrv_get_device_name(bs);
3733 const char *input = opaque;
3734
3735 if (input[0] == '\0' ||
3736 !strncmp(name, (char *)input, strlen(input))) {
3737 readline_add_completion(cur_mon->rs, name);
3738 }
3739 }
3740
3741 /* NOTE: this parser is an approximate form of the real command parser */
3742 static void parse_cmdline(const char *cmdline,
3743 int *pnb_args, char **args)
3744 {
3745 const char *p;
3746 int nb_args, ret;
3747 char buf[1024];
3748
3749 p = cmdline;
3750 nb_args = 0;
3751 for(;;) {
3752 while (qemu_isspace(*p))
3753 p++;
3754 if (*p == '\0')
3755 break;
3756 if (nb_args >= MAX_ARGS)
3757 break;
3758 ret = get_str(buf, sizeof(buf), &p);
3759 args[nb_args] = qemu_strdup(buf);
3760 nb_args++;
3761 if (ret < 0)
3762 break;
3763 }
3764 *pnb_args = nb_args;
3765 }
3766
3767 static const char *next_arg_type(const char *typestr)
3768 {
3769 const char *p = strchr(typestr, ':');
3770 return (p != NULL ? ++p : typestr);
3771 }
3772
3773 static void monitor_find_completion(const char *cmdline)
3774 {
3775 const char *cmdname;
3776 char *args[MAX_ARGS];
3777 int nb_args, i, len;
3778 const char *ptype, *str;
3779 const mon_cmd_t *cmd;
3780 const KeyDef *key;
3781
3782 parse_cmdline(cmdline, &nb_args, args);
3783 #ifdef DEBUG_COMPLETION
3784 for(i = 0; i < nb_args; i++) {
3785 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
3786 }
3787 #endif
3788
3789 /* if the line ends with a space, it means we want to complete the
3790 next arg */
3791 len = strlen(cmdline);
3792 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3793 if (nb_args >= MAX_ARGS)
3794 return;
3795 args[nb_args++] = qemu_strdup("");
3796 }
3797 if (nb_args <= 1) {
3798 /* command completion */
3799 if (nb_args == 0)
3800 cmdname = "";
3801 else
3802 cmdname = args[0];
3803 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
3804 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
3805 cmd_completion(cmdname, cmd->name);
3806 }
3807 } else {
3808 /* find the command */
3809 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
3810 if (compare_cmd(args[0], cmd->name))
3811 goto found;
3812 }
3813 return;
3814 found:
3815 ptype = next_arg_type(cmd->args_type);
3816 for(i = 0; i < nb_args - 2; i++) {
3817 if (*ptype != '\0') {
3818 ptype = next_arg_type(ptype);
3819 while (*ptype == '?')
3820 ptype = next_arg_type(ptype);
3821 }
3822 }
3823 str = args[nb_args - 1];
3824 if (*ptype == '-' && ptype[1] != '\0') {
3825 ptype += 2;
3826 }
3827 switch(*ptype) {
3828 case 'F':
3829 /* file completion */
3830 readline_set_completion_index(cur_mon->rs, strlen(str));
3831 file_completion(str);
3832 break;
3833 case 'B':
3834 /* block device name completion */
3835 readline_set_completion_index(cur_mon->rs, strlen(str));
3836 bdrv_iterate(block_completion_it, (void *)str);
3837 break;
3838 case 's':
3839 /* XXX: more generic ? */
3840 if (!strcmp(cmd->name, "info")) {
3841 readline_set_completion_index(cur_mon->rs, strlen(str));
3842 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
3843 cmd_completion(str, cmd->name);
3844 }
3845 } else if (!strcmp(cmd->name, "sendkey")) {
3846 char *sep = strrchr(str, '-');
3847 if (sep)
3848 str = sep + 1;
3849 readline_set_completion_index(cur_mon->rs, strlen(str));
3850 for(key = key_defs; key->name != NULL; key++) {
3851 cmd_completion(str, key->name);
3852 }
3853 } else if (!strcmp(cmd->name, "help|?")) {
3854 readline_set_completion_index(cur_mon->rs, strlen(str));
3855 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3856 cmd_completion(str, cmd->name);
3857 }
3858 }
3859 break;
3860 default:
3861 break;
3862 }
3863 }
3864 for(i = 0; i < nb_args; i++)
3865 qemu_free(args[i]);
3866 }
3867
3868 static int monitor_can_read(void *opaque)
3869 {
3870 Monitor *mon = opaque;
3871
3872 return (mon->suspend_cnt == 0) ? 1 : 0;
3873 }
3874
3875 typedef struct CmdArgs {
3876 QString *name;
3877 int type;
3878 int flag;
3879 int optional;
3880 } CmdArgs;
3881
3882 static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
3883 {
3884 if (!cmd_args->optional) {
3885 qemu_error_new(QERR_MISSING_PARAMETER, name);
3886 return -1;
3887 }
3888
3889 if (cmd_args->type == '-') {
3890 /* handlers expect a value, they need to be changed */
3891 qdict_put(args, name, qint_from_int(0));
3892 }
3893
3894 return 0;
3895 }
3896
3897 static int check_arg(const CmdArgs *cmd_args, QDict *args)
3898 {
3899 QObject *value;
3900 const char *name;
3901
3902 name = qstring_get_str(cmd_args->name);
3903
3904 if (!args) {
3905 return check_opt(cmd_args, name, args);
3906 }
3907
3908 value = qdict_get(args, name);
3909 if (!value) {
3910 return check_opt(cmd_args, name, args);
3911 }
3912
3913 switch (cmd_args->type) {
3914 case 'F':
3915 case 'B':
3916 case 's':
3917 if (qobject_type(value) != QTYPE_QSTRING) {
3918 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "string");
3919 return -1;
3920 }
3921 break;
3922 case '/': {
3923 int i;
3924 const char *keys[] = { "count", "format", "size", NULL };
3925
3926 for (i = 0; keys[i]; i++) {
3927 QObject *obj = qdict_get(args, keys[i]);
3928 if (!obj) {
3929 qemu_error_new(QERR_MISSING_PARAMETER, name);
3930 return -1;
3931 }
3932 if (qobject_type(obj) != QTYPE_QINT) {
3933 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
3934 return -1;
3935 }
3936 }
3937 break;
3938 }
3939 case 'i':
3940 case 'l':
3941 case 'M':
3942 if (qobject_type(value) != QTYPE_QINT) {
3943 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
3944 return -1;
3945 }
3946 break;
3947 case '-':
3948 if (qobject_type(value) != QTYPE_QINT &&
3949 qobject_type(value) != QTYPE_QBOOL) {
3950 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "bool");
3951 return -1;
3952 }
3953 if (qobject_type(value) == QTYPE_QBOOL) {
3954 /* handlers expect a QInt, they need to be changed */
3955 qdict_put(args, name,
3956 qint_from_int(qbool_get_int(qobject_to_qbool(value))));
3957 }
3958 break;
3959 default:
3960 /* impossible */
3961 abort();
3962 }
3963
3964 return 0;
3965 }
3966
3967 static void cmd_args_init(CmdArgs *cmd_args)
3968 {
3969 cmd_args->name = qstring_new();
3970 cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
3971 }
3972
3973 /*
3974 * This is not trivial, we have to parse Monitor command's argument
3975 * type syntax to be able to check the arguments provided by clients.
3976 *
3977 * In the near future we will be using an array for that and will be
3978 * able to drop all this parsing...
3979 */
3980 static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
3981 {
3982 int err;
3983 const char *p;
3984 CmdArgs cmd_args;
3985
3986 if (cmd->args_type == NULL) {
3987 return (qdict_size(args) == 0 ? 0 : -1);
3988 }
3989
3990 err = 0;
3991 cmd_args_init(&cmd_args);
3992
3993 for (p = cmd->args_type;; p++) {
3994 if (*p == ':') {
3995 cmd_args.type = *++p;
3996 p++;
3997 if (cmd_args.type == '-') {
3998 cmd_args.flag = *p++;
3999 cmd_args.optional = 1;
4000 } else if (*p == '?') {
4001 cmd_args.optional = 1;
4002 p++;
4003 }
4004
4005 assert(*p == ',' || *p == '\0');
4006 err = check_arg(&cmd_args, args);
4007
4008 QDECREF(cmd_args.name);
4009 cmd_args_init(&cmd_args);
4010
4011 if (err < 0) {
4012 break;
4013 }
4014 } else {
4015 qstring_append_chr(cmd_args.name, *p);
4016 }
4017
4018 if (*p == '\0') {
4019 break;
4020 }
4021 }
4022
4023 QDECREF(cmd_args.name);
4024 return err;
4025 }
4026
4027 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4028 {
4029 int err;
4030 QObject *obj;
4031 QDict *input, *args;
4032 const mon_cmd_t *cmd;
4033 Monitor *mon = cur_mon;
4034 const char *cmd_name, *info_item;
4035
4036 args = NULL;
4037 qemu_errors_to_mon(mon);
4038
4039 obj = json_parser_parse(tokens, NULL);
4040 if (!obj) {
4041 // FIXME: should be triggered in json_parser_parse()
4042 qemu_error_new(QERR_JSON_PARSING);
4043 goto err_out;
4044 } else if (qobject_type(obj) != QTYPE_QDICT) {
4045 qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "object");
4046 qobject_decref(obj);
4047 goto err_out;
4048 }
4049
4050 input = qobject_to_qdict(obj);
4051
4052 mon->mc->id = qdict_get(input, "id");
4053 qobject_incref(mon->mc->id);
4054
4055 obj = qdict_get(input, "execute");
4056 if (!obj) {
4057 qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4058 goto err_input;
4059 } else if (qobject_type(obj) != QTYPE_QSTRING) {
4060 qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "string");
4061 goto err_input;
4062 }
4063
4064 cmd_name = qstring_get_str(qobject_to_qstring(obj));
4065
4066 /*
4067 * XXX: We need this special case until we get info handlers
4068 * converted into 'query-' commands
4069 */
4070 if (compare_cmd(cmd_name, "info")) {
4071 qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
4072 goto err_input;
4073 } else if (strstart(cmd_name, "query-", &info_item)) {
4074 cmd = monitor_find_command("info");
4075 qdict_put_obj(input, "arguments",
4076 qobject_from_jsonf("{ 'item': %s }", info_item));
4077 } else {
4078 cmd = monitor_find_command(cmd_name);
4079 if (!cmd || !monitor_handler_ported(cmd)) {
4080 qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
4081 goto err_input;
4082 }
4083 }
4084
4085 obj = qdict_get(input, "arguments");
4086 if (!obj) {
4087 args = qdict_new();
4088 } else {
4089 args = qobject_to_qdict(obj);
4090 QINCREF(args);
4091 }
4092
4093 QDECREF(input);
4094
4095 err = monitor_check_qmp_args(cmd, args);
4096 if (err < 0) {
4097 goto err_out;
4098 }
4099
4100 monitor_call_handler(mon, cmd, args);
4101 goto out;
4102
4103 err_input:
4104 QDECREF(input);
4105 err_out:
4106 monitor_protocol_emitter(mon, NULL);
4107 out:
4108 QDECREF(args);
4109 qemu_errors_to_previous();
4110 }
4111
4112 /**
4113 * monitor_control_read(): Read and handle QMP input
4114 */
4115 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4116 {
4117 Monitor *old_mon = cur_mon;
4118
4119 cur_mon = opaque;
4120
4121 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4122
4123 cur_mon = old_mon;
4124 }
4125
4126 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4127 {
4128 Monitor *old_mon = cur_mon;
4129 int i;
4130
4131 cur_mon = opaque;
4132
4133 if (cur_mon->rs) {
4134 for (i = 0; i < size; i++)
4135 readline_handle_byte(cur_mon->rs, buf[i]);
4136 } else {
4137 if (size == 0 || buf[size - 1] != 0)
4138 monitor_printf(cur_mon, "corrupted command\n");
4139 else
4140 handle_user_command(cur_mon, (char *)buf);
4141 }
4142
4143 cur_mon = old_mon;
4144 }
4145
4146 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4147 {
4148 monitor_suspend(mon);
4149 handle_user_command(mon, cmdline);
4150 monitor_resume(mon);
4151 }
4152
4153 int monitor_suspend(Monitor *mon)
4154 {
4155 if (!mon->rs)
4156 return -ENOTTY;
4157 mon->suspend_cnt++;
4158 return 0;
4159 }
4160
4161 void monitor_resume(Monitor *mon)
4162 {
4163 if (!mon->rs)
4164 return;
4165 if (--mon->suspend_cnt == 0)
4166 readline_show_prompt(mon->rs);
4167 }
4168
4169 /**
4170 * monitor_control_event(): Print QMP gretting
4171 */
4172 static void monitor_control_event(void *opaque, int event)
4173 {
4174 if (event == CHR_EVENT_OPENED) {
4175 QObject *data;
4176 Monitor *mon = opaque;
4177
4178 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4179
4180 data = qobject_from_jsonf("{ 'QMP': { 'capabilities': [] } }");
4181 assert(data != NULL);
4182
4183 monitor_json_emitter(mon, data);
4184 qobject_decref(data);
4185 }
4186 }
4187
4188 static void monitor_event(void *opaque, int event)
4189 {
4190 Monitor *mon = opaque;
4191
4192 switch (event) {
4193 case CHR_EVENT_MUX_IN:
4194 mon->mux_out = 0;
4195 if (mon->reset_seen) {
4196 readline_restart(mon->rs);
4197 monitor_resume(mon);
4198 monitor_flush(mon);
4199 } else {
4200 mon->suspend_cnt = 0;
4201 }
4202 break;
4203
4204 case CHR_EVENT_MUX_OUT:
4205 if (mon->reset_seen) {
4206 if (mon->suspend_cnt == 0) {
4207 monitor_printf(mon, "\n");
4208 }
4209 monitor_flush(mon);
4210 monitor_suspend(mon);
4211 } else {
4212 mon->suspend_cnt++;
4213 }
4214 mon->mux_out = 1;
4215 break;
4216
4217 case CHR_EVENT_OPENED:
4218 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4219 "information\n", QEMU_VERSION);
4220 if (!mon->mux_out) {
4221 readline_show_prompt(mon->rs);
4222 }
4223 mon->reset_seen = 1;
4224 break;
4225 }
4226 }
4227
4228
4229 /*
4230 * Local variables:
4231 * c-indent-level: 4
4232 * c-basic-offset: 4
4233 * tab-width: 8
4234 * End:
4235 */
4236
4237 void monitor_init(CharDriverState *chr, int flags)
4238 {
4239 static int is_first_init = 1;
4240 Monitor *mon;
4241
4242 if (is_first_init) {
4243 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4244 is_first_init = 0;
4245 }
4246
4247 mon = qemu_mallocz(sizeof(*mon));
4248
4249 mon->chr = chr;
4250 mon->flags = flags;
4251 if (flags & MONITOR_USE_READLINE) {
4252 mon->rs = readline_init(mon, monitor_find_completion);
4253 monitor_read_command(mon, 0);
4254 }
4255
4256 if (monitor_ctrl_mode(mon)) {
4257 mon->mc = qemu_mallocz(sizeof(MonitorControl));
4258 /* Control mode requires special handlers */
4259 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4260 monitor_control_event, mon);
4261 } else {
4262 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4263 monitor_event, mon);
4264 }
4265
4266 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4267 if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
4268 cur_mon = mon;
4269 }
4270
4271 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4272 {
4273 BlockDriverState *bs = opaque;
4274 int ret = 0;
4275
4276 if (bdrv_set_key(bs, password) != 0) {
4277 monitor_printf(mon, "invalid password\n");
4278 ret = -EPERM;
4279 }
4280 if (mon->password_completion_cb)
4281 mon->password_completion_cb(mon->password_opaque, ret);
4282
4283 monitor_read_command(mon, 1);
4284 }
4285
4286 void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4287 BlockDriverCompletionFunc *completion_cb,
4288 void *opaque)
4289 {
4290 int err;
4291
4292 if (!bdrv_key_required(bs)) {
4293 if (completion_cb)
4294 completion_cb(opaque, 0);
4295 return;
4296 }
4297
4298 if (monitor_ctrl_mode(mon)) {
4299 qemu_error_new(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4300 return;
4301 }
4302
4303 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4304 bdrv_get_encrypted_filename(bs));
4305
4306 mon->password_completion_cb = completion_cb;
4307 mon->password_opaque = opaque;
4308
4309 err = monitor_read_password(mon, bdrv_password_cb, bs);
4310
4311 if (err && completion_cb)
4312 completion_cb(opaque, err);
4313 }
4314
4315 typedef struct QemuErrorSink QemuErrorSink;
4316 struct QemuErrorSink {
4317 enum {
4318 ERR_SINK_FILE,
4319 ERR_SINK_MONITOR,
4320 } dest;
4321 union {
4322 FILE *fp;
4323 Monitor *mon;
4324 };
4325 QemuErrorSink *previous;
4326 };
4327
4328 static QemuErrorSink *qemu_error_sink;
4329
4330 void qemu_errors_to_file(FILE *fp)
4331 {
4332 QemuErrorSink *sink;
4333
4334 sink = qemu_mallocz(sizeof(*sink));
4335 sink->dest = ERR_SINK_FILE;
4336 sink->fp = fp;
4337 sink->previous = qemu_error_sink;
4338 qemu_error_sink = sink;
4339 }
4340
4341 void qemu_errors_to_mon(Monitor *mon)
4342 {
4343 QemuErrorSink *sink;
4344
4345 sink = qemu_mallocz(sizeof(*sink));
4346 sink->dest = ERR_SINK_MONITOR;
4347 sink->mon = mon;
4348 sink->previous = qemu_error_sink;
4349 qemu_error_sink = sink;
4350 }
4351
4352 void qemu_errors_to_previous(void)
4353 {
4354 QemuErrorSink *sink;
4355
4356 assert(qemu_error_sink != NULL);
4357 sink = qemu_error_sink;
4358 qemu_error_sink = sink->previous;
4359 qemu_free(sink);
4360 }
4361
4362 void qemu_error(const char *fmt, ...)
4363 {
4364 va_list args;
4365
4366 assert(qemu_error_sink != NULL);
4367 switch (qemu_error_sink->dest) {
4368 case ERR_SINK_FILE:
4369 va_start(args, fmt);
4370 vfprintf(qemu_error_sink->fp, fmt, args);
4371 va_end(args);
4372 break;
4373 case ERR_SINK_MONITOR:
4374 va_start(args, fmt);
4375 monitor_vprintf(qemu_error_sink->mon, fmt, args);
4376 va_end(args);
4377 break;
4378 }
4379 }
4380
4381 void qemu_error_internal(const char *file, int linenr, const char *func,
4382 const char *fmt, ...)
4383 {
4384 va_list va;
4385 QError *qerror;
4386
4387 assert(qemu_error_sink != NULL);
4388
4389 va_start(va, fmt);
4390 qerror = qerror_from_info(file, linenr, func, fmt, &va);
4391 va_end(va);
4392
4393 switch (qemu_error_sink->dest) {
4394 case ERR_SINK_FILE:
4395 qerror_print(qerror);
4396 QDECREF(qerror);
4397 break;
4398 case ERR_SINK_MONITOR:
4399 assert(qemu_error_sink->mon->error == NULL);
4400 qemu_error_sink->mon->error = qerror;
4401 break;
4402 }
4403 }
Qemu copy for testing