Annotation of qemu/monitor.c, revision 1.1.1.17

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

unix.superglobalmegacorp.com