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