File:  [Qemu by Fabrice Bellard] / qemu / monitor.c
Revision 1.1.1.15 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:56:21 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

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

unix.superglobalmegacorp.com