Annotation of qemu/monitor.c, revision 1.1.1.9

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.6   root       32: #include "gdbstub.h"
                     33: #include "net.h"
                     34: #include "qemu-char.h"
                     35: #include "sysemu.h"
1.1.1.9 ! root       36: #include "monitor.h"
        !            37: #include "readline.h"
1.1.1.6   root       38: #include "console.h"
                     39: #include "block.h"
                     40: #include "audio/audio.h"
1.1       root       41: #include "disas.h"
1.1.1.7   root       42: #include "balloon.h"
                     43: #include "qemu-timer.h"
                     44: #include "migration.h"
                     45: #include "kvm.h"
1.1.1.9 ! root       46: #include "acl.h"
1.1.1.6   root       47: 
1.1       root       48: //#define DEBUG
                     49: //#define DEBUG_COMPLETION
                     50: 
                     51: /*
                     52:  * Supported types:
1.1.1.6   root       53:  *
1.1       root       54:  * 'F'          filename
                     55:  * 'B'          block device name
                     56:  * 's'          string (accept optional quote)
                     57:  * 'i'          32 bit integer
                     58:  * 'l'          target long (32 or 64 bit)
                     59:  * '/'          optional gdb-like print format (like "/10x")
                     60:  *
                     61:  * '?'          optional type (for 'F', 's' and 'i')
                     62:  *
                     63:  */
                     64: 
1.1.1.9 ! root       65: typedef struct mon_cmd_t {
1.1       root       66:     const char *name;
                     67:     const char *args_type;
1.1.1.7   root       68:     void *handler;
1.1       root       69:     const char *params;
                     70:     const char *help;
1.1.1.9 ! root       71: } mon_cmd_t;
1.1       root       72: 
1.1.1.9 ! root       73: /* file descriptors passed via SCM_RIGHTS */
        !            74: typedef struct mon_fd_t mon_fd_t;
        !            75: struct mon_fd_t {
        !            76:     char *name;
        !            77:     int fd;
        !            78:     LIST_ENTRY(mon_fd_t) next;
        !            79: };
        !            80: 
        !            81: struct Monitor {
        !            82:     CharDriverState *chr;
        !            83:     int flags;
        !            84:     int suspend_cnt;
        !            85:     uint8_t outbuf[1024];
        !            86:     int outbuf_index;
        !            87:     ReadLineState *rs;
        !            88:     CPUState *mon_cpu;
        !            89:     BlockDriverCompletionFunc *password_completion_cb;
        !            90:     void *password_opaque;
        !            91:     LIST_HEAD(,mon_fd_t) fds;
        !            92:     LIST_ENTRY(Monitor) entry;
        !            93: };
1.1       root       94: 
1.1.1.9 ! root       95: static LIST_HEAD(mon_list, Monitor) mon_list;
1.1       root       96: 
1.1.1.9 ! root       97: static const mon_cmd_t mon_cmds[];
        !            98: static const mon_cmd_t info_cmds[];
1.1       root       99: 
1.1.1.9 ! root      100: Monitor *cur_mon = NULL;
1.1       root      101: 
1.1.1.9 ! root      102: static void monitor_command_cb(Monitor *mon, const char *cmdline,
        !           103:                                void *opaque);
1.1.1.2   root      104: 
1.1.1.9 ! root      105: static void monitor_read_command(Monitor *mon, int show_prompt)
1.1       root      106: {
1.1.1.9 ! root      107:     readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
        !           108:     if (show_prompt)
        !           109:         readline_show_prompt(mon->rs);
        !           110: }
        !           111: 
        !           112: static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
        !           113:                                  void *opaque)
        !           114: {
        !           115:     if (mon->rs) {
        !           116:         readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
        !           117:         /* prompt is printed on return from the command handler */
        !           118:         return 0;
        !           119:     } else {
        !           120:         monitor_printf(mon, "terminal does not support password prompting\n");
        !           121:         return -ENOTTY;
        !           122:     }
        !           123: }
        !           124: 
        !           125: void monitor_flush(Monitor *mon)
        !           126: {
        !           127:     if (mon && mon->outbuf_index != 0 && mon->chr->focus == 0) {
        !           128:         qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
        !           129:         mon->outbuf_index = 0;
1.1       root      130:     }
                    131: }
                    132: 
                    133: /* flush at every end of line or if the buffer is full */
1.1.1.9 ! root      134: static void monitor_puts(Monitor *mon, const char *str)
1.1       root      135: {
1.1.1.6   root      136:     char c;
1.1.1.9 ! root      137: 
        !           138:     if (!mon)
        !           139:         return;
        !           140: 
1.1       root      141:     for(;;) {
                    142:         c = *str++;
                    143:         if (c == '\0')
                    144:             break;
1.1.1.4   root      145:         if (c == '\n')
1.1.1.9 ! root      146:             mon->outbuf[mon->outbuf_index++] = '\r';
        !           147:         mon->outbuf[mon->outbuf_index++] = c;
        !           148:         if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
        !           149:             || c == '\n')
        !           150:             monitor_flush(mon);
1.1       root      151:     }
                    152: }
                    153: 
1.1.1.9 ! root      154: void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
1.1       root      155: {
                    156:     char buf[4096];
                    157:     vsnprintf(buf, sizeof(buf), fmt, ap);
1.1.1.9 ! root      158:     monitor_puts(mon, buf);
1.1       root      159: }
                    160: 
1.1.1.9 ! root      161: void monitor_printf(Monitor *mon, const char *fmt, ...)
1.1       root      162: {
                    163:     va_list ap;
                    164:     va_start(ap, fmt);
1.1.1.9 ! root      165:     monitor_vprintf(mon, fmt, ap);
1.1       root      166:     va_end(ap);
                    167: }
                    168: 
1.1.1.9 ! root      169: void monitor_print_filename(Monitor *mon, const char *filename)
1.1.1.5   root      170: {
                    171:     int i;
                    172: 
                    173:     for (i = 0; filename[i]; i++) {
1.1.1.9 ! root      174:         switch (filename[i]) {
        !           175:         case ' ':
        !           176:         case '"':
        !           177:         case '\\':
        !           178:             monitor_printf(mon, "\\%c", filename[i]);
        !           179:             break;
        !           180:         case '\t':
        !           181:             monitor_printf(mon, "\\t");
        !           182:             break;
        !           183:         case '\r':
        !           184:             monitor_printf(mon, "\\r");
        !           185:             break;
        !           186:         case '\n':
        !           187:             monitor_printf(mon, "\\n");
        !           188:             break;
        !           189:         default:
        !           190:             monitor_printf(mon, "%c", filename[i]);
        !           191:             break;
        !           192:         }
1.1.1.5   root      193:     }
                    194: }
                    195: 
1.1       root      196: static int monitor_fprintf(FILE *stream, const char *fmt, ...)
                    197: {
                    198:     va_list ap;
                    199:     va_start(ap, fmt);
1.1.1.9 ! root      200:     monitor_vprintf((Monitor *)stream, fmt, ap);
1.1       root      201:     va_end(ap);
                    202:     return 0;
                    203: }
                    204: 
                    205: static int compare_cmd(const char *name, const char *list)
                    206: {
                    207:     const char *p, *pstart;
                    208:     int len;
                    209:     len = strlen(name);
                    210:     p = list;
                    211:     for(;;) {
                    212:         pstart = p;
                    213:         p = strchr(p, '|');
                    214:         if (!p)
                    215:             p = pstart + strlen(pstart);
                    216:         if ((p - pstart) == len && !memcmp(pstart, name, len))
                    217:             return 1;
                    218:         if (*p == '\0')
                    219:             break;
                    220:         p++;
                    221:     }
                    222:     return 0;
                    223: }
                    224: 
1.1.1.9 ! root      225: static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
        !           226:                           const char *prefix, const char *name)
1.1       root      227: {
1.1.1.9 ! root      228:     const mon_cmd_t *cmd;
1.1       root      229: 
                    230:     for(cmd = cmds; cmd->name != NULL; cmd++) {
                    231:         if (!name || !strcmp(name, cmd->name))
1.1.1.9 ! root      232:             monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
        !           233:                            cmd->params, cmd->help);
1.1       root      234:     }
                    235: }
                    236: 
1.1.1.9 ! root      237: static void help_cmd(Monitor *mon, const char *name)
1.1       root      238: {
                    239:     if (name && !strcmp(name, "info")) {
1.1.1.9 ! root      240:         help_cmd_dump(mon, info_cmds, "info ", NULL);
1.1       root      241:     } else {
1.1.1.9 ! root      242:         help_cmd_dump(mon, mon_cmds, "", name);
1.1       root      243:         if (name && !strcmp(name, "log")) {
1.1.1.7   root      244:             const CPULogItem *item;
1.1.1.9 ! root      245:             monitor_printf(mon, "Log items (comma separated):\n");
        !           246:             monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
1.1       root      247:             for(item = cpu_log_items; item->mask != 0; item++) {
1.1.1.9 ! root      248:                 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
1.1       root      249:             }
                    250:         }
                    251:     }
                    252: }
                    253: 
1.1.1.9 ! root      254: static void do_commit(Monitor *mon, const char *device)
1.1       root      255: {
1.1.1.5   root      256:     int i, all_devices;
1.1.1.6   root      257: 
1.1.1.5   root      258:     all_devices = !strcmp(device, "all");
1.1.1.6   root      259:     for (i = 0; i < nb_drives; i++) {
1.1.1.9 ! root      260:         if (!all_devices)
        !           261:             if (strcmp(bdrv_get_device_name(drives_table[i].bdrv), device))
        !           262:                 continue;
        !           263:         bdrv_commit(drives_table[i].bdrv);
1.1       root      264:     }
                    265: }
                    266: 
1.1.1.9 ! root      267: static void do_info(Monitor *mon, const char *item)
1.1       root      268: {
1.1.1.9 ! root      269:     const mon_cmd_t *cmd;
        !           270:     void (*handler)(Monitor *);
1.1       root      271: 
                    272:     if (!item)
                    273:         goto help;
                    274:     for(cmd = info_cmds; cmd->name != NULL; cmd++) {
1.1.1.6   root      275:         if (compare_cmd(item, cmd->name))
1.1       root      276:             goto found;
                    277:     }
                    278:  help:
1.1.1.9 ! root      279:     help_cmd(mon, "info");
1.1       root      280:     return;
                    281:  found:
1.1.1.7   root      282:     handler = cmd->handler;
1.1.1.9 ! root      283:     handler(mon);
1.1       root      284: }
                    285: 
1.1.1.9 ! root      286: static void do_info_version(Monitor *mon)
1.1       root      287: {
1.1.1.9 ! root      288:     monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
1.1       root      289: }
                    290: 
1.1.1.9 ! root      291: static void do_info_name(Monitor *mon)
1.1.1.6   root      292: {
                    293:     if (qemu_name)
1.1.1.9 ! root      294:         monitor_printf(mon, "%s\n", qemu_name);
1.1.1.6   root      295: }
                    296: 
1.1.1.7   root      297: #if defined(TARGET_I386)
1.1.1.9 ! root      298: static void do_info_hpet(Monitor *mon)
1.1.1.7   root      299: {
1.1.1.9 ! root      300:     monitor_printf(mon, "HPET is %s by QEMU\n",
        !           301:                    (no_hpet) ? "disabled" : "enabled");
1.1.1.7   root      302: }
                    303: #endif
                    304: 
1.1.1.9 ! root      305: static void do_info_uuid(Monitor *mon)
1.1.1.6   root      306: {
1.1.1.9 ! root      307:     monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
        !           308:                    qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
        !           309:                    qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
        !           310:                    qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
        !           311:                    qemu_uuid[14], qemu_uuid[15]);
1.1.1.6   root      312: }
                    313: 
1.1.1.2   root      314: /* get the current CPU defined by the user */
1.1.1.6   root      315: static int mon_set_cpu(int cpu_index)
1.1.1.2   root      316: {
                    317:     CPUState *env;
                    318: 
                    319:     for(env = first_cpu; env != NULL; env = env->next_cpu) {
                    320:         if (env->cpu_index == cpu_index) {
1.1.1.9 ! root      321:             cur_mon->mon_cpu = env;
1.1.1.2   root      322:             return 0;
1.1       root      323:         }
                    324:     }
1.1.1.2   root      325:     return -1;
1.1       root      326: }
1.1.1.2   root      327: 
1.1.1.6   root      328: static CPUState *mon_get_cpu(void)
1.1       root      329: {
1.1.1.9 ! root      330:     if (!cur_mon->mon_cpu) {
1.1.1.2   root      331:         mon_set_cpu(0);
                    332:     }
1.1.1.9 ! root      333:     cpu_synchronize_state(cur_mon->mon_cpu, 0);
        !           334:     return cur_mon->mon_cpu;
1.1       root      335: }
                    336: 
1.1.1.9 ! root      337: static void do_info_registers(Monitor *mon)
1.1       root      338: {
1.1.1.2   root      339:     CPUState *env;
                    340:     env = mon_get_cpu();
                    341:     if (!env)
                    342:         return;
1.1       root      343: #ifdef TARGET_I386
1.1.1.9 ! root      344:     cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
1.1       root      345:                    X86_DUMP_FPU);
                    346: #else
1.1.1.9 ! root      347:     cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
1.1       root      348:                    0);
                    349: #endif
                    350: }
                    351: 
1.1.1.9 ! root      352: static void do_info_cpus(Monitor *mon)
1.1.1.2   root      353: {
                    354:     CPUState *env;
                    355: 
                    356:     /* just to set the default cpu if not already done */
                    357:     mon_get_cpu();
                    358: 
                    359:     for(env = first_cpu; env != NULL; env = env->next_cpu) {
1.1.1.9 ! root      360:         cpu_synchronize_state(env, 0);
        !           361:         monitor_printf(mon, "%c CPU #%d:",
        !           362:                        (env == mon->mon_cpu) ? '*' : ' ',
        !           363:                        env->cpu_index);
1.1.1.2   root      364: #if defined(TARGET_I386)
1.1.1.9 ! root      365:         monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
        !           366:                        env->eip + env->segs[R_CS].base);
1.1.1.2   root      367: #elif defined(TARGET_PPC)
1.1.1.9 ! root      368:         monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
1.1.1.2   root      369: #elif defined(TARGET_SPARC)
1.1.1.9 ! root      370:         monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
        !           371:                        env->pc, env->npc);
1.1.1.6   root      372: #elif defined(TARGET_MIPS)
1.1.1.9 ! root      373:         monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
1.1.1.7   root      374: #endif
1.1.1.6   root      375:         if (env->halted)
1.1.1.9 ! root      376:             monitor_printf(mon, " (halted)");
        !           377:         monitor_printf(mon, "\n");
1.1.1.2   root      378:     }
                    379: }
                    380: 
1.1.1.9 ! root      381: static void do_cpu_set(Monitor *mon, int index)
1.1.1.2   root      382: {
                    383:     if (mon_set_cpu(index) < 0)
1.1.1.9 ! root      384:         monitor_printf(mon, "Invalid CPU index\n");
1.1.1.2   root      385: }
                    386: 
1.1.1.9 ! root      387: static void do_info_jit(Monitor *mon)
1.1       root      388: {
1.1.1.9 ! root      389:     dump_exec_info((FILE *)mon, monitor_fprintf);
1.1       root      390: }
                    391: 
1.1.1.9 ! root      392: static void do_info_history(Monitor *mon)
1.1       root      393: {
                    394:     int i;
                    395:     const char *str;
1.1.1.6   root      396: 
1.1.1.9 ! root      397:     if (!mon->rs)
        !           398:         return;
1.1       root      399:     i = 0;
                    400:     for(;;) {
1.1.1.9 ! root      401:         str = readline_get_history(mon->rs, i);
1.1       root      402:         if (!str)
                    403:             break;
1.1.1.9 ! root      404:         monitor_printf(mon, "%d: '%s'\n", i, str);
1.1       root      405:         i++;
                    406:     }
                    407: }
                    408: 
1.1.1.6   root      409: #if defined(TARGET_PPC)
                    410: /* XXX: not implemented in other targets */
1.1.1.9 ! root      411: static void do_info_cpu_stats(Monitor *mon)
1.1.1.6   root      412: {
                    413:     CPUState *env;
                    414: 
                    415:     env = mon_get_cpu();
1.1.1.9 ! root      416:     cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
1.1.1.6   root      417: }
                    418: #endif
                    419: 
1.1.1.9 ! root      420: static void do_quit(Monitor *mon)
1.1       root      421: {
                    422:     exit(0);
                    423: }
                    424: 
1.1.1.9 ! root      425: static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
1.1       root      426: {
                    427:     if (bdrv_is_inserted(bs)) {
                    428:         if (!force) {
                    429:             if (!bdrv_is_removable(bs)) {
1.1.1.9 ! root      430:                 monitor_printf(mon, "device is not removable\n");
1.1       root      431:                 return -1;
                    432:             }
                    433:             if (bdrv_is_locked(bs)) {
1.1.1.9 ! root      434:                 monitor_printf(mon, "device is locked\n");
1.1       root      435:                 return -1;
                    436:             }
                    437:         }
                    438:         bdrv_close(bs);
                    439:     }
                    440:     return 0;
                    441: }
                    442: 
1.1.1.9 ! root      443: static void do_eject(Monitor *mon, int force, const char *filename)
1.1       root      444: {
                    445:     BlockDriverState *bs;
                    446: 
                    447:     bs = bdrv_find(filename);
                    448:     if (!bs) {
1.1.1.9 ! root      449:         monitor_printf(mon, "device not found\n");
1.1       root      450:         return;
                    451:     }
1.1.1.9 ! root      452:     eject_device(mon, bs, force);
1.1       root      453: }
                    454: 
1.1.1.9 ! root      455: static void do_change_block(Monitor *mon, const char *device,
        !           456:                             const char *filename, const char *fmt)
1.1       root      457: {
                    458:     BlockDriverState *bs;
1.1.1.7   root      459:     BlockDriver *drv = NULL;
1.1       root      460: 
                    461:     bs = bdrv_find(device);
                    462:     if (!bs) {
1.1.1.9 ! root      463:         monitor_printf(mon, "device not found\n");
1.1       root      464:         return;
                    465:     }
1.1.1.7   root      466:     if (fmt) {
                    467:         drv = bdrv_find_format(fmt);
                    468:         if (!drv) {
1.1.1.9 ! root      469:             monitor_printf(mon, "invalid format %s\n", fmt);
1.1.1.7   root      470:             return;
                    471:         }
                    472:     }
1.1.1.9 ! root      473:     if (eject_device(mon, bs, 0) < 0)
1.1       root      474:         return;
1.1.1.7   root      475:     bdrv_open2(bs, filename, 0, drv);
1.1.1.9 ! root      476:     monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
1.1.1.6   root      477: }
                    478: 
1.1.1.9 ! root      479: static void change_vnc_password_cb(Monitor *mon, const char *password,
        !           480:                                    void *opaque)
        !           481: {
        !           482:     if (vnc_display_password(NULL, password) < 0)
        !           483:         monitor_printf(mon, "could not set VNC server password\n");
        !           484: 
        !           485:     monitor_read_command(mon, 1);
        !           486: }
        !           487: 
        !           488: static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
1.1.1.6   root      489: {
                    490:     if (strcmp(target, "passwd") == 0 ||
1.1.1.9 ! root      491:         strcmp(target, "password") == 0) {
        !           492:         if (arg) {
        !           493:             char password[9];
        !           494:             strncpy(password, arg, sizeof(password));
        !           495:             password[sizeof(password) - 1] = '\0';
        !           496:             change_vnc_password_cb(mon, password, NULL);
        !           497:         } else {
        !           498:             monitor_read_password(mon, change_vnc_password_cb, NULL);
        !           499:         }
1.1.1.6   root      500:     } else {
1.1.1.9 ! root      501:         if (vnc_display_open(NULL, target) < 0)
        !           502:             monitor_printf(mon, "could not start VNC server on %s\n", target);
1.1.1.6   root      503:     }
                    504: }
                    505: 
1.1.1.9 ! root      506: static void do_change(Monitor *mon, const char *device, const char *target,
        !           507:                       const char *arg)
1.1.1.6   root      508: {
                    509:     if (strcmp(device, "vnc") == 0) {
1.1.1.9 ! root      510:         do_change_vnc(mon, target, arg);
1.1.1.6   root      511:     } else {
1.1.1.9 ! root      512:         do_change_block(mon, device, target, arg);
1.1       root      513:     }
                    514: }
                    515: 
1.1.1.9 ! root      516: static void do_screen_dump(Monitor *mon, const char *filename)
1.1       root      517: {
1.1.1.3   root      518:     vga_hw_screen_dump(filename);
1.1       root      519: }
                    520: 
1.1.1.9 ! root      521: static void do_logfile(Monitor *mon, const char *filename)
1.1.1.6   root      522: {
                    523:     cpu_set_log_filename(filename);
                    524: }
                    525: 
1.1.1.9 ! root      526: static void do_log(Monitor *mon, const char *items)
1.1       root      527: {
                    528:     int mask;
1.1.1.6   root      529: 
1.1       root      530:     if (!strcmp(items, "none")) {
                    531:         mask = 0;
                    532:     } else {
                    533:         mask = cpu_str_to_log_mask(items);
                    534:         if (!mask) {
1.1.1.9 ! root      535:             help_cmd(mon, "log");
1.1       root      536:             return;
                    537:         }
                    538:     }
                    539:     cpu_set_log(mask);
                    540: }
                    541: 
1.1.1.9 ! root      542: static void do_singlestep(Monitor *mon, const char *option)
        !           543: {
        !           544:     if (!option || !strcmp(option, "on")) {
        !           545:         singlestep = 1;
        !           546:     } else if (!strcmp(option, "off")) {
        !           547:         singlestep = 0;
        !           548:     } else {
        !           549:         monitor_printf(mon, "unexpected option %s\n", option);
        !           550:     }
        !           551: }
        !           552: 
        !           553: static void do_stop(Monitor *mon)
1.1       root      554: {
                    555:     vm_stop(EXCP_INTERRUPT);
                    556: }
                    557: 
1.1.1.9 ! root      558: static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
        !           559: 
        !           560: struct bdrv_iterate_context {
        !           561:     Monitor *mon;
        !           562:     int err;
        !           563: };
        !           564: 
        !           565: static void do_cont(Monitor *mon)
1.1.1.8   root      566: {
1.1.1.9 ! root      567:     struct bdrv_iterate_context context = { mon, 0 };
1.1.1.8   root      568: 
1.1.1.9 ! root      569:     bdrv_iterate(encrypted_bdrv_it, &context);
        !           570:     /* only resume the vm if all keys are set and valid */
        !           571:     if (!context.err)
        !           572:         vm_start();
1.1.1.8   root      573: }
                    574: 
1.1.1.9 ! root      575: static void bdrv_key_cb(void *opaque, int err)
1.1       root      576: {
1.1.1.9 ! root      577:     Monitor *mon = opaque;
1.1.1.8   root      578: 
1.1.1.9 ! root      579:     /* another key was set successfully, retry to continue */
1.1.1.8   root      580:     if (!err)
1.1.1.9 ! root      581:         do_cont(mon);
        !           582: }
        !           583: 
        !           584: static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
        !           585: {
        !           586:     struct bdrv_iterate_context *context = opaque;
        !           587: 
        !           588:     if (!context->err && bdrv_key_required(bs)) {
        !           589:         context->err = -EBUSY;
        !           590:         monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
        !           591:                                     context->mon);
        !           592:     }
1.1       root      593: }
                    594: 
1.1.1.9 ! root      595: static void do_gdbserver(Monitor *mon, const char *device)
1.1       root      596: {
1.1.1.9 ! root      597:     if (!device)
        !           598:         device = "tcp::" DEFAULT_GDBSTUB_PORT;
        !           599:     if (gdbserver_start(device) < 0) {
        !           600:         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
        !           601:                        device);
        !           602:     } else if (strcmp(device, "none") == 0) {
        !           603:         monitor_printf(mon, "Disabled gdbserver\n");
1.1       root      604:     } else {
1.1.1.9 ! root      605:         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
        !           606:                        device);
        !           607:     }
        !           608: }
        !           609: 
        !           610: static void do_watchdog_action(Monitor *mon, const char *action)
        !           611: {
        !           612:     if (select_watchdog_action(action) == -1) {
        !           613:         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1.1       root      614:     }
                    615: }
                    616: 
1.1.1.9 ! root      617: static void monitor_printc(Monitor *mon, int c)
1.1       root      618: {
1.1.1.9 ! root      619:     monitor_printf(mon, "'");
1.1       root      620:     switch(c) {
                    621:     case '\'':
1.1.1.9 ! root      622:         monitor_printf(mon, "\\'");
1.1       root      623:         break;
                    624:     case '\\':
1.1.1.9 ! root      625:         monitor_printf(mon, "\\\\");
1.1       root      626:         break;
                    627:     case '\n':
1.1.1.9 ! root      628:         monitor_printf(mon, "\\n");
1.1       root      629:         break;
                    630:     case '\r':
1.1.1.9 ! root      631:         monitor_printf(mon, "\\r");
1.1       root      632:         break;
                    633:     default:
                    634:         if (c >= 32 && c <= 126) {
1.1.1.9 ! root      635:             monitor_printf(mon, "%c", c);
1.1       root      636:         } else {
1.1.1.9 ! root      637:             monitor_printf(mon, "\\x%02x", c);
1.1       root      638:         }
                    639:         break;
                    640:     }
1.1.1.9 ! root      641:     monitor_printf(mon, "'");
1.1       root      642: }
                    643: 
1.1.1.9 ! root      644: static void memory_dump(Monitor *mon, int count, int format, int wsize,
1.1.1.6   root      645:                         target_phys_addr_t addr, int is_physical)
1.1       root      646: {
1.1.1.2   root      647:     CPUState *env;
1.1       root      648:     int nb_per_line, l, line_size, i, max_digits, len;
                    649:     uint8_t buf[16];
                    650:     uint64_t v;
                    651: 
                    652:     if (format == 'i') {
                    653:         int flags;
                    654:         flags = 0;
1.1.1.2   root      655:         env = mon_get_cpu();
                    656:         if (!env && !is_physical)
                    657:             return;
1.1       root      658: #ifdef TARGET_I386
                    659:         if (wsize == 2) {
                    660:             flags = 1;
                    661:         } else if (wsize == 4) {
                    662:             flags = 0;
                    663:         } else {
1.1.1.3   root      664:             /* as default we use the current CS size */
1.1       root      665:             flags = 0;
1.1.1.3   root      666:             if (env) {
                    667: #ifdef TARGET_X86_64
1.1.1.6   root      668:                 if ((env->efer & MSR_EFER_LMA) &&
1.1.1.3   root      669:                     (env->segs[R_CS].flags & DESC_L_MASK))
                    670:                     flags = 2;
                    671:                 else
                    672: #endif
                    673:                 if (!(env->segs[R_CS].flags & DESC_B_MASK))
                    674:                     flags = 1;
                    675:             }
1.1       root      676:         }
                    677: #endif
1.1.1.9 ! root      678:         monitor_disas(mon, env, addr, count, is_physical, flags);
1.1       root      679:         return;
                    680:     }
                    681: 
                    682:     len = wsize * count;
                    683:     if (wsize == 1)
                    684:         line_size = 8;
                    685:     else
                    686:         line_size = 16;
                    687:     nb_per_line = line_size / wsize;
                    688:     max_digits = 0;
                    689: 
                    690:     switch(format) {
                    691:     case 'o':
                    692:         max_digits = (wsize * 8 + 2) / 3;
                    693:         break;
                    694:     default:
                    695:     case 'x':
                    696:         max_digits = (wsize * 8) / 4;
                    697:         break;
                    698:     case 'u':
                    699:     case 'd':
                    700:         max_digits = (wsize * 8 * 10 + 32) / 33;
                    701:         break;
                    702:     case 'c':
                    703:         wsize = 1;
                    704:         break;
                    705:     }
                    706: 
                    707:     while (len > 0) {
1.1.1.6   root      708:         if (is_physical)
1.1.1.9 ! root      709:             monitor_printf(mon, TARGET_FMT_plx ":", addr);
1.1.1.6   root      710:         else
1.1.1.9 ! root      711:             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1.1       root      712:         l = len;
                    713:         if (l > line_size)
                    714:             l = line_size;
                    715:         if (is_physical) {
                    716:             cpu_physical_memory_rw(addr, buf, l, 0);
                    717:         } else {
1.1.1.2   root      718:             env = mon_get_cpu();
                    719:             if (!env)
                    720:                 break;
1.1.1.7   root      721:             if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1.1.1.9 ! root      722:                 monitor_printf(mon, " Cannot access memory\n");
1.1.1.7   root      723:                 break;
                    724:             }
1.1       root      725:         }
1.1.1.6   root      726:         i = 0;
1.1       root      727:         while (i < l) {
                    728:             switch(wsize) {
                    729:             default:
                    730:             case 1:
                    731:                 v = ldub_raw(buf + i);
                    732:                 break;
                    733:             case 2:
                    734:                 v = lduw_raw(buf + i);
                    735:                 break;
                    736:             case 4:
                    737:                 v = (uint32_t)ldl_raw(buf + i);
                    738:                 break;
                    739:             case 8:
                    740:                 v = ldq_raw(buf + i);
                    741:                 break;
                    742:             }
1.1.1.9 ! root      743:             monitor_printf(mon, " ");
1.1       root      744:             switch(format) {
                    745:             case 'o':
1.1.1.9 ! root      746:                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1.1       root      747:                 break;
                    748:             case 'x':
1.1.1.9 ! root      749:                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1.1       root      750:                 break;
                    751:             case 'u':
1.1.1.9 ! root      752:                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1.1       root      753:                 break;
                    754:             case 'd':
1.1.1.9 ! root      755:                 monitor_printf(mon, "%*" PRId64, max_digits, v);
1.1       root      756:                 break;
                    757:             case 'c':
1.1.1.9 ! root      758:                 monitor_printc(mon, v);
1.1       root      759:                 break;
                    760:             }
                    761:             i += wsize;
                    762:         }
1.1.1.9 ! root      763:         monitor_printf(mon, "\n");
1.1       root      764:         addr += l;
                    765:         len -= l;
                    766:     }
                    767: }
                    768: 
                    769: #if TARGET_LONG_BITS == 64
                    770: #define GET_TLONG(h, l) (((uint64_t)(h) << 32) | (l))
                    771: #else
                    772: #define GET_TLONG(h, l) (l)
                    773: #endif
                    774: 
1.1.1.9 ! root      775: static void do_memory_dump(Monitor *mon, int count, int format, int size,
1.1       root      776:                            uint32_t addrh, uint32_t addrl)
                    777: {
                    778:     target_long addr = GET_TLONG(addrh, addrl);
1.1.1.9 ! root      779:     memory_dump(mon, count, format, size, addr, 0);
1.1       root      780: }
                    781: 
1.1.1.6   root      782: #if TARGET_PHYS_ADDR_BITS > 32
                    783: #define GET_TPHYSADDR(h, l) (((uint64_t)(h) << 32) | (l))
                    784: #else
                    785: #define GET_TPHYSADDR(h, l) (l)
                    786: #endif
                    787: 
1.1.1.9 ! root      788: static void do_physical_memory_dump(Monitor *mon, int count, int format,
        !           789:                                     int size, uint32_t addrh, uint32_t addrl)
1.1       root      790: 
                    791: {
1.1.1.6   root      792:     target_phys_addr_t addr = GET_TPHYSADDR(addrh, addrl);
1.1.1.9 ! root      793:     memory_dump(mon, count, format, size, addr, 1);
1.1       root      794: }
                    795: 
1.1.1.9 ! root      796: static void do_print(Monitor *mon, int count, int format, int size,
        !           797:                      unsigned int valh, unsigned int vall)
1.1       root      798: {
1.1.1.6   root      799:     target_phys_addr_t val = GET_TPHYSADDR(valh, vall);
                    800: #if TARGET_PHYS_ADDR_BITS == 32
1.1       root      801:     switch(format) {
                    802:     case 'o':
1.1.1.9 ! root      803:         monitor_printf(mon, "%#o", val);
1.1       root      804:         break;
                    805:     case 'x':
1.1.1.9 ! root      806:         monitor_printf(mon, "%#x", val);
1.1       root      807:         break;
                    808:     case 'u':
1.1.1.9 ! root      809:         monitor_printf(mon, "%u", val);
1.1       root      810:         break;
                    811:     default:
                    812:     case 'd':
1.1.1.9 ! root      813:         monitor_printf(mon, "%d", val);
1.1       root      814:         break;
                    815:     case 'c':
1.1.1.9 ! root      816:         monitor_printc(mon, val);
1.1       root      817:         break;
                    818:     }
                    819: #else
                    820:     switch(format) {
                    821:     case 'o':
1.1.1.9 ! root      822:         monitor_printf(mon, "%#" PRIo64, val);
1.1       root      823:         break;
                    824:     case 'x':
1.1.1.9 ! root      825:         monitor_printf(mon, "%#" PRIx64, val);
1.1       root      826:         break;
                    827:     case 'u':
1.1.1.9 ! root      828:         monitor_printf(mon, "%" PRIu64, val);
1.1       root      829:         break;
                    830:     default:
                    831:     case 'd':
1.1.1.9 ! root      832:         monitor_printf(mon, "%" PRId64, val);
1.1       root      833:         break;
                    834:     case 'c':
1.1.1.9 ! root      835:         monitor_printc(mon, val);
1.1       root      836:         break;
                    837:     }
                    838: #endif
1.1.1.9 ! root      839:     monitor_printf(mon, "\n");
1.1       root      840: }
                    841: 
1.1.1.9 ! root      842: static void do_memory_save(Monitor *mon, unsigned int valh, unsigned int vall,
1.1.1.5   root      843:                            uint32_t size, const char *filename)
                    844: {
                    845:     FILE *f;
                    846:     target_long addr = GET_TLONG(valh, vall);
                    847:     uint32_t l;
                    848:     CPUState *env;
                    849:     uint8_t buf[1024];
                    850: 
                    851:     env = mon_get_cpu();
                    852:     if (!env)
                    853:         return;
                    854: 
                    855:     f = fopen(filename, "wb");
                    856:     if (!f) {
1.1.1.9 ! root      857:         monitor_printf(mon, "could not open '%s'\n", filename);
1.1.1.5   root      858:         return;
                    859:     }
                    860:     while (size != 0) {
                    861:         l = sizeof(buf);
                    862:         if (l > size)
                    863:             l = size;
                    864:         cpu_memory_rw_debug(env, addr, buf, l, 0);
                    865:         fwrite(buf, 1, l, f);
                    866:         addr += l;
                    867:         size -= l;
                    868:     }
                    869:     fclose(f);
                    870: }
                    871: 
1.1.1.9 ! root      872: static void do_physical_memory_save(Monitor *mon, unsigned int valh,
        !           873:                                     unsigned int vall, uint32_t size,
        !           874:                                     const char *filename)
1.1.1.7   root      875: {
                    876:     FILE *f;
                    877:     uint32_t l;
                    878:     uint8_t buf[1024];
                    879:     target_phys_addr_t addr = GET_TPHYSADDR(valh, vall); 
                    880: 
                    881:     f = fopen(filename, "wb");
                    882:     if (!f) {
1.1.1.9 ! root      883:         monitor_printf(mon, "could not open '%s'\n", filename);
1.1.1.7   root      884:         return;
                    885:     }
                    886:     while (size != 0) {
                    887:         l = sizeof(buf);
                    888:         if (l > size)
                    889:             l = size;
                    890:         cpu_physical_memory_rw(addr, buf, l, 0);
                    891:         fwrite(buf, 1, l, f);
                    892:         fflush(f);
                    893:         addr += l;
                    894:         size -= l;
                    895:     }
                    896:     fclose(f);
                    897: }
                    898: 
1.1.1.9 ! root      899: static void do_sum(Monitor *mon, uint32_t start, uint32_t size)
1.1       root      900: {
                    901:     uint32_t addr;
                    902:     uint8_t buf[1];
                    903:     uint16_t sum;
                    904: 
                    905:     sum = 0;
                    906:     for(addr = start; addr < (start + size); addr++) {
                    907:         cpu_physical_memory_rw(addr, buf, 1, 0);
                    908:         /* BSD sum algorithm ('sum' Unix command) */
                    909:         sum = (sum >> 1) | (sum << 15);
                    910:         sum += buf[0];
                    911:     }
1.1.1.9 ! root      912:     monitor_printf(mon, "%05d\n", sum);
1.1       root      913: }
                    914: 
                    915: typedef struct {
                    916:     int keycode;
                    917:     const char *name;
                    918: } KeyDef;
                    919: 
                    920: static const KeyDef key_defs[] = {
                    921:     { 0x2a, "shift" },
                    922:     { 0x36, "shift_r" },
1.1.1.6   root      923: 
1.1       root      924:     { 0x38, "alt" },
                    925:     { 0xb8, "alt_r" },
1.1.1.7   root      926:     { 0x64, "altgr" },
                    927:     { 0xe4, "altgr_r" },
1.1       root      928:     { 0x1d, "ctrl" },
                    929:     { 0x9d, "ctrl_r" },
                    930: 
                    931:     { 0xdd, "menu" },
                    932: 
                    933:     { 0x01, "esc" },
                    934: 
                    935:     { 0x02, "1" },
                    936:     { 0x03, "2" },
                    937:     { 0x04, "3" },
                    938:     { 0x05, "4" },
                    939:     { 0x06, "5" },
                    940:     { 0x07, "6" },
                    941:     { 0x08, "7" },
                    942:     { 0x09, "8" },
                    943:     { 0x0a, "9" },
                    944:     { 0x0b, "0" },
1.1.1.4   root      945:     { 0x0c, "minus" },
                    946:     { 0x0d, "equal" },
1.1       root      947:     { 0x0e, "backspace" },
                    948: 
                    949:     { 0x0f, "tab" },
                    950:     { 0x10, "q" },
                    951:     { 0x11, "w" },
                    952:     { 0x12, "e" },
                    953:     { 0x13, "r" },
                    954:     { 0x14, "t" },
                    955:     { 0x15, "y" },
                    956:     { 0x16, "u" },
                    957:     { 0x17, "i" },
                    958:     { 0x18, "o" },
                    959:     { 0x19, "p" },
                    960: 
                    961:     { 0x1c, "ret" },
                    962: 
                    963:     { 0x1e, "a" },
                    964:     { 0x1f, "s" },
                    965:     { 0x20, "d" },
                    966:     { 0x21, "f" },
                    967:     { 0x22, "g" },
                    968:     { 0x23, "h" },
                    969:     { 0x24, "j" },
                    970:     { 0x25, "k" },
                    971:     { 0x26, "l" },
                    972: 
                    973:     { 0x2c, "z" },
                    974:     { 0x2d, "x" },
                    975:     { 0x2e, "c" },
                    976:     { 0x2f, "v" },
                    977:     { 0x30, "b" },
                    978:     { 0x31, "n" },
                    979:     { 0x32, "m" },
1.1.1.7   root      980:     { 0x33, "comma" },
                    981:     { 0x34, "dot" },
                    982:     { 0x35, "slash" },
                    983: 
                    984:     { 0x37, "asterisk" },
1.1.1.6   root      985: 
1.1       root      986:     { 0x39, "spc" },
                    987:     { 0x3a, "caps_lock" },
                    988:     { 0x3b, "f1" },
                    989:     { 0x3c, "f2" },
                    990:     { 0x3d, "f3" },
                    991:     { 0x3e, "f4" },
                    992:     { 0x3f, "f5" },
                    993:     { 0x40, "f6" },
                    994:     { 0x41, "f7" },
                    995:     { 0x42, "f8" },
                    996:     { 0x43, "f9" },
                    997:     { 0x44, "f10" },
                    998:     { 0x45, "num_lock" },
                    999:     { 0x46, "scroll_lock" },
                   1000: 
1.1.1.4   root     1001:     { 0xb5, "kp_divide" },
                   1002:     { 0x37, "kp_multiply" },
1.1.1.6   root     1003:     { 0x4a, "kp_subtract" },
1.1.1.4   root     1004:     { 0x4e, "kp_add" },
                   1005:     { 0x9c, "kp_enter" },
                   1006:     { 0x53, "kp_decimal" },
1.1.1.7   root     1007:     { 0x54, "sysrq" },
1.1.1.4   root     1008: 
                   1009:     { 0x52, "kp_0" },
                   1010:     { 0x4f, "kp_1" },
                   1011:     { 0x50, "kp_2" },
                   1012:     { 0x51, "kp_3" },
                   1013:     { 0x4b, "kp_4" },
                   1014:     { 0x4c, "kp_5" },
                   1015:     { 0x4d, "kp_6" },
                   1016:     { 0x47, "kp_7" },
                   1017:     { 0x48, "kp_8" },
                   1018:     { 0x49, "kp_9" },
1.1.1.6   root     1019: 
1.1       root     1020:     { 0x56, "<" },
                   1021: 
                   1022:     { 0x57, "f11" },
                   1023:     { 0x58, "f12" },
                   1024: 
                   1025:     { 0xb7, "print" },
                   1026: 
                   1027:     { 0xc7, "home" },
                   1028:     { 0xc9, "pgup" },
                   1029:     { 0xd1, "pgdn" },
                   1030:     { 0xcf, "end" },
                   1031: 
                   1032:     { 0xcb, "left" },
                   1033:     { 0xc8, "up" },
                   1034:     { 0xd0, "down" },
                   1035:     { 0xcd, "right" },
                   1036: 
                   1037:     { 0xd2, "insert" },
                   1038:     { 0xd3, "delete" },
1.1.1.7   root     1039: #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
                   1040:     { 0xf0, "stop" },
                   1041:     { 0xf1, "again" },
                   1042:     { 0xf2, "props" },
                   1043:     { 0xf3, "undo" },
                   1044:     { 0xf4, "front" },
                   1045:     { 0xf5, "copy" },
                   1046:     { 0xf6, "open" },
                   1047:     { 0xf7, "paste" },
                   1048:     { 0xf8, "find" },
                   1049:     { 0xf9, "cut" },
                   1050:     { 0xfa, "lf" },
                   1051:     { 0xfb, "help" },
                   1052:     { 0xfc, "meta_l" },
                   1053:     { 0xfd, "meta_r" },
                   1054:     { 0xfe, "compose" },
                   1055: #endif
1.1       root     1056:     { 0, NULL },
                   1057: };
                   1058: 
                   1059: static int get_keycode(const char *key)
                   1060: {
                   1061:     const KeyDef *p;
1.1.1.4   root     1062:     char *endp;
                   1063:     int ret;
1.1       root     1064: 
                   1065:     for(p = key_defs; p->name != NULL; p++) {
                   1066:         if (!strcmp(key, p->name))
                   1067:             return p->keycode;
                   1068:     }
1.1.1.4   root     1069:     if (strstart(key, "0x", NULL)) {
                   1070:         ret = strtoul(key, &endp, 0);
                   1071:         if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
                   1072:             return ret;
                   1073:     }
1.1       root     1074:     return -1;
                   1075: }
                   1076: 
1.1.1.7   root     1077: #define MAX_KEYCODES 16
                   1078: static uint8_t keycodes[MAX_KEYCODES];
                   1079: static int nb_pending_keycodes;
                   1080: static QEMUTimer *key_timer;
                   1081: 
                   1082: static void release_keys(void *opaque)
1.1       root     1083: {
1.1.1.7   root     1084:     int keycode;
1.1.1.6   root     1085: 
1.1.1.7   root     1086:     while (nb_pending_keycodes > 0) {
                   1087:         nb_pending_keycodes--;
                   1088:         keycode = keycodes[nb_pending_keycodes];
                   1089:         if (keycode & 0x80)
                   1090:             kbd_put_keycode(0xe0);
                   1091:         kbd_put_keycode(keycode | 0x80);
                   1092:     }
                   1093: }
                   1094: 
1.1.1.9 ! root     1095: static void do_sendkey(Monitor *mon, const char *string, int has_hold_time,
        !          1096:                        int hold_time)
1.1.1.7   root     1097: {
                   1098:     char keyname_buf[16];
                   1099:     char *separator;
                   1100:     int keyname_len, keycode, i;
                   1101: 
                   1102:     if (nb_pending_keycodes > 0) {
                   1103:         qemu_del_timer(key_timer);
                   1104:         release_keys(NULL);
                   1105:     }
                   1106:     if (!has_hold_time)
                   1107:         hold_time = 100;
                   1108:     i = 0;
                   1109:     while (1) {
                   1110:         separator = strchr(string, '-');
                   1111:         keyname_len = separator ? separator - string : strlen(string);
                   1112:         if (keyname_len > 0) {
                   1113:             pstrcpy(keyname_buf, sizeof(keyname_buf), string);
                   1114:             if (keyname_len > sizeof(keyname_buf) - 1) {
1.1.1.9 ! root     1115:                 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1.1.1.7   root     1116:                 return;
1.1       root     1117:             }
1.1.1.7   root     1118:             if (i == MAX_KEYCODES) {
1.1.1.9 ! root     1119:                 monitor_printf(mon, "too many keys\n");
1.1.1.7   root     1120:                 return;
                   1121:             }
                   1122:             keyname_buf[keyname_len] = 0;
                   1123:             keycode = get_keycode(keyname_buf);
                   1124:             if (keycode < 0) {
1.1.1.9 ! root     1125:                 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1.1.1.7   root     1126:                 return;
                   1127:             }
                   1128:             keycodes[i++] = keycode;
1.1       root     1129:         }
1.1.1.7   root     1130:         if (!separator)
1.1       root     1131:             break;
1.1.1.7   root     1132:         string = separator + 1;
1.1       root     1133:     }
1.1.1.7   root     1134:     nb_pending_keycodes = i;
1.1       root     1135:     /* key down events */
1.1.1.7   root     1136:     for (i = 0; i < nb_pending_keycodes; i++) {
1.1       root     1137:         keycode = keycodes[i];
                   1138:         if (keycode & 0x80)
                   1139:             kbd_put_keycode(0xe0);
                   1140:         kbd_put_keycode(keycode & 0x7f);
                   1141:     }
1.1.1.7   root     1142:     /* delayed key up events */
                   1143:     qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
                   1144:                     muldiv64(ticks_per_sec, hold_time, 1000));
1.1       root     1145: }
                   1146: 
1.1.1.4   root     1147: static int mouse_button_state;
                   1148: 
1.1.1.9 ! root     1149: static void do_mouse_move(Monitor *mon, const char *dx_str, const char *dy_str,
1.1.1.4   root     1150:                           const char *dz_str)
                   1151: {
                   1152:     int dx, dy, dz;
                   1153:     dx = strtol(dx_str, NULL, 0);
                   1154:     dy = strtol(dy_str, NULL, 0);
                   1155:     dz = 0;
1.1.1.6   root     1156:     if (dz_str)
1.1.1.4   root     1157:         dz = strtol(dz_str, NULL, 0);
                   1158:     kbd_mouse_event(dx, dy, dz, mouse_button_state);
                   1159: }
                   1160: 
1.1.1.9 ! root     1161: static void do_mouse_button(Monitor *mon, int button_state)
1.1.1.4   root     1162: {
                   1163:     mouse_button_state = button_state;
                   1164:     kbd_mouse_event(0, 0, 0, mouse_button_state);
                   1165: }
                   1166: 
1.1.1.9 ! root     1167: static void do_ioport_read(Monitor *mon, int count, int format, int size,
        !          1168:                            int addr, int has_index, int index)
1.1       root     1169: {
                   1170:     uint32_t val;
                   1171:     int suffix;
                   1172: 
                   1173:     if (has_index) {
1.1.1.9 ! root     1174:         cpu_outb(NULL, addr & IOPORTS_MASK, index & 0xff);
1.1       root     1175:         addr++;
                   1176:     }
                   1177:     addr &= 0xffff;
                   1178: 
                   1179:     switch(size) {
                   1180:     default:
                   1181:     case 1:
                   1182:         val = cpu_inb(NULL, addr);
                   1183:         suffix = 'b';
                   1184:         break;
                   1185:     case 2:
                   1186:         val = cpu_inw(NULL, addr);
                   1187:         suffix = 'w';
                   1188:         break;
                   1189:     case 4:
                   1190:         val = cpu_inl(NULL, addr);
                   1191:         suffix = 'l';
                   1192:         break;
                   1193:     }
1.1.1.9 ! root     1194:     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
        !          1195:                    suffix, addr, size * 2, val);
1.1       root     1196: }
                   1197: 
1.1.1.9 ! root     1198: static void do_ioport_write(Monitor *mon, int count, int format, int size,
        !          1199:                             int addr, int val)
1.1.1.7   root     1200: {
1.1.1.9 ! root     1201:     addr &= IOPORTS_MASK;
        !          1202: 
        !          1203:     switch (size) {
        !          1204:     default:
        !          1205:     case 1:
        !          1206:         cpu_outb(NULL, addr, val);
        !          1207:         break;
        !          1208:     case 2:
        !          1209:         cpu_outw(NULL, addr, val);
        !          1210:         break;
        !          1211:     case 4:
        !          1212:         cpu_outl(NULL, addr, val);
        !          1213:         break;
        !          1214:     }
1.1.1.7   root     1215: }
                   1216: 
1.1.1.9 ! root     1217: static void do_boot_set(Monitor *mon, const char *bootdevice)
1.1.1.7   root     1218: {
                   1219:     int res;
                   1220: 
1.1.1.9 ! root     1221:     res = qemu_boot_set(bootdevice);
        !          1222:     if (res == 0) {
        !          1223:         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
        !          1224:     } else if (res > 0) {
        !          1225:         monitor_printf(mon, "setting boot device list failed\n");
1.1.1.7   root     1226:     } else {
1.1.1.9 ! root     1227:         monitor_printf(mon, "no function defined to set boot device list for "
        !          1228:                        "this architecture\n");
1.1.1.7   root     1229:     }
                   1230: }
                   1231: 
1.1.1.9 ! root     1232: static void do_system_reset(Monitor *mon)
1.1       root     1233: {
                   1234:     qemu_system_reset_request();
                   1235: }
                   1236: 
1.1.1.9 ! root     1237: static void do_system_powerdown(Monitor *mon)
1.1       root     1238: {
                   1239:     qemu_system_powerdown_request();
                   1240: }
                   1241: 
                   1242: #if defined(TARGET_I386)
1.1.1.9 ! root     1243: static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1.1       root     1244: {
1.1.1.9 ! root     1245:     monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
        !          1246:                    addr,
        !          1247:                    pte & mask,
        !          1248:                    pte & PG_GLOBAL_MASK ? 'G' : '-',
        !          1249:                    pte & PG_PSE_MASK ? 'P' : '-',
        !          1250:                    pte & PG_DIRTY_MASK ? 'D' : '-',
        !          1251:                    pte & PG_ACCESSED_MASK ? 'A' : '-',
        !          1252:                    pte & PG_PCD_MASK ? 'C' : '-',
        !          1253:                    pte & PG_PWT_MASK ? 'T' : '-',
        !          1254:                    pte & PG_USER_MASK ? 'U' : '-',
        !          1255:                    pte & PG_RW_MASK ? 'W' : '-');
1.1       root     1256: }
                   1257: 
1.1.1.9 ! root     1258: static void tlb_info(Monitor *mon)
1.1       root     1259: {
1.1.1.2   root     1260:     CPUState *env;
1.1       root     1261:     int l1, l2;
                   1262:     uint32_t pgd, pde, pte;
                   1263: 
1.1.1.2   root     1264:     env = mon_get_cpu();
                   1265:     if (!env)
                   1266:         return;
                   1267: 
1.1       root     1268:     if (!(env->cr[0] & CR0_PG_MASK)) {
1.1.1.9 ! root     1269:         monitor_printf(mon, "PG disabled\n");
1.1       root     1270:         return;
                   1271:     }
                   1272:     pgd = env->cr[3] & ~0xfff;
                   1273:     for(l1 = 0; l1 < 1024; l1++) {
                   1274:         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
                   1275:         pde = le32_to_cpu(pde);
                   1276:         if (pde & PG_PRESENT_MASK) {
                   1277:             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1.1.1.9 ! root     1278:                 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1.1       root     1279:             } else {
                   1280:                 for(l2 = 0; l2 < 1024; l2++) {
1.1.1.6   root     1281:                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1.1       root     1282:                                              (uint8_t *)&pte, 4);
                   1283:                     pte = le32_to_cpu(pte);
                   1284:                     if (pte & PG_PRESENT_MASK) {
1.1.1.9 ! root     1285:                         print_pte(mon, (l1 << 22) + (l2 << 12),
1.1.1.6   root     1286:                                   pte & ~PG_PSE_MASK,
1.1       root     1287:                                   ~0xfff);
                   1288:                     }
                   1289:                 }
                   1290:             }
                   1291:         }
                   1292:     }
                   1293: }
                   1294: 
1.1.1.9 ! root     1295: static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1.1       root     1296:                       uint32_t end, int prot)
                   1297: {
                   1298:     int prot1;
                   1299:     prot1 = *plast_prot;
                   1300:     if (prot != prot1) {
                   1301:         if (*pstart != -1) {
1.1.1.9 ! root     1302:             monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
        !          1303:                            *pstart, end, end - *pstart,
        !          1304:                            prot1 & PG_USER_MASK ? 'u' : '-',
        !          1305:                            'r',
        !          1306:                            prot1 & PG_RW_MASK ? 'w' : '-');
1.1       root     1307:         }
                   1308:         if (prot != 0)
                   1309:             *pstart = end;
                   1310:         else
                   1311:             *pstart = -1;
                   1312:         *plast_prot = prot;
                   1313:     }
                   1314: }
                   1315: 
1.1.1.9 ! root     1316: static void mem_info(Monitor *mon)
1.1       root     1317: {
1.1.1.2   root     1318:     CPUState *env;
1.1       root     1319:     int l1, l2, prot, last_prot;
                   1320:     uint32_t pgd, pde, pte, start, end;
                   1321: 
1.1.1.2   root     1322:     env = mon_get_cpu();
                   1323:     if (!env)
                   1324:         return;
                   1325: 
1.1       root     1326:     if (!(env->cr[0] & CR0_PG_MASK)) {
1.1.1.9 ! root     1327:         monitor_printf(mon, "PG disabled\n");
1.1       root     1328:         return;
                   1329:     }
                   1330:     pgd = env->cr[3] & ~0xfff;
                   1331:     last_prot = 0;
                   1332:     start = -1;
                   1333:     for(l1 = 0; l1 < 1024; l1++) {
                   1334:         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
                   1335:         pde = le32_to_cpu(pde);
                   1336:         end = l1 << 22;
                   1337:         if (pde & PG_PRESENT_MASK) {
                   1338:             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
                   1339:                 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1.1.1.9 ! root     1340:                 mem_print(mon, &start, &last_prot, end, prot);
1.1       root     1341:             } else {
                   1342:                 for(l2 = 0; l2 < 1024; l2++) {
1.1.1.6   root     1343:                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1.1       root     1344:                                              (uint8_t *)&pte, 4);
                   1345:                     pte = le32_to_cpu(pte);
                   1346:                     end = (l1 << 22) + (l2 << 12);
                   1347:                     if (pte & PG_PRESENT_MASK) {
                   1348:                         prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
                   1349:                     } else {
                   1350:                         prot = 0;
                   1351:                     }
1.1.1.9 ! root     1352:                     mem_print(mon, &start, &last_prot, end, prot);
1.1       root     1353:                 }
                   1354:             }
                   1355:         } else {
                   1356:             prot = 0;
1.1.1.9 ! root     1357:             mem_print(mon, &start, &last_prot, end, prot);
1.1       root     1358:         }
                   1359:     }
                   1360: }
                   1361: #endif
                   1362: 
1.1.1.7   root     1363: #if defined(TARGET_SH4)
                   1364: 
1.1.1.9 ! root     1365: static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1.1.1.7   root     1366: {
1.1.1.9 ! root     1367:     monitor_printf(mon, " tlb%i:\t"
        !          1368:                    "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
        !          1369:                    "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
        !          1370:                    "dirty=%hhu writethrough=%hhu\n",
        !          1371:                    idx,
        !          1372:                    tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
        !          1373:                    tlb->v, tlb->sh, tlb->c, tlb->pr,
        !          1374:                    tlb->d, tlb->wt);
1.1.1.7   root     1375: }
                   1376: 
1.1.1.9 ! root     1377: static void tlb_info(Monitor *mon)
1.1.1.7   root     1378: {
                   1379:     CPUState *env = mon_get_cpu();
                   1380:     int i;
                   1381: 
1.1.1.9 ! root     1382:     monitor_printf (mon, "ITLB:\n");
1.1.1.7   root     1383:     for (i = 0 ; i < ITLB_SIZE ; i++)
1.1.1.9 ! root     1384:         print_tlb (mon, i, &env->itlb[i]);
        !          1385:     monitor_printf (mon, "UTLB:\n");
1.1.1.7   root     1386:     for (i = 0 ; i < UTLB_SIZE ; i++)
1.1.1.9 ! root     1387:         print_tlb (mon, i, &env->utlb[i]);
1.1.1.7   root     1388: }
                   1389: 
                   1390: #endif
                   1391: 
1.1.1.9 ! root     1392: static void do_info_kqemu(Monitor *mon)
1.1       root     1393: {
1.1.1.9 ! root     1394: #ifdef CONFIG_KQEMU
1.1.1.2   root     1395:     CPUState *env;
1.1       root     1396:     int val;
                   1397:     val = 0;
1.1.1.2   root     1398:     env = mon_get_cpu();
                   1399:     if (!env) {
1.1.1.9 ! root     1400:         monitor_printf(mon, "No cpu initialized yet");
1.1.1.2   root     1401:         return;
                   1402:     }
                   1403:     val = env->kqemu_enabled;
1.1.1.9 ! root     1404:     monitor_printf(mon, "kqemu support: ");
1.1.1.3   root     1405:     switch(val) {
                   1406:     default:
                   1407:     case 0:
1.1.1.9 ! root     1408:         monitor_printf(mon, "disabled\n");
1.1.1.3   root     1409:         break;
                   1410:     case 1:
1.1.1.9 ! root     1411:         monitor_printf(mon, "enabled for user code\n");
1.1.1.3   root     1412:         break;
                   1413:     case 2:
1.1.1.9 ! root     1414:         monitor_printf(mon, "enabled for user and kernel code\n");
1.1.1.3   root     1415:         break;
                   1416:     }
1.1       root     1417: #else
1.1.1.9 ! root     1418:     monitor_printf(mon, "kqemu support: not compiled\n");
1.1       root     1419: #endif
1.1.1.6   root     1420: }
1.1       root     1421: 
1.1.1.9 ! root     1422: static void do_info_kvm(Monitor *mon)
1.1.1.7   root     1423: {
                   1424: #ifdef CONFIG_KVM
1.1.1.9 ! root     1425:     monitor_printf(mon, "kvm support: ");
1.1.1.7   root     1426:     if (kvm_enabled())
1.1.1.9 ! root     1427:         monitor_printf(mon, "enabled\n");
1.1.1.7   root     1428:     else
1.1.1.9 ! root     1429:         monitor_printf(mon, "disabled\n");
1.1.1.7   root     1430: #else
1.1.1.9 ! root     1431:     monitor_printf(mon, "kvm support: not compiled\n");
1.1.1.7   root     1432: #endif
                   1433: }
                   1434: 
1.1.1.9 ! root     1435: static void do_info_numa(Monitor *mon)
        !          1436: {
        !          1437:     int i;
        !          1438:     CPUState *env;
        !          1439: 
        !          1440:     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
        !          1441:     for (i = 0; i < nb_numa_nodes; i++) {
        !          1442:         monitor_printf(mon, "node %d cpus:", i);
        !          1443:         for (env = first_cpu; env != NULL; env = env->next_cpu) {
        !          1444:             if (env->numa_node == i) {
        !          1445:                 monitor_printf(mon, " %d", env->cpu_index);
        !          1446:             }
        !          1447:         }
        !          1448:         monitor_printf(mon, "\n");
        !          1449:         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
        !          1450:             node_mem[i] >> 20);
        !          1451:     }
        !          1452: }
        !          1453: 
1.1.1.3   root     1454: #ifdef CONFIG_PROFILER
                   1455: 
                   1456: int64_t kqemu_time;
                   1457: int64_t qemu_time;
                   1458: int64_t kqemu_exec_count;
                   1459: int64_t dev_time;
                   1460: int64_t kqemu_ret_int_count;
                   1461: int64_t kqemu_ret_excp_count;
                   1462: int64_t kqemu_ret_intr_count;
                   1463: 
1.1.1.9 ! root     1464: static void do_info_profile(Monitor *mon)
1.1.1.3   root     1465: {
                   1466:     int64_t total;
                   1467:     total = qemu_time;
                   1468:     if (total == 0)
                   1469:         total = 1;
1.1.1.9 ! root     1470:     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
        !          1471:                    dev_time, dev_time / (double)ticks_per_sec);
        !          1472:     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
        !          1473:                    qemu_time, qemu_time / (double)ticks_per_sec);
        !          1474:     monitor_printf(mon, "kqemu time  %" PRId64 " (%0.3f %0.1f%%) count=%"
        !          1475:                         PRId64 " int=%" PRId64 " excp=%" PRId64 " intr=%"
        !          1476:                         PRId64 "\n",
        !          1477:                    kqemu_time, kqemu_time / (double)ticks_per_sec,
        !          1478:                    kqemu_time / (double)total * 100.0,
        !          1479:                    kqemu_exec_count,
        !          1480:                    kqemu_ret_int_count,
        !          1481:                    kqemu_ret_excp_count,
        !          1482:                    kqemu_ret_intr_count);
1.1.1.3   root     1483:     qemu_time = 0;
                   1484:     kqemu_time = 0;
                   1485:     kqemu_exec_count = 0;
                   1486:     dev_time = 0;
                   1487:     kqemu_ret_int_count = 0;
                   1488:     kqemu_ret_excp_count = 0;
                   1489:     kqemu_ret_intr_count = 0;
1.1.1.9 ! root     1490: #ifdef CONFIG_KQEMU
1.1.1.3   root     1491:     kqemu_record_dump();
                   1492: #endif
                   1493: }
                   1494: #else
1.1.1.9 ! root     1495: static void do_info_profile(Monitor *mon)
1.1.1.3   root     1496: {
1.1.1.9 ! root     1497:     monitor_printf(mon, "Internal profiler not compiled\n");
1.1.1.3   root     1498: }
                   1499: #endif
                   1500: 
1.1.1.4   root     1501: /* Capture support */
                   1502: static LIST_HEAD (capture_list_head, CaptureState) capture_head;
                   1503: 
1.1.1.9 ! root     1504: static void do_info_capture(Monitor *mon)
1.1.1.4   root     1505: {
                   1506:     int i;
                   1507:     CaptureState *s;
                   1508: 
                   1509:     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1.1.1.9 ! root     1510:         monitor_printf(mon, "[%d]: ", i);
1.1.1.4   root     1511:         s->ops.info (s->opaque);
                   1512:     }
                   1513: }
                   1514: 
1.1.1.9 ! root     1515: #ifdef HAS_AUDIO
        !          1516: static void do_stop_capture(Monitor *mon, int n)
1.1.1.4   root     1517: {
                   1518:     int i;
                   1519:     CaptureState *s;
                   1520: 
                   1521:     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
                   1522:         if (i == n) {
                   1523:             s->ops.destroy (s->opaque);
                   1524:             LIST_REMOVE (s, entries);
                   1525:             qemu_free (s);
                   1526:             return;
                   1527:         }
                   1528:     }
                   1529: }
                   1530: 
1.1.1.9 ! root     1531: static void do_wav_capture(Monitor *mon, const char *path,
        !          1532:                            int has_freq, int freq,
        !          1533:                            int has_bits, int bits,
        !          1534:                            int has_channels, int nchannels)
1.1.1.4   root     1535: {
                   1536:     CaptureState *s;
                   1537: 
                   1538:     s = qemu_mallocz (sizeof (*s));
                   1539: 
                   1540:     freq = has_freq ? freq : 44100;
                   1541:     bits = has_bits ? bits : 16;
                   1542:     nchannels = has_channels ? nchannels : 2;
                   1543: 
                   1544:     if (wav_start_capture (s, path, freq, bits, nchannels)) {
1.1.1.9 ! root     1545:         monitor_printf(mon, "Faied to add wave capture\n");
1.1.1.4   root     1546:         qemu_free (s);
                   1547:     }
                   1548:     LIST_INSERT_HEAD (&capture_head, s, entries);
                   1549: }
                   1550: #endif
                   1551: 
1.1.1.7   root     1552: #if defined(TARGET_I386)
1.1.1.9 ! root     1553: static void do_inject_nmi(Monitor *mon, int cpu_index)
1.1.1.7   root     1554: {
                   1555:     CPUState *env;
                   1556: 
                   1557:     for (env = first_cpu; env != NULL; env = env->next_cpu)
                   1558:         if (env->cpu_index == cpu_index) {
                   1559:             cpu_interrupt(env, CPU_INTERRUPT_NMI);
                   1560:             break;
                   1561:         }
                   1562: }
                   1563: #endif
                   1564: 
1.1.1.9 ! root     1565: static void do_info_status(Monitor *mon)
1.1.1.7   root     1566: {
1.1.1.9 ! root     1567:     if (vm_running) {
        !          1568:         if (singlestep) {
        !          1569:             monitor_printf(mon, "VM status: running (single step mode)\n");
        !          1570:         } else {
        !          1571:             monitor_printf(mon, "VM status: running\n");
        !          1572:         }
        !          1573:     } else
        !          1574:        monitor_printf(mon, "VM status: paused\n");
1.1.1.7   root     1575: }
                   1576: 
                   1577: 
1.1.1.9 ! root     1578: static void do_balloon(Monitor *mon, int value)
1.1.1.7   root     1579: {
                   1580:     ram_addr_t target = value;
                   1581:     qemu_balloon(target << 20);
                   1582: }
                   1583: 
1.1.1.9 ! root     1584: static void do_info_balloon(Monitor *mon)
1.1.1.7   root     1585: {
                   1586:     ram_addr_t actual;
                   1587: 
                   1588:     actual = qemu_balloon_status();
                   1589:     if (kvm_enabled() && !kvm_has_sync_mmu())
1.1.1.9 ! root     1590:         monitor_printf(mon, "Using KVM without synchronous MMU, "
        !          1591:                        "ballooning disabled\n");
1.1.1.7   root     1592:     else if (actual == 0)
1.1.1.9 ! root     1593:         monitor_printf(mon, "Ballooning not activated in VM\n");
1.1.1.7   root     1594:     else
1.1.1.9 ! root     1595:         monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
        !          1596: }
        !          1597: 
        !          1598: static qemu_acl *find_acl(Monitor *mon, const char *name)
        !          1599: {
        !          1600:     qemu_acl *acl = qemu_acl_find(name);
        !          1601: 
        !          1602:     if (!acl) {
        !          1603:         monitor_printf(mon, "acl: unknown list '%s'\n", name);
        !          1604:     }
        !          1605:     return acl;
        !          1606: }
        !          1607: 
        !          1608: static void do_acl_show(Monitor *mon, const char *aclname)
        !          1609: {
        !          1610:     qemu_acl *acl = find_acl(mon, aclname);
        !          1611:     qemu_acl_entry *entry;
        !          1612:     int i = 0;
        !          1613: 
        !          1614:     if (acl) {
        !          1615:         monitor_printf(mon, "policy: %s\n",
        !          1616:                        acl->defaultDeny ? "deny" : "allow");
        !          1617:         TAILQ_FOREACH(entry, &acl->entries, next) {
        !          1618:             i++;
        !          1619:             monitor_printf(mon, "%d: %s %s\n", i,
        !          1620:                            entry->deny ? "deny" : "allow", entry->match);
        !          1621:         }
        !          1622:     }
        !          1623: }
        !          1624: 
        !          1625: static void do_acl_reset(Monitor *mon, const char *aclname)
        !          1626: {
        !          1627:     qemu_acl *acl = find_acl(mon, aclname);
        !          1628: 
        !          1629:     if (acl) {
        !          1630:         qemu_acl_reset(acl);
        !          1631:         monitor_printf(mon, "acl: removed all rules\n");
        !          1632:     }
        !          1633: }
        !          1634: 
        !          1635: static void do_acl_policy(Monitor *mon, const char *aclname,
        !          1636:                           const char *policy)
        !          1637: {
        !          1638:     qemu_acl *acl = find_acl(mon, aclname);
        !          1639: 
        !          1640:     if (acl) {
        !          1641:         if (strcmp(policy, "allow") == 0) {
        !          1642:             acl->defaultDeny = 0;
        !          1643:             monitor_printf(mon, "acl: policy set to 'allow'\n");
        !          1644:         } else if (strcmp(policy, "deny") == 0) {
        !          1645:             acl->defaultDeny = 1;
        !          1646:             monitor_printf(mon, "acl: policy set to 'deny'\n");
        !          1647:         } else {
        !          1648:             monitor_printf(mon, "acl: unknown policy '%s', "
        !          1649:                            "expected 'deny' or 'allow'\n", policy);
        !          1650:         }
        !          1651:     }
        !          1652: }
        !          1653: 
        !          1654: static void do_acl_add(Monitor *mon, const char *aclname,
        !          1655:                        const char *match, const char *policy,
        !          1656:                        int has_index, int index)
        !          1657: {
        !          1658:     qemu_acl *acl = find_acl(mon, aclname);
        !          1659:     int deny, ret;
        !          1660: 
        !          1661:     if (acl) {
        !          1662:         if (strcmp(policy, "allow") == 0) {
        !          1663:             deny = 0;
        !          1664:         } else if (strcmp(policy, "deny") == 0) {
        !          1665:             deny = 1;
        !          1666:         } else {
        !          1667:             monitor_printf(mon, "acl: unknown policy '%s', "
        !          1668:                            "expected 'deny' or 'allow'\n", policy);
        !          1669:             return;
        !          1670:         }
        !          1671:         if (has_index)
        !          1672:             ret = qemu_acl_insert(acl, deny, match, index);
        !          1673:         else
        !          1674:             ret = qemu_acl_append(acl, deny, match);
        !          1675:         if (ret < 0)
        !          1676:             monitor_printf(mon, "acl: unable to add acl entry\n");
        !          1677:         else
        !          1678:             monitor_printf(mon, "acl: added rule at position %d\n", ret);
        !          1679:     }
        !          1680: }
        !          1681: 
        !          1682: static void do_acl_remove(Monitor *mon, const char *aclname, const char *match)
        !          1683: {
        !          1684:     qemu_acl *acl = find_acl(mon, aclname);
        !          1685:     int ret;
        !          1686: 
        !          1687:     if (acl) {
        !          1688:         ret = qemu_acl_remove(acl, match);
        !          1689:         if (ret < 0)
        !          1690:             monitor_printf(mon, "acl: no matching acl entry\n");
        !          1691:         else
        !          1692:             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
        !          1693:     }
1.1.1.7   root     1694: }
                   1695: 
                   1696: #if defined(TARGET_I386)
1.1.1.9 ! root     1697: static void do_inject_mce(Monitor *mon,
        !          1698:                           int cpu_index, int bank,
        !          1699:                           unsigned status_hi, unsigned status_lo,
        !          1700:                           unsigned mcg_status_hi, unsigned mcg_status_lo,
        !          1701:                           unsigned addr_hi, unsigned addr_lo,
        !          1702:                           unsigned misc_hi, unsigned misc_lo)
        !          1703: {
        !          1704:     CPUState *cenv;
        !          1705:     uint64_t status = ((uint64_t)status_hi << 32) | status_lo;
        !          1706:     uint64_t mcg_status = ((uint64_t)mcg_status_hi << 32) | mcg_status_lo;
        !          1707:     uint64_t addr = ((uint64_t)addr_hi << 32) | addr_lo;
        !          1708:     uint64_t misc = ((uint64_t)misc_hi << 32) | misc_lo;
        !          1709: 
        !          1710:     for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
        !          1711:         if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
        !          1712:             cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
        !          1713:             break;
        !          1714:         }
        !          1715: }
1.1.1.7   root     1716: #endif
1.1.1.9 ! root     1717: 
        !          1718: static void do_getfd(Monitor *mon, const char *fdname)
        !          1719: {
        !          1720:     mon_fd_t *monfd;
        !          1721:     int fd;
        !          1722: 
        !          1723:     fd = qemu_chr_get_msgfd(mon->chr);
        !          1724:     if (fd == -1) {
        !          1725:         monitor_printf(mon, "getfd: no file descriptor supplied via SCM_RIGHTS\n");
        !          1726:         return;
        !          1727:     }
        !          1728: 
        !          1729:     if (qemu_isdigit(fdname[0])) {
        !          1730:         monitor_printf(mon, "getfd: monitor names may not begin with a number\n");
        !          1731:         return;
        !          1732:     }
        !          1733: 
        !          1734:     fd = dup(fd);
        !          1735:     if (fd == -1) {
        !          1736:         monitor_printf(mon, "Failed to dup() file descriptor: %s\n",
        !          1737:                        strerror(errno));
        !          1738:         return;
        !          1739:     }
        !          1740: 
        !          1741:     LIST_FOREACH(monfd, &mon->fds, next) {
        !          1742:         if (strcmp(monfd->name, fdname) != 0) {
        !          1743:             continue;
        !          1744:         }
        !          1745: 
        !          1746:         close(monfd->fd);
        !          1747:         monfd->fd = fd;
        !          1748:         return;
        !          1749:     }
        !          1750: 
        !          1751:     monfd = qemu_mallocz(sizeof(mon_fd_t));
        !          1752:     monfd->name = qemu_strdup(fdname);
        !          1753:     monfd->fd = fd;
        !          1754: 
        !          1755:     LIST_INSERT_HEAD(&mon->fds, monfd, next);
        !          1756: }
        !          1757: 
        !          1758: static void do_closefd(Monitor *mon, const char *fdname)
        !          1759: {
        !          1760:     mon_fd_t *monfd;
        !          1761: 
        !          1762:     LIST_FOREACH(monfd, &mon->fds, next) {
        !          1763:         if (strcmp(monfd->name, fdname) != 0) {
        !          1764:             continue;
        !          1765:         }
        !          1766: 
        !          1767:         LIST_REMOVE(monfd, next);
        !          1768:         close(monfd->fd);
        !          1769:         qemu_free(monfd->name);
        !          1770:         qemu_free(monfd);
        !          1771:         return;
        !          1772:     }
        !          1773: 
        !          1774:     monitor_printf(mon, "Failed to find file descriptor named %s\n",
        !          1775:                    fdname);
        !          1776: }
        !          1777: 
        !          1778: int monitor_get_fd(Monitor *mon, const char *fdname)
        !          1779: {
        !          1780:     mon_fd_t *monfd;
        !          1781: 
        !          1782:     LIST_FOREACH(monfd, &mon->fds, next) {
        !          1783:         int fd;
        !          1784: 
        !          1785:         if (strcmp(monfd->name, fdname) != 0) {
        !          1786:             continue;
        !          1787:         }
        !          1788: 
        !          1789:         fd = monfd->fd;
        !          1790: 
        !          1791:         /* caller takes ownership of fd */
        !          1792:         LIST_REMOVE(monfd, next);
        !          1793:         qemu_free(monfd->name);
        !          1794:         qemu_free(monfd);
        !          1795: 
        !          1796:         return fd;
        !          1797:     }
        !          1798: 
        !          1799:     return -1;
        !          1800: }
        !          1801: 
        !          1802: static const mon_cmd_t mon_cmds[] = {
        !          1803: #include "qemu-monitor.h"
1.1.1.6   root     1804:     { NULL, NULL, },
1.1       root     1805: };
                   1806: 
1.1.1.9 ! root     1807: /* Please update qemu-monitor.hx when adding or changing commands */
        !          1808: static const mon_cmd_t info_cmds[] = {
1.1       root     1809:     { "version", "", do_info_version,
1.1.1.7   root     1810:       "", "show the version of QEMU" },
1.1       root     1811:     { "network", "", do_info_network,
                   1812:       "", "show the network state" },
1.1.1.7   root     1813:     { "chardev", "", qemu_chr_info,
                   1814:       "", "show the character devices" },
1.1.1.9 ! root     1815:     { "block", "", bdrv_info,
1.1       root     1816:       "", "show the block devices" },
1.1.1.9 ! root     1817:     { "blockstats", "", bdrv_info_stats,
1.1.1.6   root     1818:       "", "show block device statistics" },
1.1       root     1819:     { "registers", "", do_info_registers,
                   1820:       "", "show the cpu registers" },
1.1.1.2   root     1821:     { "cpus", "", do_info_cpus,
                   1822:       "", "show infos for each CPU" },
1.1       root     1823:     { "history", "", do_info_history,
                   1824:       "", "show the command line history", },
                   1825:     { "irq", "", irq_info,
                   1826:       "", "show the interrupts statistics (if available)", },
                   1827:     { "pic", "", pic_info,
                   1828:       "", "show i8259 (PIC) state", },
                   1829:     { "pci", "", pci_info,
                   1830:       "", "show PCI info", },
1.1.1.7   root     1831: #if defined(TARGET_I386) || defined(TARGET_SH4)
1.1       root     1832:     { "tlb", "", tlb_info,
                   1833:       "", "show virtual to physical memory mappings", },
1.1.1.7   root     1834: #endif
                   1835: #if defined(TARGET_I386)
1.1       root     1836:     { "mem", "", mem_info,
                   1837:       "", "show the active virtual memory mappings", },
1.1.1.7   root     1838:     { "hpet", "", do_info_hpet,
                   1839:       "", "show state of HPET", },
1.1       root     1840: #endif
                   1841:     { "jit", "", do_info_jit,
                   1842:       "", "show dynamic compiler info", },
                   1843:     { "kqemu", "", do_info_kqemu,
1.1.1.7   root     1844:       "", "show KQEMU information", },
                   1845:     { "kvm", "", do_info_kvm,
                   1846:       "", "show KVM information", },
1.1.1.9 ! root     1847:     { "numa", "", do_info_numa,
        !          1848:       "", "show NUMA information", },
1.1.1.2   root     1849:     { "usb", "", usb_info,
                   1850:       "", "show guest USB devices", },
                   1851:     { "usbhost", "", usb_host_info,
                   1852:       "", "show host USB devices", },
1.1.1.3   root     1853:     { "profile", "", do_info_profile,
                   1854:       "", "show profiling information", },
1.1.1.4   root     1855:     { "capture", "", do_info_capture,
1.1.1.5   root     1856:       "", "show capture information" },
                   1857:     { "snapshots", "", do_info_snapshots,
                   1858:       "", "show the currently saved VM snapshots" },
1.1.1.7   root     1859:     { "status", "", do_info_status,
                   1860:       "", "show the current VM status (running|paused)" },
1.1.1.6   root     1861:     { "pcmcia", "", pcmcia_info,
                   1862:       "", "show guest PCMCIA status" },
1.1.1.5   root     1863:     { "mice", "", do_info_mice,
                   1864:       "", "show which guest mouse is receiving events" },
                   1865:     { "vnc", "", do_info_vnc,
                   1866:       "", "show the vnc server status"},
1.1.1.6   root     1867:     { "name", "", do_info_name,
                   1868:       "", "show the current VM name" },
1.1.1.7   root     1869:     { "uuid", "", do_info_uuid,
                   1870:       "", "show the current VM UUID" },
1.1.1.6   root     1871: #if defined(TARGET_PPC)
                   1872:     { "cpustats", "", do_info_cpu_stats,
                   1873:       "", "show CPU statistics", },
                   1874: #endif
                   1875: #if defined(CONFIG_SLIRP)
1.1.1.9 ! root     1876:     { "usernet", "", do_info_usernet,
        !          1877:       "", "show user network stack connection states", },
1.1.1.6   root     1878: #endif
1.1.1.7   root     1879:     { "migrate", "", do_info_migrate, "", "show migration status" },
                   1880:     { "balloon", "", do_info_balloon,
                   1881:       "", "show balloon information" },
1.1.1.9 ! root     1882:     { "qtree", "", do_info_qtree,
        !          1883:       "", "show device tree" },
1.1       root     1884:     { NULL, NULL, },
                   1885: };
                   1886: 
                   1887: /*******************************************************************/
                   1888: 
                   1889: static const char *pch;
                   1890: static jmp_buf expr_env;
                   1891: 
                   1892: #define MD_TLONG 0
                   1893: #define MD_I32   1
                   1894: 
                   1895: typedef struct MonitorDef {
                   1896:     const char *name;
                   1897:     int offset;
1.1.1.7   root     1898:     target_long (*get_value)(const struct MonitorDef *md, int val);
1.1       root     1899:     int type;
                   1900: } MonitorDef;
                   1901: 
                   1902: #if defined(TARGET_I386)
1.1.1.7   root     1903: static target_long monitor_get_pc (const struct MonitorDef *md, int val)
1.1       root     1904: {
1.1.1.2   root     1905:     CPUState *env = mon_get_cpu();
                   1906:     if (!env)
                   1907:         return 0;
                   1908:     return env->eip + env->segs[R_CS].base;
1.1       root     1909: }
                   1910: #endif
                   1911: 
                   1912: #if defined(TARGET_PPC)
1.1.1.7   root     1913: static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
1.1       root     1914: {
1.1.1.2   root     1915:     CPUState *env = mon_get_cpu();
1.1       root     1916:     unsigned int u;
                   1917:     int i;
                   1918: 
1.1.1.2   root     1919:     if (!env)
                   1920:         return 0;
                   1921: 
1.1       root     1922:     u = 0;
                   1923:     for (i = 0; i < 8; i++)
1.1.1.9 ! root     1924:         u |= env->crf[i] << (32 - (4 * i));
1.1       root     1925: 
                   1926:     return u;
                   1927: }
                   1928: 
1.1.1.7   root     1929: static target_long monitor_get_msr (const struct MonitorDef *md, int val)
1.1       root     1930: {
1.1.1.2   root     1931:     CPUState *env = mon_get_cpu();
                   1932:     if (!env)
                   1933:         return 0;
1.1.1.6   root     1934:     return env->msr;
1.1       root     1935: }
                   1936: 
1.1.1.7   root     1937: static target_long monitor_get_xer (const struct MonitorDef *md, int val)
1.1       root     1938: {
1.1.1.2   root     1939:     CPUState *env = mon_get_cpu();
                   1940:     if (!env)
                   1941:         return 0;
1.1.1.7   root     1942:     return env->xer;
1.1       root     1943: }
                   1944: 
1.1.1.7   root     1945: static target_long monitor_get_decr (const struct MonitorDef *md, int val)
1.1       root     1946: {
1.1.1.2   root     1947:     CPUState *env = mon_get_cpu();
                   1948:     if (!env)
                   1949:         return 0;
                   1950:     return cpu_ppc_load_decr(env);
1.1       root     1951: }
                   1952: 
1.1.1.7   root     1953: static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
1.1       root     1954: {
1.1.1.2   root     1955:     CPUState *env = mon_get_cpu();
                   1956:     if (!env)
                   1957:         return 0;
                   1958:     return cpu_ppc_load_tbu(env);
1.1       root     1959: }
                   1960: 
1.1.1.7   root     1961: static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
1.1       root     1962: {
1.1.1.2   root     1963:     CPUState *env = mon_get_cpu();
                   1964:     if (!env)
                   1965:         return 0;
                   1966:     return cpu_ppc_load_tbl(env);
1.1       root     1967: }
                   1968: #endif
                   1969: 
                   1970: #if defined(TARGET_SPARC)
1.1.1.2   root     1971: #ifndef TARGET_SPARC64
1.1.1.7   root     1972: static target_long monitor_get_psr (const struct MonitorDef *md, int val)
1.1       root     1973: {
1.1.1.2   root     1974:     CPUState *env = mon_get_cpu();
                   1975:     if (!env)
                   1976:         return 0;
                   1977:     return GET_PSR(env);
1.1       root     1978: }
1.1.1.2   root     1979: #endif
1.1       root     1980: 
1.1.1.7   root     1981: static target_long monitor_get_reg(const struct MonitorDef *md, int val)
1.1       root     1982: {
1.1.1.2   root     1983:     CPUState *env = mon_get_cpu();
                   1984:     if (!env)
                   1985:         return 0;
                   1986:     return env->regwptr[val];
1.1       root     1987: }
                   1988: #endif
                   1989: 
1.1.1.7   root     1990: static const MonitorDef monitor_defs[] = {
1.1       root     1991: #ifdef TARGET_I386
                   1992: 
                   1993: #define SEG(name, seg) \
                   1994:     { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
                   1995:     { name ".base", offsetof(CPUState, segs[seg].base) },\
                   1996:     { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
                   1997: 
                   1998:     { "eax", offsetof(CPUState, regs[0]) },
                   1999:     { "ecx", offsetof(CPUState, regs[1]) },
                   2000:     { "edx", offsetof(CPUState, regs[2]) },
                   2001:     { "ebx", offsetof(CPUState, regs[3]) },
                   2002:     { "esp|sp", offsetof(CPUState, regs[4]) },
                   2003:     { "ebp|fp", offsetof(CPUState, regs[5]) },
                   2004:     { "esi", offsetof(CPUState, regs[6]) },
                   2005:     { "edi", offsetof(CPUState, regs[7]) },
                   2006: #ifdef TARGET_X86_64
                   2007:     { "r8", offsetof(CPUState, regs[8]) },
                   2008:     { "r9", offsetof(CPUState, regs[9]) },
                   2009:     { "r10", offsetof(CPUState, regs[10]) },
                   2010:     { "r11", offsetof(CPUState, regs[11]) },
                   2011:     { "r12", offsetof(CPUState, regs[12]) },
                   2012:     { "r13", offsetof(CPUState, regs[13]) },
                   2013:     { "r14", offsetof(CPUState, regs[14]) },
                   2014:     { "r15", offsetof(CPUState, regs[15]) },
                   2015: #endif
                   2016:     { "eflags", offsetof(CPUState, eflags) },
                   2017:     { "eip", offsetof(CPUState, eip) },
                   2018:     SEG("cs", R_CS)
                   2019:     SEG("ds", R_DS)
                   2020:     SEG("es", R_ES)
                   2021:     SEG("ss", R_SS)
                   2022:     SEG("fs", R_FS)
                   2023:     SEG("gs", R_GS)
                   2024:     { "pc", 0, monitor_get_pc, },
                   2025: #elif defined(TARGET_PPC)
1.1.1.6   root     2026:     /* General purpose registers */
1.1       root     2027:     { "r0", offsetof(CPUState, gpr[0]) },
                   2028:     { "r1", offsetof(CPUState, gpr[1]) },
                   2029:     { "r2", offsetof(CPUState, gpr[2]) },
                   2030:     { "r3", offsetof(CPUState, gpr[3]) },
                   2031:     { "r4", offsetof(CPUState, gpr[4]) },
                   2032:     { "r5", offsetof(CPUState, gpr[5]) },
                   2033:     { "r6", offsetof(CPUState, gpr[6]) },
                   2034:     { "r7", offsetof(CPUState, gpr[7]) },
                   2035:     { "r8", offsetof(CPUState, gpr[8]) },
                   2036:     { "r9", offsetof(CPUState, gpr[9]) },
                   2037:     { "r10", offsetof(CPUState, gpr[10]) },
                   2038:     { "r11", offsetof(CPUState, gpr[11]) },
                   2039:     { "r12", offsetof(CPUState, gpr[12]) },
                   2040:     { "r13", offsetof(CPUState, gpr[13]) },
                   2041:     { "r14", offsetof(CPUState, gpr[14]) },
                   2042:     { "r15", offsetof(CPUState, gpr[15]) },
                   2043:     { "r16", offsetof(CPUState, gpr[16]) },
                   2044:     { "r17", offsetof(CPUState, gpr[17]) },
                   2045:     { "r18", offsetof(CPUState, gpr[18]) },
                   2046:     { "r19", offsetof(CPUState, gpr[19]) },
                   2047:     { "r20", offsetof(CPUState, gpr[20]) },
                   2048:     { "r21", offsetof(CPUState, gpr[21]) },
                   2049:     { "r22", offsetof(CPUState, gpr[22]) },
                   2050:     { "r23", offsetof(CPUState, gpr[23]) },
                   2051:     { "r24", offsetof(CPUState, gpr[24]) },
                   2052:     { "r25", offsetof(CPUState, gpr[25]) },
                   2053:     { "r26", offsetof(CPUState, gpr[26]) },
                   2054:     { "r27", offsetof(CPUState, gpr[27]) },
                   2055:     { "r28", offsetof(CPUState, gpr[28]) },
                   2056:     { "r29", offsetof(CPUState, gpr[29]) },
                   2057:     { "r30", offsetof(CPUState, gpr[30]) },
                   2058:     { "r31", offsetof(CPUState, gpr[31]) },
1.1.1.6   root     2059:     /* Floating point registers */
                   2060:     { "f0", offsetof(CPUState, fpr[0]) },
                   2061:     { "f1", offsetof(CPUState, fpr[1]) },
                   2062:     { "f2", offsetof(CPUState, fpr[2]) },
                   2063:     { "f3", offsetof(CPUState, fpr[3]) },
                   2064:     { "f4", offsetof(CPUState, fpr[4]) },
                   2065:     { "f5", offsetof(CPUState, fpr[5]) },
                   2066:     { "f6", offsetof(CPUState, fpr[6]) },
                   2067:     { "f7", offsetof(CPUState, fpr[7]) },
                   2068:     { "f8", offsetof(CPUState, fpr[8]) },
                   2069:     { "f9", offsetof(CPUState, fpr[9]) },
                   2070:     { "f10", offsetof(CPUState, fpr[10]) },
                   2071:     { "f11", offsetof(CPUState, fpr[11]) },
                   2072:     { "f12", offsetof(CPUState, fpr[12]) },
                   2073:     { "f13", offsetof(CPUState, fpr[13]) },
                   2074:     { "f14", offsetof(CPUState, fpr[14]) },
                   2075:     { "f15", offsetof(CPUState, fpr[15]) },
                   2076:     { "f16", offsetof(CPUState, fpr[16]) },
                   2077:     { "f17", offsetof(CPUState, fpr[17]) },
                   2078:     { "f18", offsetof(CPUState, fpr[18]) },
                   2079:     { "f19", offsetof(CPUState, fpr[19]) },
                   2080:     { "f20", offsetof(CPUState, fpr[20]) },
                   2081:     { "f21", offsetof(CPUState, fpr[21]) },
                   2082:     { "f22", offsetof(CPUState, fpr[22]) },
                   2083:     { "f23", offsetof(CPUState, fpr[23]) },
                   2084:     { "f24", offsetof(CPUState, fpr[24]) },
                   2085:     { "f25", offsetof(CPUState, fpr[25]) },
                   2086:     { "f26", offsetof(CPUState, fpr[26]) },
                   2087:     { "f27", offsetof(CPUState, fpr[27]) },
                   2088:     { "f28", offsetof(CPUState, fpr[28]) },
                   2089:     { "f29", offsetof(CPUState, fpr[29]) },
                   2090:     { "f30", offsetof(CPUState, fpr[30]) },
                   2091:     { "f31", offsetof(CPUState, fpr[31]) },
                   2092:     { "fpscr", offsetof(CPUState, fpscr) },
                   2093:     /* Next instruction pointer */
1.1       root     2094:     { "nip|pc", offsetof(CPUState, nip) },
                   2095:     { "lr", offsetof(CPUState, lr) },
                   2096:     { "ctr", offsetof(CPUState, ctr) },
                   2097:     { "decr", 0, &monitor_get_decr, },
                   2098:     { "ccr", 0, &monitor_get_ccr, },
1.1.1.6   root     2099:     /* Machine state register */
1.1       root     2100:     { "msr", 0, &monitor_get_msr, },
                   2101:     { "xer", 0, &monitor_get_xer, },
                   2102:     { "tbu", 0, &monitor_get_tbu, },
                   2103:     { "tbl", 0, &monitor_get_tbl, },
1.1.1.6   root     2104: #if defined(TARGET_PPC64)
                   2105:     /* Address space register */
                   2106:     { "asr", offsetof(CPUState, asr) },
                   2107: #endif
                   2108:     /* Segment registers */
1.1       root     2109:     { "sdr1", offsetof(CPUState, sdr1) },
                   2110:     { "sr0", offsetof(CPUState, sr[0]) },
                   2111:     { "sr1", offsetof(CPUState, sr[1]) },
                   2112:     { "sr2", offsetof(CPUState, sr[2]) },
                   2113:     { "sr3", offsetof(CPUState, sr[3]) },
                   2114:     { "sr4", offsetof(CPUState, sr[4]) },
                   2115:     { "sr5", offsetof(CPUState, sr[5]) },
                   2116:     { "sr6", offsetof(CPUState, sr[6]) },
                   2117:     { "sr7", offsetof(CPUState, sr[7]) },
                   2118:     { "sr8", offsetof(CPUState, sr[8]) },
                   2119:     { "sr9", offsetof(CPUState, sr[9]) },
                   2120:     { "sr10", offsetof(CPUState, sr[10]) },
                   2121:     { "sr11", offsetof(CPUState, sr[11]) },
                   2122:     { "sr12", offsetof(CPUState, sr[12]) },
                   2123:     { "sr13", offsetof(CPUState, sr[13]) },
                   2124:     { "sr14", offsetof(CPUState, sr[14]) },
                   2125:     { "sr15", offsetof(CPUState, sr[15]) },
                   2126:     /* Too lazy to put BATs and SPRs ... */
                   2127: #elif defined(TARGET_SPARC)
                   2128:     { "g0", offsetof(CPUState, gregs[0]) },
                   2129:     { "g1", offsetof(CPUState, gregs[1]) },
                   2130:     { "g2", offsetof(CPUState, gregs[2]) },
                   2131:     { "g3", offsetof(CPUState, gregs[3]) },
                   2132:     { "g4", offsetof(CPUState, gregs[4]) },
                   2133:     { "g5", offsetof(CPUState, gregs[5]) },
                   2134:     { "g6", offsetof(CPUState, gregs[6]) },
                   2135:     { "g7", offsetof(CPUState, gregs[7]) },
                   2136:     { "o0", 0, monitor_get_reg },
                   2137:     { "o1", 1, monitor_get_reg },
                   2138:     { "o2", 2, monitor_get_reg },
                   2139:     { "o3", 3, monitor_get_reg },
                   2140:     { "o4", 4, monitor_get_reg },
                   2141:     { "o5", 5, monitor_get_reg },
                   2142:     { "o6", 6, monitor_get_reg },
                   2143:     { "o7", 7, monitor_get_reg },
                   2144:     { "l0", 8, monitor_get_reg },
                   2145:     { "l1", 9, monitor_get_reg },
                   2146:     { "l2", 10, monitor_get_reg },
                   2147:     { "l3", 11, monitor_get_reg },
                   2148:     { "l4", 12, monitor_get_reg },
                   2149:     { "l5", 13, monitor_get_reg },
                   2150:     { "l6", 14, monitor_get_reg },
                   2151:     { "l7", 15, monitor_get_reg },
                   2152:     { "i0", 16, monitor_get_reg },
                   2153:     { "i1", 17, monitor_get_reg },
                   2154:     { "i2", 18, monitor_get_reg },
                   2155:     { "i3", 19, monitor_get_reg },
                   2156:     { "i4", 20, monitor_get_reg },
                   2157:     { "i5", 21, monitor_get_reg },
                   2158:     { "i6", 22, monitor_get_reg },
                   2159:     { "i7", 23, monitor_get_reg },
                   2160:     { "pc", offsetof(CPUState, pc) },
                   2161:     { "npc", offsetof(CPUState, npc) },
                   2162:     { "y", offsetof(CPUState, y) },
1.1.1.2   root     2163: #ifndef TARGET_SPARC64
1.1       root     2164:     { "psr", 0, &monitor_get_psr, },
                   2165:     { "wim", offsetof(CPUState, wim) },
1.1.1.2   root     2166: #endif
1.1       root     2167:     { "tbr", offsetof(CPUState, tbr) },
                   2168:     { "fsr", offsetof(CPUState, fsr) },
                   2169:     { "f0", offsetof(CPUState, fpr[0]) },
                   2170:     { "f1", offsetof(CPUState, fpr[1]) },
                   2171:     { "f2", offsetof(CPUState, fpr[2]) },
                   2172:     { "f3", offsetof(CPUState, fpr[3]) },
                   2173:     { "f4", offsetof(CPUState, fpr[4]) },
                   2174:     { "f5", offsetof(CPUState, fpr[5]) },
                   2175:     { "f6", offsetof(CPUState, fpr[6]) },
                   2176:     { "f7", offsetof(CPUState, fpr[7]) },
                   2177:     { "f8", offsetof(CPUState, fpr[8]) },
                   2178:     { "f9", offsetof(CPUState, fpr[9]) },
                   2179:     { "f10", offsetof(CPUState, fpr[10]) },
                   2180:     { "f11", offsetof(CPUState, fpr[11]) },
                   2181:     { "f12", offsetof(CPUState, fpr[12]) },
                   2182:     { "f13", offsetof(CPUState, fpr[13]) },
                   2183:     { "f14", offsetof(CPUState, fpr[14]) },
                   2184:     { "f15", offsetof(CPUState, fpr[15]) },
                   2185:     { "f16", offsetof(CPUState, fpr[16]) },
                   2186:     { "f17", offsetof(CPUState, fpr[17]) },
                   2187:     { "f18", offsetof(CPUState, fpr[18]) },
                   2188:     { "f19", offsetof(CPUState, fpr[19]) },
                   2189:     { "f20", offsetof(CPUState, fpr[20]) },
                   2190:     { "f21", offsetof(CPUState, fpr[21]) },
                   2191:     { "f22", offsetof(CPUState, fpr[22]) },
                   2192:     { "f23", offsetof(CPUState, fpr[23]) },
                   2193:     { "f24", offsetof(CPUState, fpr[24]) },
                   2194:     { "f25", offsetof(CPUState, fpr[25]) },
                   2195:     { "f26", offsetof(CPUState, fpr[26]) },
                   2196:     { "f27", offsetof(CPUState, fpr[27]) },
                   2197:     { "f28", offsetof(CPUState, fpr[28]) },
                   2198:     { "f29", offsetof(CPUState, fpr[29]) },
                   2199:     { "f30", offsetof(CPUState, fpr[30]) },
                   2200:     { "f31", offsetof(CPUState, fpr[31]) },
1.1.1.2   root     2201: #ifdef TARGET_SPARC64
                   2202:     { "f32", offsetof(CPUState, fpr[32]) },
                   2203:     { "f34", offsetof(CPUState, fpr[34]) },
                   2204:     { "f36", offsetof(CPUState, fpr[36]) },
                   2205:     { "f38", offsetof(CPUState, fpr[38]) },
                   2206:     { "f40", offsetof(CPUState, fpr[40]) },
                   2207:     { "f42", offsetof(CPUState, fpr[42]) },
                   2208:     { "f44", offsetof(CPUState, fpr[44]) },
                   2209:     { "f46", offsetof(CPUState, fpr[46]) },
                   2210:     { "f48", offsetof(CPUState, fpr[48]) },
                   2211:     { "f50", offsetof(CPUState, fpr[50]) },
                   2212:     { "f52", offsetof(CPUState, fpr[52]) },
                   2213:     { "f54", offsetof(CPUState, fpr[54]) },
                   2214:     { "f56", offsetof(CPUState, fpr[56]) },
                   2215:     { "f58", offsetof(CPUState, fpr[58]) },
                   2216:     { "f60", offsetof(CPUState, fpr[60]) },
                   2217:     { "f62", offsetof(CPUState, fpr[62]) },
                   2218:     { "asi", offsetof(CPUState, asi) },
                   2219:     { "pstate", offsetof(CPUState, pstate) },
                   2220:     { "cansave", offsetof(CPUState, cansave) },
                   2221:     { "canrestore", offsetof(CPUState, canrestore) },
                   2222:     { "otherwin", offsetof(CPUState, otherwin) },
                   2223:     { "wstate", offsetof(CPUState, wstate) },
                   2224:     { "cleanwin", offsetof(CPUState, cleanwin) },
                   2225:     { "fprs", offsetof(CPUState, fprs) },
                   2226: #endif
1.1       root     2227: #endif
                   2228:     { NULL },
                   2229: };
                   2230: 
1.1.1.9 ! root     2231: static void expr_error(Monitor *mon, const char *msg)
1.1       root     2232: {
1.1.1.9 ! root     2233:     monitor_printf(mon, "%s\n", msg);
1.1       root     2234:     longjmp(expr_env, 1);
                   2235: }
                   2236: 
1.1.1.2   root     2237: /* return 0 if OK, -1 if not found, -2 if no CPU defined */
1.1       root     2238: static int get_monitor_def(target_long *pval, const char *name)
                   2239: {
1.1.1.7   root     2240:     const MonitorDef *md;
1.1       root     2241:     void *ptr;
                   2242: 
                   2243:     for(md = monitor_defs; md->name != NULL; md++) {
                   2244:         if (compare_cmd(name, md->name)) {
                   2245:             if (md->get_value) {
                   2246:                 *pval = md->get_value(md, md->offset);
                   2247:             } else {
1.1.1.2   root     2248:                 CPUState *env = mon_get_cpu();
                   2249:                 if (!env)
                   2250:                     return -2;
                   2251:                 ptr = (uint8_t *)env + md->offset;
1.1       root     2252:                 switch(md->type) {
                   2253:                 case MD_I32:
                   2254:                     *pval = *(int32_t *)ptr;
                   2255:                     break;
                   2256:                 case MD_TLONG:
                   2257:                     *pval = *(target_long *)ptr;
                   2258:                     break;
                   2259:                 default:
                   2260:                     *pval = 0;
                   2261:                     break;
                   2262:                 }
                   2263:             }
                   2264:             return 0;
                   2265:         }
                   2266:     }
                   2267:     return -1;
                   2268: }
                   2269: 
                   2270: static void next(void)
                   2271: {
1.1.1.9 ! root     2272:     if (*pch != '\0') {
1.1       root     2273:         pch++;
1.1.1.7   root     2274:         while (qemu_isspace(*pch))
1.1       root     2275:             pch++;
                   2276:     }
                   2277: }
                   2278: 
1.1.1.9 ! root     2279: static int64_t expr_sum(Monitor *mon);
1.1       root     2280: 
1.1.1.9 ! root     2281: static int64_t expr_unary(Monitor *mon)
1.1       root     2282: {
1.1.1.6   root     2283:     int64_t n;
1.1       root     2284:     char *p;
1.1.1.2   root     2285:     int ret;
1.1       root     2286: 
                   2287:     switch(*pch) {
                   2288:     case '+':
                   2289:         next();
1.1.1.9 ! root     2290:         n = expr_unary(mon);
1.1       root     2291:         break;
                   2292:     case '-':
                   2293:         next();
1.1.1.9 ! root     2294:         n = -expr_unary(mon);
1.1       root     2295:         break;
                   2296:     case '~':
                   2297:         next();
1.1.1.9 ! root     2298:         n = ~expr_unary(mon);
1.1       root     2299:         break;
                   2300:     case '(':
                   2301:         next();
1.1.1.9 ! root     2302:         n = expr_sum(mon);
1.1       root     2303:         if (*pch != ')') {
1.1.1.9 ! root     2304:             expr_error(mon, "')' expected");
1.1       root     2305:         }
                   2306:         next();
                   2307:         break;
                   2308:     case '\'':
                   2309:         pch++;
                   2310:         if (*pch == '\0')
1.1.1.9 ! root     2311:             expr_error(mon, "character constant expected");
1.1       root     2312:         n = *pch;
                   2313:         pch++;
                   2314:         if (*pch != '\'')
1.1.1.9 ! root     2315:             expr_error(mon, "missing terminating \' character");
1.1       root     2316:         next();
                   2317:         break;
                   2318:     case '$':
                   2319:         {
                   2320:             char buf[128], *q;
1.1.1.6   root     2321:             target_long reg=0;
                   2322: 
1.1       root     2323:             pch++;
                   2324:             q = buf;
                   2325:             while ((*pch >= 'a' && *pch <= 'z') ||
                   2326:                    (*pch >= 'A' && *pch <= 'Z') ||
                   2327:                    (*pch >= '0' && *pch <= '9') ||
                   2328:                    *pch == '_' || *pch == '.') {
                   2329:                 if ((q - buf) < sizeof(buf) - 1)
                   2330:                     *q++ = *pch;
                   2331:                 pch++;
                   2332:             }
1.1.1.7   root     2333:             while (qemu_isspace(*pch))
1.1       root     2334:                 pch++;
                   2335:             *q = 0;
1.1.1.6   root     2336:             ret = get_monitor_def(&reg, buf);
1.1.1.2   root     2337:             if (ret == -1)
1.1.1.9 ! root     2338:                 expr_error(mon, "unknown register");
1.1.1.6   root     2339:             else if (ret == -2)
1.1.1.9 ! root     2340:                 expr_error(mon, "no cpu defined");
1.1.1.6   root     2341:             n = reg;
1.1       root     2342:         }
                   2343:         break;
                   2344:     case '\0':
1.1.1.9 ! root     2345:         expr_error(mon, "unexpected end of expression");
1.1       root     2346:         n = 0;
                   2347:         break;
                   2348:     default:
1.1.1.6   root     2349: #if TARGET_PHYS_ADDR_BITS > 32
1.1.1.4   root     2350:         n = strtoull(pch, &p, 0);
                   2351: #else
1.1       root     2352:         n = strtoul(pch, &p, 0);
1.1.1.4   root     2353: #endif
1.1       root     2354:         if (pch == p) {
1.1.1.9 ! root     2355:             expr_error(mon, "invalid char in expression");
1.1       root     2356:         }
                   2357:         pch = p;
1.1.1.7   root     2358:         while (qemu_isspace(*pch))
1.1       root     2359:             pch++;
                   2360:         break;
                   2361:     }
                   2362:     return n;
                   2363: }
                   2364: 
                   2365: 
1.1.1.9 ! root     2366: static int64_t expr_prod(Monitor *mon)
1.1       root     2367: {
1.1.1.6   root     2368:     int64_t val, val2;
1.1       root     2369:     int op;
1.1.1.6   root     2370: 
1.1.1.9 ! root     2371:     val = expr_unary(mon);
1.1       root     2372:     for(;;) {
                   2373:         op = *pch;
                   2374:         if (op != '*' && op != '/' && op != '%')
                   2375:             break;
                   2376:         next();
1.1.1.9 ! root     2377:         val2 = expr_unary(mon);
1.1       root     2378:         switch(op) {
                   2379:         default:
                   2380:         case '*':
                   2381:             val *= val2;
                   2382:             break;
                   2383:         case '/':
                   2384:         case '%':
1.1.1.6   root     2385:             if (val2 == 0)
1.1.1.9 ! root     2386:                 expr_error(mon, "division by zero");
1.1       root     2387:             if (op == '/')
                   2388:                 val /= val2;
                   2389:             else
                   2390:                 val %= val2;
                   2391:             break;
                   2392:         }
                   2393:     }
                   2394:     return val;
                   2395: }
                   2396: 
1.1.1.9 ! root     2397: static int64_t expr_logic(Monitor *mon)
1.1       root     2398: {
1.1.1.6   root     2399:     int64_t val, val2;
1.1       root     2400:     int op;
                   2401: 
1.1.1.9 ! root     2402:     val = expr_prod(mon);
1.1       root     2403:     for(;;) {
                   2404:         op = *pch;
                   2405:         if (op != '&' && op != '|' && op != '^')
                   2406:             break;
                   2407:         next();
1.1.1.9 ! root     2408:         val2 = expr_prod(mon);
1.1       root     2409:         switch(op) {
                   2410:         default:
                   2411:         case '&':
                   2412:             val &= val2;
                   2413:             break;
                   2414:         case '|':
                   2415:             val |= val2;
                   2416:             break;
                   2417:         case '^':
                   2418:             val ^= val2;
                   2419:             break;
                   2420:         }
                   2421:     }
                   2422:     return val;
                   2423: }
                   2424: 
1.1.1.9 ! root     2425: static int64_t expr_sum(Monitor *mon)
1.1       root     2426: {
1.1.1.6   root     2427:     int64_t val, val2;
1.1       root     2428:     int op;
                   2429: 
1.1.1.9 ! root     2430:     val = expr_logic(mon);
1.1       root     2431:     for(;;) {
                   2432:         op = *pch;
                   2433:         if (op != '+' && op != '-')
                   2434:             break;
                   2435:         next();
1.1.1.9 ! root     2436:         val2 = expr_logic(mon);
1.1       root     2437:         if (op == '+')
                   2438:             val += val2;
                   2439:         else
                   2440:             val -= val2;
                   2441:     }
                   2442:     return val;
                   2443: }
                   2444: 
1.1.1.9 ! root     2445: static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
1.1       root     2446: {
                   2447:     pch = *pp;
                   2448:     if (setjmp(expr_env)) {
                   2449:         *pp = pch;
                   2450:         return -1;
                   2451:     }
1.1.1.7   root     2452:     while (qemu_isspace(*pch))
1.1       root     2453:         pch++;
1.1.1.9 ! root     2454:     *pval = expr_sum(mon);
1.1       root     2455:     *pp = pch;
                   2456:     return 0;
                   2457: }
                   2458: 
                   2459: static int get_str(char *buf, int buf_size, const char **pp)
                   2460: {
                   2461:     const char *p;
                   2462:     char *q;
                   2463:     int c;
                   2464: 
                   2465:     q = buf;
                   2466:     p = *pp;
1.1.1.7   root     2467:     while (qemu_isspace(*p))
1.1       root     2468:         p++;
                   2469:     if (*p == '\0') {
                   2470:     fail:
                   2471:         *q = '\0';
                   2472:         *pp = p;
                   2473:         return -1;
                   2474:     }
                   2475:     if (*p == '\"') {
                   2476:         p++;
                   2477:         while (*p != '\0' && *p != '\"') {
                   2478:             if (*p == '\\') {
                   2479:                 p++;
                   2480:                 c = *p++;
                   2481:                 switch(c) {
                   2482:                 case 'n':
                   2483:                     c = '\n';
                   2484:                     break;
                   2485:                 case 'r':
                   2486:                     c = '\r';
                   2487:                     break;
                   2488:                 case '\\':
                   2489:                 case '\'':
                   2490:                 case '\"':
                   2491:                     break;
                   2492:                 default:
                   2493:                     qemu_printf("unsupported escape code: '\\%c'\n", c);
                   2494:                     goto fail;
                   2495:                 }
                   2496:                 if ((q - buf) < buf_size - 1) {
                   2497:                     *q++ = c;
                   2498:                 }
                   2499:             } else {
                   2500:                 if ((q - buf) < buf_size - 1) {
                   2501:                     *q++ = *p;
                   2502:                 }
                   2503:                 p++;
                   2504:             }
                   2505:         }
                   2506:         if (*p != '\"') {
                   2507:             qemu_printf("unterminated string\n");
                   2508:             goto fail;
                   2509:         }
                   2510:         p++;
                   2511:     } else {
1.1.1.7   root     2512:         while (*p != '\0' && !qemu_isspace(*p)) {
1.1       root     2513:             if ((q - buf) < buf_size - 1) {
                   2514:                 *q++ = *p;
                   2515:             }
                   2516:             p++;
                   2517:         }
                   2518:     }
                   2519:     *q = '\0';
                   2520:     *pp = p;
                   2521:     return 0;
                   2522: }
                   2523: 
1.1.1.9 ! root     2524: /*
        !          2525:  * Store the command-name in cmdname, and return a pointer to
        !          2526:  * the remaining of the command string.
        !          2527:  */
        !          2528: static const char *get_command_name(const char *cmdline,
        !          2529:                                     char *cmdname, size_t nlen)
        !          2530: {
        !          2531:     size_t len;
        !          2532:     const char *p, *pstart;
        !          2533: 
        !          2534:     p = cmdline;
        !          2535:     while (qemu_isspace(*p))
        !          2536:         p++;
        !          2537:     if (*p == '\0')
        !          2538:         return NULL;
        !          2539:     pstart = p;
        !          2540:     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
        !          2541:         p++;
        !          2542:     len = p - pstart;
        !          2543:     if (len > nlen - 1)
        !          2544:         len = nlen - 1;
        !          2545:     memcpy(cmdname, pstart, len);
        !          2546:     cmdname[len] = '\0';
        !          2547:     return p;
        !          2548: }
        !          2549: 
1.1       root     2550: static int default_fmt_format = 'x';
                   2551: static int default_fmt_size = 4;
                   2552: 
                   2553: #define MAX_ARGS 16
                   2554: 
1.1.1.9 ! root     2555: static void monitor_handle_command(Monitor *mon, const char *cmdline)
1.1       root     2556: {
1.1.1.9 ! root     2557:     const char *p, *typestr;
        !          2558:     int c, nb_args, i, has_arg;
        !          2559:     const mon_cmd_t *cmd;
1.1       root     2560:     char cmdname[256];
                   2561:     char buf[1024];
                   2562:     void *str_allocated[MAX_ARGS];
                   2563:     void *args[MAX_ARGS];
1.1.1.9 ! root     2564:     void (*handler_0)(Monitor *mon);
        !          2565:     void (*handler_1)(Monitor *mon, void *arg0);
        !          2566:     void (*handler_2)(Monitor *mon, void *arg0, void *arg1);
        !          2567:     void (*handler_3)(Monitor *mon, void *arg0, void *arg1, void *arg2);
        !          2568:     void (*handler_4)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2569:                       void *arg3);
        !          2570:     void (*handler_5)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2571:                       void *arg3, void *arg4);
        !          2572:     void (*handler_6)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2573:                       void *arg3, void *arg4, void *arg5);
        !          2574:     void (*handler_7)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2575:                       void *arg3, void *arg4, void *arg5, void *arg6);
        !          2576:     void (*handler_8)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2577:                       void *arg3, void *arg4, void *arg5, void *arg6,
        !          2578:                       void *arg7);
        !          2579:     void (*handler_9)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2580:                       void *arg3, void *arg4, void *arg5, void *arg6,
        !          2581:                       void *arg7, void *arg8);
        !          2582:     void (*handler_10)(Monitor *mon, void *arg0, void *arg1, void *arg2,
        !          2583:                        void *arg3, void *arg4, void *arg5, void *arg6,
        !          2584:                        void *arg7, void *arg8, void *arg9);
1.1       root     2585: 
                   2586: #ifdef DEBUG
1.1.1.9 ! root     2587:     monitor_printf(mon, "command='%s'\n", cmdline);
1.1       root     2588: #endif
1.1.1.6   root     2589: 
1.1       root     2590:     /* extract the command name */
1.1.1.9 ! root     2591:     p = get_command_name(cmdline, cmdname, sizeof(cmdname));
        !          2592:     if (!p)
1.1       root     2593:         return;
1.1.1.6   root     2594: 
1.1       root     2595:     /* find the command */
1.1.1.9 ! root     2596:     for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
1.1.1.6   root     2597:         if (compare_cmd(cmdname, cmd->name))
1.1.1.9 ! root     2598:             break;
        !          2599:     }
        !          2600: 
        !          2601:     if (cmd->name == NULL) {
        !          2602:         monitor_printf(mon, "unknown command: '%s'\n", cmdname);
        !          2603:         return;
1.1       root     2604:     }
                   2605: 
                   2606:     for(i = 0; i < MAX_ARGS; i++)
                   2607:         str_allocated[i] = NULL;
1.1.1.6   root     2608: 
1.1       root     2609:     /* parse the parameters */
                   2610:     typestr = cmd->args_type;
                   2611:     nb_args = 0;
                   2612:     for(;;) {
                   2613:         c = *typestr;
                   2614:         if (c == '\0')
                   2615:             break;
                   2616:         typestr++;
                   2617:         switch(c) {
                   2618:         case 'F':
                   2619:         case 'B':
                   2620:         case 's':
                   2621:             {
                   2622:                 int ret;
                   2623:                 char *str;
1.1.1.6   root     2624: 
1.1.1.7   root     2625:                 while (qemu_isspace(*p))
1.1       root     2626:                     p++;
                   2627:                 if (*typestr == '?') {
                   2628:                     typestr++;
                   2629:                     if (*p == '\0') {
                   2630:                         /* no optional string: NULL argument */
                   2631:                         str = NULL;
                   2632:                         goto add_str;
                   2633:                     }
                   2634:                 }
                   2635:                 ret = get_str(buf, sizeof(buf), &p);
                   2636:                 if (ret < 0) {
                   2637:                     switch(c) {
                   2638:                     case 'F':
1.1.1.9 ! root     2639:                         monitor_printf(mon, "%s: filename expected\n",
        !          2640:                                        cmdname);
1.1       root     2641:                         break;
                   2642:                     case 'B':
1.1.1.9 ! root     2643:                         monitor_printf(mon, "%s: block device name expected\n",
        !          2644:                                        cmdname);
1.1       root     2645:                         break;
                   2646:                     default:
1.1.1.9 ! root     2647:                         monitor_printf(mon, "%s: string expected\n", cmdname);
1.1       root     2648:                         break;
                   2649:                     }
                   2650:                     goto fail;
                   2651:                 }
                   2652:                 str = qemu_malloc(strlen(buf) + 1);
1.1.1.7   root     2653:                 pstrcpy(str, sizeof(buf), buf);
1.1       root     2654:                 str_allocated[nb_args] = str;
                   2655:             add_str:
                   2656:                 if (nb_args >= MAX_ARGS) {
                   2657:                 error_args:
1.1.1.9 ! root     2658:                     monitor_printf(mon, "%s: too many arguments\n", cmdname);
1.1       root     2659:                     goto fail;
                   2660:                 }
                   2661:                 args[nb_args++] = str;
                   2662:             }
                   2663:             break;
                   2664:         case '/':
                   2665:             {
                   2666:                 int count, format, size;
1.1.1.6   root     2667: 
1.1.1.7   root     2668:                 while (qemu_isspace(*p))
1.1       root     2669:                     p++;
                   2670:                 if (*p == '/') {
                   2671:                     /* format found */
                   2672:                     p++;
                   2673:                     count = 1;
1.1.1.7   root     2674:                     if (qemu_isdigit(*p)) {
1.1       root     2675:                         count = 0;
1.1.1.7   root     2676:                         while (qemu_isdigit(*p)) {
1.1       root     2677:                             count = count * 10 + (*p - '0');
                   2678:                             p++;
                   2679:                         }
                   2680:                     }
                   2681:                     size = -1;
                   2682:                     format = -1;
                   2683:                     for(;;) {
                   2684:                         switch(*p) {
                   2685:                         case 'o':
                   2686:                         case 'd':
                   2687:                         case 'u':
                   2688:                         case 'x':
                   2689:                         case 'i':
                   2690:                         case 'c':
                   2691:                             format = *p++;
                   2692:                             break;
                   2693:                         case 'b':
                   2694:                             size = 1;
                   2695:                             p++;
                   2696:                             break;
                   2697:                         case 'h':
                   2698:                             size = 2;
                   2699:                             p++;
                   2700:                             break;
                   2701:                         case 'w':
                   2702:                             size = 4;
                   2703:                             p++;
                   2704:                             break;
                   2705:                         case 'g':
                   2706:                         case 'L':
                   2707:                             size = 8;
                   2708:                             p++;
                   2709:                             break;
                   2710:                         default:
                   2711:                             goto next;
                   2712:                         }
                   2713:                     }
                   2714:                 next:
1.1.1.7   root     2715:                     if (*p != '\0' && !qemu_isspace(*p)) {
1.1.1.9 ! root     2716:                         monitor_printf(mon, "invalid char in format: '%c'\n",
        !          2717:                                        *p);
1.1       root     2718:                         goto fail;
                   2719:                     }
                   2720:                     if (format < 0)
                   2721:                         format = default_fmt_format;
                   2722:                     if (format != 'i') {
                   2723:                         /* for 'i', not specifying a size gives -1 as size */
                   2724:                         if (size < 0)
                   2725:                             size = default_fmt_size;
1.1.1.7   root     2726:                         default_fmt_size = size;
1.1       root     2727:                     }
                   2728:                     default_fmt_format = format;
                   2729:                 } else {
                   2730:                     count = 1;
                   2731:                     format = default_fmt_format;
                   2732:                     if (format != 'i') {
                   2733:                         size = default_fmt_size;
                   2734:                     } else {
                   2735:                         size = -1;
                   2736:                     }
                   2737:                 }
                   2738:                 if (nb_args + 3 > MAX_ARGS)
                   2739:                     goto error_args;
1.1.1.6   root     2740:                 args[nb_args++] = (void*)(long)count;
                   2741:                 args[nb_args++] = (void*)(long)format;
                   2742:                 args[nb_args++] = (void*)(long)size;
1.1       root     2743:             }
                   2744:             break;
                   2745:         case 'i':
                   2746:         case 'l':
                   2747:             {
1.1.1.6   root     2748:                 int64_t val;
                   2749: 
1.1.1.7   root     2750:                 while (qemu_isspace(*p))
1.1       root     2751:                     p++;
                   2752:                 if (*typestr == '?' || *typestr == '.') {
                   2753:                     if (*typestr == '?') {
                   2754:                         if (*p == '\0')
                   2755:                             has_arg = 0;
                   2756:                         else
                   2757:                             has_arg = 1;
                   2758:                     } else {
                   2759:                         if (*p == '.') {
                   2760:                             p++;
1.1.1.7   root     2761:                             while (qemu_isspace(*p))
1.1       root     2762:                                 p++;
                   2763:                             has_arg = 1;
                   2764:                         } else {
                   2765:                             has_arg = 0;
                   2766:                         }
                   2767:                     }
1.1.1.4   root     2768:                     typestr++;
1.1       root     2769:                     if (nb_args >= MAX_ARGS)
                   2770:                         goto error_args;
1.1.1.6   root     2771:                     args[nb_args++] = (void *)(long)has_arg;
1.1       root     2772:                     if (!has_arg) {
                   2773:                         if (nb_args >= MAX_ARGS)
                   2774:                             goto error_args;
                   2775:                         val = -1;
                   2776:                         goto add_num;
                   2777:                     }
                   2778:                 }
1.1.1.9 ! root     2779:                 if (get_expr(mon, &val, &p))
1.1       root     2780:                     goto fail;
                   2781:             add_num:
                   2782:                 if (c == 'i') {
                   2783:                     if (nb_args >= MAX_ARGS)
                   2784:                         goto error_args;
1.1.1.6   root     2785:                     args[nb_args++] = (void *)(long)val;
1.1       root     2786:                 } else {
                   2787:                     if ((nb_args + 1) >= MAX_ARGS)
                   2788:                         goto error_args;
1.1.1.6   root     2789: #if TARGET_PHYS_ADDR_BITS > 32
                   2790:                     args[nb_args++] = (void *)(long)((val >> 32) & 0xffffffff);
1.1       root     2791: #else
                   2792:                     args[nb_args++] = (void *)0;
                   2793: #endif
1.1.1.6   root     2794:                     args[nb_args++] = (void *)(long)(val & 0xffffffff);
1.1       root     2795:                 }
                   2796:             }
                   2797:             break;
                   2798:         case '-':
                   2799:             {
                   2800:                 int has_option;
                   2801:                 /* option */
1.1.1.6   root     2802: 
1.1       root     2803:                 c = *typestr++;
                   2804:                 if (c == '\0')
                   2805:                     goto bad_type;
1.1.1.7   root     2806:                 while (qemu_isspace(*p))
1.1       root     2807:                     p++;
                   2808:                 has_option = 0;
                   2809:                 if (*p == '-') {
                   2810:                     p++;
                   2811:                     if (*p != c) {
1.1.1.9 ! root     2812:                         monitor_printf(mon, "%s: unsupported option -%c\n",
        !          2813:                                        cmdname, *p);
1.1       root     2814:                         goto fail;
                   2815:                     }
                   2816:                     p++;
                   2817:                     has_option = 1;
                   2818:                 }
                   2819:                 if (nb_args >= MAX_ARGS)
                   2820:                     goto error_args;
1.1.1.6   root     2821:                 args[nb_args++] = (void *)(long)has_option;
1.1       root     2822:             }
                   2823:             break;
                   2824:         default:
                   2825:         bad_type:
1.1.1.9 ! root     2826:             monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
1.1       root     2827:             goto fail;
                   2828:         }
                   2829:     }
                   2830:     /* check that all arguments were parsed */
1.1.1.7   root     2831:     while (qemu_isspace(*p))
1.1       root     2832:         p++;
                   2833:     if (*p != '\0') {
1.1.1.9 ! root     2834:         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
        !          2835:                        cmdname);
1.1       root     2836:         goto fail;
                   2837:     }
                   2838: 
                   2839:     switch(nb_args) {
                   2840:     case 0:
1.1.1.7   root     2841:         handler_0 = cmd->handler;
1.1.1.9 ! root     2842:         handler_0(mon);
1.1       root     2843:         break;
                   2844:     case 1:
1.1.1.7   root     2845:         handler_1 = cmd->handler;
1.1.1.9 ! root     2846:         handler_1(mon, args[0]);
1.1       root     2847:         break;
                   2848:     case 2:
1.1.1.7   root     2849:         handler_2 = cmd->handler;
1.1.1.9 ! root     2850:         handler_2(mon, args[0], args[1]);
1.1       root     2851:         break;
                   2852:     case 3:
1.1.1.7   root     2853:         handler_3 = cmd->handler;
1.1.1.9 ! root     2854:         handler_3(mon, args[0], args[1], args[2]);
1.1       root     2855:         break;
                   2856:     case 4:
1.1.1.7   root     2857:         handler_4 = cmd->handler;
1.1.1.9 ! root     2858:         handler_4(mon, args[0], args[1], args[2], args[3]);
1.1       root     2859:         break;
                   2860:     case 5:
1.1.1.7   root     2861:         handler_5 = cmd->handler;
1.1.1.9 ! root     2862:         handler_5(mon, args[0], args[1], args[2], args[3], args[4]);
1.1       root     2863:         break;
                   2864:     case 6:
1.1.1.7   root     2865:         handler_6 = cmd->handler;
1.1.1.9 ! root     2866:         handler_6(mon, args[0], args[1], args[2], args[3], args[4], args[5]);
1.1       root     2867:         break;
1.1.1.4   root     2868:     case 7:
1.1.1.7   root     2869:         handler_7 = cmd->handler;
1.1.1.9 ! root     2870:         handler_7(mon, args[0], args[1], args[2], args[3], args[4], args[5],
        !          2871:                   args[6]);
        !          2872:         break;
        !          2873:     case 8:
        !          2874:         handler_8 = cmd->handler;
        !          2875:         handler_8(mon, args[0], args[1], args[2], args[3], args[4], args[5],
        !          2876:                   args[6], args[7]);
        !          2877:         break;
        !          2878:     case 9:
        !          2879:         handler_9 = cmd->handler;
        !          2880:         handler_9(mon, args[0], args[1], args[2], args[3], args[4], args[5],
        !          2881:                   args[6], args[7], args[8]);
        !          2882:         break;
        !          2883:     case 10:
        !          2884:         handler_10 = cmd->handler;
        !          2885:         handler_10(mon, args[0], args[1], args[2], args[3], args[4], args[5],
        !          2886:                    args[6], args[7], args[8], args[9]);
1.1.1.4   root     2887:         break;
1.1       root     2888:     default:
1.1.1.9 ! root     2889:         monitor_printf(mon, "unsupported number of arguments: %d\n", nb_args);
1.1       root     2890:         goto fail;
                   2891:     }
                   2892:  fail:
                   2893:     for(i = 0; i < MAX_ARGS; i++)
                   2894:         qemu_free(str_allocated[i]);
                   2895: }
                   2896: 
                   2897: static void cmd_completion(const char *name, const char *list)
                   2898: {
                   2899:     const char *p, *pstart;
                   2900:     char cmd[128];
                   2901:     int len;
                   2902: 
                   2903:     p = list;
                   2904:     for(;;) {
                   2905:         pstart = p;
                   2906:         p = strchr(p, '|');
                   2907:         if (!p)
                   2908:             p = pstart + strlen(pstart);
                   2909:         len = p - pstart;
                   2910:         if (len > sizeof(cmd) - 2)
                   2911:             len = sizeof(cmd) - 2;
                   2912:         memcpy(cmd, pstart, len);
                   2913:         cmd[len] = '\0';
                   2914:         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
1.1.1.9 ! root     2915:             readline_add_completion(cur_mon->rs, cmd);
1.1       root     2916:         }
                   2917:         if (*p == '\0')
                   2918:             break;
                   2919:         p++;
                   2920:     }
                   2921: }
                   2922: 
                   2923: static void file_completion(const char *input)
                   2924: {
                   2925:     DIR *ffs;
                   2926:     struct dirent *d;
                   2927:     char path[1024];
                   2928:     char file[1024], file_prefix[1024];
                   2929:     int input_path_len;
                   2930:     const char *p;
                   2931: 
1.1.1.6   root     2932:     p = strrchr(input, '/');
1.1       root     2933:     if (!p) {
                   2934:         input_path_len = 0;
                   2935:         pstrcpy(file_prefix, sizeof(file_prefix), input);
1.1.1.7   root     2936:         pstrcpy(path, sizeof(path), ".");
1.1       root     2937:     } else {
                   2938:         input_path_len = p - input + 1;
                   2939:         memcpy(path, input, input_path_len);
                   2940:         if (input_path_len > sizeof(path) - 1)
                   2941:             input_path_len = sizeof(path) - 1;
                   2942:         path[input_path_len] = '\0';
                   2943:         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
                   2944:     }
                   2945: #ifdef DEBUG_COMPLETION
1.1.1.9 ! root     2946:     monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
        !          2947:                    input, path, file_prefix);
1.1       root     2948: #endif
                   2949:     ffs = opendir(path);
                   2950:     if (!ffs)
                   2951:         return;
                   2952:     for(;;) {
                   2953:         struct stat sb;
                   2954:         d = readdir(ffs);
                   2955:         if (!d)
                   2956:             break;
                   2957:         if (strstart(d->d_name, file_prefix, NULL)) {
                   2958:             memcpy(file, input, input_path_len);
1.1.1.7   root     2959:             if (input_path_len < sizeof(file))
                   2960:                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
                   2961:                         d->d_name);
1.1       root     2962:             /* stat the file to find out if it's a directory.
                   2963:              * In that case add a slash to speed up typing long paths
                   2964:              */
                   2965:             stat(file, &sb);
                   2966:             if(S_ISDIR(sb.st_mode))
1.1.1.7   root     2967:                 pstrcat(file, sizeof(file), "/");
1.1.1.9 ! root     2968:             readline_add_completion(cur_mon->rs, file);
1.1       root     2969:         }
                   2970:     }
                   2971:     closedir(ffs);
                   2972: }
                   2973: 
1.1.1.8   root     2974: static void block_completion_it(void *opaque, BlockDriverState *bs)
1.1       root     2975: {
1.1.1.8   root     2976:     const char *name = bdrv_get_device_name(bs);
1.1       root     2977:     const char *input = opaque;
                   2978: 
                   2979:     if (input[0] == '\0' ||
                   2980:         !strncmp(name, (char *)input, strlen(input))) {
1.1.1.9 ! root     2981:         readline_add_completion(cur_mon->rs, name);
1.1       root     2982:     }
                   2983: }
                   2984: 
                   2985: /* NOTE: this parser is an approximate form of the real command parser */
                   2986: static void parse_cmdline(const char *cmdline,
                   2987:                          int *pnb_args, char **args)
                   2988: {
                   2989:     const char *p;
                   2990:     int nb_args, ret;
                   2991:     char buf[1024];
                   2992: 
                   2993:     p = cmdline;
                   2994:     nb_args = 0;
                   2995:     for(;;) {
1.1.1.7   root     2996:         while (qemu_isspace(*p))
1.1       root     2997:             p++;
                   2998:         if (*p == '\0')
                   2999:             break;
                   3000:         if (nb_args >= MAX_ARGS)
                   3001:             break;
                   3002:         ret = get_str(buf, sizeof(buf), &p);
                   3003:         args[nb_args] = qemu_strdup(buf);
                   3004:         nb_args++;
                   3005:         if (ret < 0)
                   3006:             break;
                   3007:     }
                   3008:     *pnb_args = nb_args;
                   3009: }
                   3010: 
1.1.1.9 ! root     3011: static void monitor_find_completion(const char *cmdline)
1.1       root     3012: {
                   3013:     const char *cmdname;
                   3014:     char *args[MAX_ARGS];
                   3015:     int nb_args, i, len;
                   3016:     const char *ptype, *str;
1.1.1.9 ! root     3017:     const mon_cmd_t *cmd;
1.1.1.4   root     3018:     const KeyDef *key;
1.1       root     3019: 
                   3020:     parse_cmdline(cmdline, &nb_args, args);
                   3021: #ifdef DEBUG_COMPLETION
                   3022:     for(i = 0; i < nb_args; i++) {
1.1.1.9 ! root     3023:         monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
1.1       root     3024:     }
                   3025: #endif
                   3026: 
                   3027:     /* if the line ends with a space, it means we want to complete the
                   3028:        next arg */
                   3029:     len = strlen(cmdline);
1.1.1.7   root     3030:     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
1.1       root     3031:         if (nb_args >= MAX_ARGS)
                   3032:             return;
                   3033:         args[nb_args++] = qemu_strdup("");
                   3034:     }
                   3035:     if (nb_args <= 1) {
                   3036:         /* command completion */
                   3037:         if (nb_args == 0)
                   3038:             cmdname = "";
                   3039:         else
                   3040:             cmdname = args[0];
1.1.1.9 ! root     3041:         readline_set_completion_index(cur_mon->rs, strlen(cmdname));
        !          3042:         for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
1.1       root     3043:             cmd_completion(cmdname, cmd->name);
                   3044:         }
                   3045:     } else {
                   3046:         /* find the command */
1.1.1.9 ! root     3047:         for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
1.1       root     3048:             if (compare_cmd(args[0], cmd->name))
                   3049:                 goto found;
                   3050:         }
                   3051:         return;
                   3052:     found:
                   3053:         ptype = cmd->args_type;
                   3054:         for(i = 0; i < nb_args - 2; i++) {
                   3055:             if (*ptype != '\0') {
                   3056:                 ptype++;
                   3057:                 while (*ptype == '?')
                   3058:                     ptype++;
                   3059:             }
                   3060:         }
                   3061:         str = args[nb_args - 1];
1.1.1.9 ! root     3062:         if (*ptype == '-' && ptype[1] != '\0') {
        !          3063:             ptype += 2;
        !          3064:         }
1.1       root     3065:         switch(*ptype) {
                   3066:         case 'F':
                   3067:             /* file completion */
1.1.1.9 ! root     3068:             readline_set_completion_index(cur_mon->rs, strlen(str));
1.1       root     3069:             file_completion(str);
                   3070:             break;
                   3071:         case 'B':
                   3072:             /* block device name completion */
1.1.1.9 ! root     3073:             readline_set_completion_index(cur_mon->rs, strlen(str));
1.1       root     3074:             bdrv_iterate(block_completion_it, (void *)str);
                   3075:             break;
                   3076:         case 's':
                   3077:             /* XXX: more generic ? */
                   3078:             if (!strcmp(cmd->name, "info")) {
1.1.1.9 ! root     3079:                 readline_set_completion_index(cur_mon->rs, strlen(str));
1.1       root     3080:                 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
                   3081:                     cmd_completion(str, cmd->name);
                   3082:                 }
1.1.1.4   root     3083:             } else if (!strcmp(cmd->name, "sendkey")) {
1.1.1.9 ! root     3084:                 char *sep = strrchr(str, '-');
        !          3085:                 if (sep)
        !          3086:                     str = sep + 1;
        !          3087:                 readline_set_completion_index(cur_mon->rs, strlen(str));
1.1.1.4   root     3088:                 for(key = key_defs; key->name != NULL; key++) {
                   3089:                     cmd_completion(str, key->name);
                   3090:                 }
1.1.1.9 ! root     3091:             } else if (!strcmp(cmd->name, "help|?")) {
        !          3092:                 readline_set_completion_index(cur_mon->rs, strlen(str));
        !          3093:                 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
        !          3094:                     cmd_completion(str, cmd->name);
        !          3095:                 }
1.1       root     3096:             }
                   3097:             break;
                   3098:         default:
                   3099:             break;
                   3100:         }
                   3101:     }
                   3102:     for(i = 0; i < nb_args; i++)
                   3103:         qemu_free(args[i]);
                   3104: }
                   3105: 
1.1.1.9 ! root     3106: static int monitor_can_read(void *opaque)
1.1       root     3107: {
1.1.1.9 ! root     3108:     Monitor *mon = opaque;
        !          3109: 
        !          3110:     return (mon->suspend_cnt == 0) ? 128 : 0;
1.1       root     3111: }
                   3112: 
1.1.1.9 ! root     3113: static void monitor_read(void *opaque, const uint8_t *buf, int size)
1.1       root     3114: {
1.1.1.9 ! root     3115:     Monitor *old_mon = cur_mon;
1.1       root     3116:     int i;
                   3117: 
1.1.1.9 ! root     3118:     cur_mon = opaque;
1.1       root     3119: 
1.1.1.9 ! root     3120:     if (cur_mon->rs) {
        !          3121:         for (i = 0; i < size; i++)
        !          3122:             readline_handle_byte(cur_mon->rs, buf[i]);
        !          3123:     } else {
        !          3124:         if (size == 0 || buf[size - 1] != 0)
        !          3125:             monitor_printf(cur_mon, "corrupted command\n");
        !          3126:         else
        !          3127:             monitor_handle_command(cur_mon, (char *)buf);
        !          3128:     }
        !          3129: 
        !          3130:     cur_mon = old_mon;
1.1.1.7   root     3131: }
                   3132: 
1.1.1.9 ! root     3133: static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
1.1.1.7   root     3134: {
1.1.1.9 ! root     3135:     monitor_suspend(mon);
        !          3136:     monitor_handle_command(mon, cmdline);
        !          3137:     monitor_resume(mon);
1.1.1.7   root     3138: }
                   3139: 
1.1.1.9 ! root     3140: int monitor_suspend(Monitor *mon)
1.1.1.7   root     3141: {
1.1.1.9 ! root     3142:     if (!mon->rs)
        !          3143:         return -ENOTTY;
        !          3144:     mon->suspend_cnt++;
        !          3145:     return 0;
1.1       root     3146: }
                   3147: 
1.1.1.9 ! root     3148: void monitor_resume(Monitor *mon)
1.1       root     3149: {
1.1.1.9 ! root     3150:     if (!mon->rs)
        !          3151:         return;
        !          3152:     if (--mon->suspend_cnt == 0)
        !          3153:         readline_show_prompt(mon->rs);
1.1       root     3154: }
                   3155: 
1.1.1.9 ! root     3156: static void monitor_event(void *opaque, int event)
1.1.1.5   root     3157: {
1.1.1.9 ! root     3158:     Monitor *mon = opaque;
1.1.1.5   root     3159: 
1.1.1.9 ! root     3160:     switch (event) {
        !          3161:     case CHR_EVENT_MUX_IN:
        !          3162:         readline_restart(mon->rs);
        !          3163:         monitor_resume(mon);
        !          3164:         monitor_flush(mon);
        !          3165:         break;
        !          3166: 
        !          3167:     case CHR_EVENT_MUX_OUT:
        !          3168:         if (mon->suspend_cnt == 0)
        !          3169:             monitor_printf(mon, "\n");
        !          3170:         monitor_flush(mon);
        !          3171:         monitor_suspend(mon);
        !          3172:         break;
        !          3173: 
        !          3174:     case CHR_EVENT_RESET:
        !          3175:         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
        !          3176:                        "information\n", QEMU_VERSION);
        !          3177:         if (mon->chr->focus == 0)
        !          3178:             readline_show_prompt(mon->rs);
        !          3179:         break;
        !          3180:     }
1.1.1.5   root     3181: }
                   3182: 
1.1.1.6   root     3183: 
1.1.1.9 ! root     3184: /*
        !          3185:  * Local variables:
        !          3186:  *  c-indent-level: 4
        !          3187:  *  c-basic-offset: 4
        !          3188:  *  tab-width: 8
        !          3189:  * End:
        !          3190:  */
        !          3191: 
        !          3192: void monitor_init(CharDriverState *chr, int flags)
1.1       root     3193: {
1.1.1.9 ! root     3194:     static int is_first_init = 1;
        !          3195:     Monitor *mon;
1.1.1.6   root     3196: 
                   3197:     if (is_first_init) {
1.1.1.7   root     3198:         key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
1.1.1.6   root     3199:         is_first_init = 0;
                   3200:     }
                   3201: 
1.1.1.9 ! root     3202:     mon = qemu_mallocz(sizeof(*mon));
1.1.1.5   root     3203: 
1.1.1.9 ! root     3204:     mon->chr = chr;
        !          3205:     mon->flags = flags;
        !          3206:     if (mon->chr->focus != 0)
        !          3207:         mon->suspend_cnt = 1; /* mux'ed monitors start suspended */
        !          3208:     if (flags & MONITOR_USE_READLINE) {
        !          3209:         mon->rs = readline_init(mon, monitor_find_completion);
        !          3210:         monitor_read_command(mon, 0);
        !          3211:     }
1.1       root     3212: 
1.1.1.9 ! root     3213:     qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
        !          3214:                           mon);
1.1       root     3215: 
1.1.1.9 ! root     3216:     LIST_INSERT_HEAD(&mon_list, mon, entry);
        !          3217:     if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
        !          3218:         cur_mon = mon;
1.1       root     3219: }
                   3220: 
1.1.1.9 ! root     3221: static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
1.1       root     3222: {
1.1.1.9 ! root     3223:     BlockDriverState *bs = opaque;
        !          3224:     int ret = 0;
1.1.1.6   root     3225: 
1.1.1.9 ! root     3226:     if (bdrv_set_key(bs, password) != 0) {
        !          3227:         monitor_printf(mon, "invalid password\n");
        !          3228:         ret = -EPERM;
1.1       root     3229:     }
1.1.1.9 ! root     3230:     if (mon->password_completion_cb)
        !          3231:         mon->password_completion_cb(mon->password_opaque, ret);
1.1.1.7   root     3232: 
1.1.1.9 ! root     3233:     monitor_read_command(mon, 1);
1.1       root     3234: }
1.1.1.8   root     3235: 
1.1.1.9 ! root     3236: void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
        !          3237:                                  BlockDriverCompletionFunc *completion_cb,
        !          3238:                                  void *opaque)
1.1.1.8   root     3239: {
1.1.1.9 ! root     3240:     int err;
1.1.1.8   root     3241: 
1.1.1.9 ! root     3242:     if (!bdrv_key_required(bs)) {
        !          3243:         if (completion_cb)
        !          3244:             completion_cb(opaque, 0);
        !          3245:         return;
1.1.1.8   root     3246:     }
1.1.1.9 ! root     3247: 
        !          3248:     monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
        !          3249:                    bdrv_get_encrypted_filename(bs));
        !          3250: 
        !          3251:     mon->password_completion_cb = completion_cb;
        !          3252:     mon->password_opaque = opaque;
        !          3253: 
        !          3254:     err = monitor_read_password(mon, bdrv_password_cb, bs);
        !          3255: 
        !          3256:     if (err && completion_cb)
        !          3257:         completion_cb(opaque, err);
1.1.1.8   root     3258: }

unix.superglobalmegacorp.com