File:  [Qemu by Fabrice Bellard] / qemu / monitor.c
Revision 1.1.1.14 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:34:05 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

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

unix.superglobalmegacorp.com