Annotation of qemu/monitor.c, revision 1.1.1.11

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

unix.superglobalmegacorp.com