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

unix.superglobalmegacorp.com