Archipelago » qemu

/*

 * QEMU monitor

 * 

 * Copyright (c) 2003-2004 Fabrice Bellard

 * 

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "vl.h"

#include "disas.h"

//#define DEBUG

#ifndef offsetof

#define offsetof(type, field) ((size_t) &((type *)0)->field)

#endif

#define TERM_CMD_BUF_SIZE 4095

#define TERM_MAX_CMDS 64

#define IS_NORM 0

#define IS_ESC  1

#define IS_CSI  2

#define printf do_not_use_printf

static char term_cmd_buf[TERM_CMD_BUF_SIZE + 1];

static int term_cmd_buf_index;

static int term_cmd_buf_size;

static int term_esc_state;

static int term_esc_param;

static char *term_history[TERM_MAX_CMDS];

static int term_hist_entry;

/*

 * Supported types:

 * 

 * 'F'          filename

 * 's'          string (accept optional quote)

 * 'i'          integer

 * '/'          optional gdb-like print format (like "/10x")

 *

 * '?'          optional type (for 'F', 's' and 'i')

 *

 */

typedef struct term_cmd_t {

    const char *name;

    const char *args_type;

    void (*handler)();

    const char *params;

    const char *help;

} term_cmd_t;

static term_cmd_t term_cmds[];

static term_cmd_t info_cmds[];

void term_printf(const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    vprintf(fmt, ap);

    va_end(ap);

}

void term_flush(void)

{

    fflush(stdout);

}

static int compare_cmd(const char *name, const char *list)

{

    const char *p, *pstart;

    int len;

    len = strlen(name);

    p = list;

    for(;;) {

        pstart = p;

        p = strchr(p, '|');

        if (!p)

            p = pstart + strlen(pstart);

        if ((p - pstart) == len && !memcmp(pstart, name, len))

            return 1;

        if (*p == '\0')

            break;

        p++;

    }

    return 0;

}

static void help_cmd1(term_cmd_t *cmds, const char *prefix, const char *name)

{

    term_cmd_t *cmd;

    for(cmd = cmds; cmd->name != NULL; cmd++) {

        if (!name || !strcmp(name, cmd->name))

            term_printf("%s%s %s -- %s\n", prefix, cmd->name, cmd->params, cmd->help);

    }

}

static void help_cmd(const char *name)

{

    if (name && !strcmp(name, "info")) {

        help_cmd1(info_cmds, "info ", NULL);

    } else {

        help_cmd1(term_cmds, "", name);

        if (name && !strcmp(name, "log")) {

            CPULogItem *item;

            term_printf("Log items (comma separated):\n");

            term_printf("%-10s %s\n", "none", "remove all logs");

            for(item = cpu_log_items; item->mask != 0; item++) {

                term_printf("%-10s %s\n", item->name, item->help);

            }

        }

    }

}

static void do_help(const char *name)

{

    help_cmd(name);

}

static void do_commit(void)

{

    int i;

    for (i = 0; i < MAX_DISKS; i++) {

        if (bs_table[i])

            bdrv_commit(bs_table[i]);

    }

}

static void do_info(const char *item)

{

    term_cmd_t *cmd;

    if (!item)

        goto help;

    for(cmd = info_cmds; cmd->name != NULL; cmd++) {

        if (compare_cmd(item, cmd->name)) 

            goto found;

    }

 help:

    help_cmd("info");

    return;

 found:

    cmd->handler();

}

static void do_info_network(void)

{

    int i, j;

    NetDriverState *nd;

    for(i = 0; i < nb_nics; i++) {

        nd = &nd_table[i];

        term_printf("%d: ifname=%s macaddr=", i, nd->ifname);

        for(j = 0; j < 6; j++) {

            if (j > 0)

                term_printf(":");

            term_printf("%02x", nd->macaddr[j]);

        }

        term_printf("\n");

    }

}

static void do_info_block(void)

{

    bdrv_info();

}

static void do_info_registers(void)

{

#ifdef TARGET_I386

    cpu_dump_state(cpu_single_env, stdout, X86_DUMP_FPU | X86_DUMP_CCOP);

#else

    cpu_dump_state(cpu_single_env, stdout, 0);

#endif

}

static void do_info_history (void)

{

    int i;

    for (i = 0; i < TERM_MAX_CMDS; i++) {

        if (term_history[i] == NULL)

            break;

        term_printf("%d: '%s'\n", i, term_history[i]);

    }

}

static void do_quit(void)

{

    exit(0);

}

static int eject_device(BlockDriverState *bs, int force)

{

    if (bdrv_is_inserted(bs)) {

        if (!force) {

            if (!bdrv_is_removable(bs)) {

                term_printf("device is not removable\n");

                return -1;

            }

            if (bdrv_is_locked(bs)) {

                term_printf("device is locked\n");

                return -1;

            }

        }

        bdrv_close(bs);

    }

    return 0;

}

static void do_eject(int force, const char *filename)

{

    BlockDriverState *bs;

    term_printf("%d %s\n", force, filename);

    bs = bdrv_find(filename);

    if (!bs) {

        term_printf("device not found\n");

        return;

    }

    eject_device(bs, force);

}

static void do_change(const char *device, const char *filename)

{

    BlockDriverState *bs;

    bs = bdrv_find(device);

    if (!bs) {

        term_printf("device not found\n");

        return;

    }

    if (eject_device(bs, 0) < 0)

        return;

    bdrv_open(bs, filename, 0);

}

static void do_screen_dump(const char *filename)

{

    vga_screen_dump(filename);

}

static void do_log(const char *items)

{

    int mask;

    if (!strcmp(items, "none")) {

        mask = 0;

    } else {

        mask = cpu_str_to_log_mask(items);

        if (!mask) {

            help_cmd("log");

            return;

        }

    }

    cpu_set_log(mask);

}

static void do_savevm(const char *filename)

{

    if (qemu_savevm(filename) < 0)

        term_printf("I/O error when saving VM to '%s'\n", filename);

}

static void do_loadvm(const char *filename)

{

    if (qemu_loadvm(filename) < 0) 

        term_printf("I/O error when loading VM from '%s'\n", filename);

}

static void do_stop(void)

{

    vm_stop(EXCP_INTERRUPT);

}

static void do_cont(void)

{

    vm_start();

}

#ifdef CONFIG_GDBSTUB

static void do_gdbserver(int has_port, int port)

{

    if (!has_port)

        port = DEFAULT_GDBSTUB_PORT;

    if (gdbserver_start(port) < 0) {

        qemu_printf("Could not open gdbserver socket on port %d\n", port);

    } else {

        qemu_printf("Waiting gdb connection on port %d\n", port);

    }

}

#endif

static void term_printc(int c)

{

    term_printf("'");

    switch(c) {

    case '\'':

        term_printf("\\'");

        break;

    case '\\':

        term_printf("\\\\");

        break;

    case '\n':

        term_printf("\\n");

        break;

    case '\r':

        term_printf("\\r");

        break;

    default:

        if (c >= 32 && c <= 126) {

            term_printf("%c", c);

        } else {

            term_printf("\\x%02x", c);

        }

        break;

    }

    term_printf("'");

}

static void memory_dump(int count, int format, int wsize, 

                        target_ulong addr, int is_physical)

{

    int nb_per_line, l, line_size, i, max_digits, len;

    uint8_t buf[16];

    uint64_t v;

    if (format == 'i') {

        int flags;

        flags = 0;

#ifdef TARGET_I386

        if (wsize == 2) {

            flags = 1;

        } else if (wsize == 4) {

            flags = 0;

        } else {

            /* as default we use the current CS size */

            flags = 0;

            if (!(cpu_single_env->segs[R_CS].flags & DESC_B_MASK))

                flags = 1;

        }

#endif

        monitor_disas(addr, count, is_physical, flags);

        return;

    }

    len = wsize * count;

    if (wsize == 1)

        line_size = 8;

    else

        line_size = 16;

    nb_per_line = line_size / wsize;

    max_digits = 0;

    switch(format) {

    case 'o':

        max_digits = (wsize * 8 + 2) / 3;

        break;

    default:

    case 'x':

        max_digits = (wsize * 8) / 4;

        break;

    case 'u':

    case 'd':

        max_digits = (wsize * 8 * 10 + 32) / 33;

        break;

    case 'c':

        wsize = 1;

        break;

    }

    while (len > 0) {

        term_printf("0x%08x:", addr);

        l = len;

        if (l > line_size)

            l = line_size;

        if (is_physical) {

            cpu_physical_memory_rw(addr, buf, l, 0);

        } else {

            cpu_memory_rw_debug(cpu_single_env, addr, buf, l, 0);

        }

        i = 0; 

        while (i < l) {

            switch(wsize) {

            default:

            case 1:

                v = ldub_raw(buf + i);

                break;

            case 2:

                v = lduw_raw(buf + i);

                break;

            case 4:

                v = ldl_raw(buf + i);

                break;

            case 8:

                v = ldq_raw(buf + i);

                break;

            }

            term_printf(" ");

            switch(format) {

            case 'o':

                term_printf("%#*llo", max_digits, v);

                break;

            case 'x':

                term_printf("0x%0*llx", max_digits, v);

                break;

            case 'u':

                term_printf("%*llu", max_digits, v);

                break;

            case 'd':

                term_printf("%*lld", max_digits, v);

                break;

            case 'c':

                term_printc(v);

                break;

            }

            i += wsize;

        }

        term_printf("\n");

        addr += l;

        len -= l;

    }

}

static void do_memory_dump(int count, int format, int size, int addr)

{

    memory_dump(count, format, size, addr, 0);

}

static void do_physical_memory_dump(int count, int format, int size, int addr)

{

    memory_dump(count, format, size, addr, 1);

}

static void do_print(int count, int format, int size, int val)

{

    switch(format) {

    case 'o':

        term_printf("%#o", val);

        break;

    case 'x':

        term_printf("%#x", val);

        break;

    case 'u':

        term_printf("%u", val);

        break;

    default:

    case 'd':

        term_printf("%d", val);

        break;

    case 'c':

        term_printc(val);

        break;

    }

    term_printf("\n");

}

static term_cmd_t term_cmds[] = {

    { "help|?", "s?", do_help, 

      "[cmd]", "show the help" },

    { "commit", "", do_commit, 

      "", "commit changes to the disk images (if -snapshot is used)" },

    { "info", "s?", do_info,

      "subcommand", "show various information about the system state" },

    { "q|quit", "", do_quit,

      "", "quit the emulator" },

    { "eject", "-fs", do_eject,

      "[-f] device", "eject a removable media (use -f to force it)" },

    { "change", "sF", do_change,

      "device filename", "change a removable media" },

    { "screendump", "F", do_screen_dump, 

      "filename", "save screen into PPM image 'filename'" },

    { "log", "s", do_log,

      "item1[,...]", "activate logging of the specified items to '/tmp/qemu.log'" }, 

    { "savevm", "F", do_savevm,

      "filename", "save the whole virtual machine state to 'filename'" }, 

    { "loadvm", "F", do_loadvm,

      "filename", "restore the whole virtual machine state from 'filename'" }, 

    { "stop", "", do_stop, 

      "", "stop emulation", },

    { "c|cont", "", do_cont, 

      "", "resume emulation", },

#ifdef CONFIG_GDBSTUB

    { "gdbserver", "i?", do_gdbserver, 

      "[port]", "start gdbserver session (default port=1234)", },

#endif

    { "x", "/i", do_memory_dump, 

      "/fmt addr", "virtual memory dump starting at 'addr'", },

    { "xp", "/i", do_physical_memory_dump, 

      "/fmt addr", "physical memory dump starting at 'addr'", },

    { "p|print", "/i", do_print, 

      "/fmt expr", "print expression value (use $reg for CPU register access)", },

    { NULL, NULL, }, 

};

static term_cmd_t info_cmds[] = {

    { "network", "", do_info_network,

      "", "show the network state" },

    { "block", "", do_info_block,

      "", "show the block devices" },

    { "registers", "", do_info_registers,

      "", "show the cpu registers" },

    { "history", "", do_info_history,

      "", "show the command line history", },

    { "irq", "", irq_info,

      "", "show the interrupts statistics (if available)", },

    { "pic", "", pic_info,

      "", "show i8259 (PIC) state", },

    { "pci", "", pci_info,

      "", "show PCI info", },

    { NULL, NULL, },

};

/*******************************************************************/

static const char *pch;

static jmp_buf expr_env;

typedef struct MonitorDef {

    const char *name;

    int offset;

    int (*get_value)(struct MonitorDef *md);

} MonitorDef;

#if defined(TARGET_I386)

static int monitor_get_pc (struct MonitorDef *md)

{

    return cpu_single_env->eip + (long)cpu_single_env->segs[R_CS].base;

}

#endif

#if defined(TARGET_PPC)

static int monitor_get_ccr (struct MonitorDef *md)

{

    unsigned int u;

    int i;

    u = 0;

    for (i = 0; i < 8; i++)

        u |= cpu_single_env->crf[i] << (32 - (4 * i));

    return u;

}

static int monitor_get_msr (struct MonitorDef *md)

{

    return (cpu_single_env->msr[MSR_POW] << MSR_POW) |

        (cpu_single_env->msr[MSR_ILE] << MSR_ILE) |

        (cpu_single_env->msr[MSR_EE] << MSR_EE) |

        (cpu_single_env->msr[MSR_PR] << MSR_PR) |

        (cpu_single_env->msr[MSR_FP] << MSR_FP) |

        (cpu_single_env->msr[MSR_ME] << MSR_ME) |

        (cpu_single_env->msr[MSR_FE0] << MSR_FE0) |

        (cpu_single_env->msr[MSR_SE] << MSR_SE) |

        (cpu_single_env->msr[MSR_BE] << MSR_BE) |

        (cpu_single_env->msr[MSR_FE1] << MSR_FE1) |

        (cpu_single_env->msr[MSR_IP] << MSR_IP) |

        (cpu_single_env->msr[MSR_IR] << MSR_IR) |

        (cpu_single_env->msr[MSR_DR] << MSR_DR) |

        (cpu_single_env->msr[MSR_RI] << MSR_RI) |

        (cpu_single_env->msr[MSR_LE] << MSR_LE);

}

static int monitor_get_xer (struct MonitorDef *md)

{

    return (cpu_single_env->xer[XER_SO] << XER_SO) |

        (cpu_single_env->xer[XER_OV] << XER_OV) |

        (cpu_single_env->xer[XER_CA] << XER_CA) |

        (cpu_single_env->xer[XER_BC] << XER_BC);

}

uint32_t cpu_ppc_load_decr (CPUState *env);

static int monitor_get_decr (struct MonitorDef *md)

{

    return cpu_ppc_load_decr(cpu_single_env);

}

uint32_t cpu_ppc_load_tbu (CPUState *env);

static int monitor_get_tbu (struct MonitorDef *md)

{

    return cpu_ppc_load_tbu(cpu_single_env);

}

uint32_t cpu_ppc_load_tbl (CPUState *env);

static int monitor_get_tbl (struct MonitorDef *md)

{

    return cpu_ppc_load_tbl(cpu_single_env);

}

#endif

static MonitorDef monitor_defs[] = {

#ifdef TARGET_I386

#define SEG(name, seg) \

    { name, offsetof(CPUState, segs[seg].selector) },\

    { name ".base", offsetof(CPUState, segs[seg].base) },\

    { name ".limit", offsetof(CPUState, segs[seg].limit) },

    { "eax", offsetof(CPUState, regs[0]) },

    { "ecx", offsetof(CPUState, regs[1]) },

    { "edx", offsetof(CPUState, regs[2]) },

    { "ebx", offsetof(CPUState, regs[3]) },

    { "esp|sp", offsetof(CPUState, regs[4]) },

    { "ebp|fp", offsetof(CPUState, regs[5]) },

    { "esi", offsetof(CPUState, regs[6]) },

    { "esi", offsetof(CPUState, regs[7]) },

    { "eflags", offsetof(CPUState, eflags) },

    { "eip", offsetof(CPUState, eip) },

    SEG("cs", R_CS)

    SEG("ds", R_DS)

    SEG("es", R_ES)

    SEG("fs", R_FS)

    SEG("gs", R_GS)

    { "pc", 0, monitor_get_pc, },

#elif defined(TARGET_PPC)

    { "r0", offsetof(CPUState, gpr[0]) },

    { "r1", offsetof(CPUState, gpr[1]) },

    { "r2", offsetof(CPUState, gpr[2]) },

    { "r3", offsetof(CPUState, gpr[3]) },

    { "r4", offsetof(CPUState, gpr[4]) },

    { "r5", offsetof(CPUState, gpr[5]) },

    { "r6", offsetof(CPUState, gpr[6]) },

    { "r7", offsetof(CPUState, gpr[7]) },

    { "r8", offsetof(CPUState, gpr[8]) },

    { "r9", offsetof(CPUState, gpr[9]) },

    { "r10", offsetof(CPUState, gpr[10]) },

    { "r11", offsetof(CPUState, gpr[11]) },

    { "r12", offsetof(CPUState, gpr[12]) },

    { "r13", offsetof(CPUState, gpr[13]) },

    { "r14", offsetof(CPUState, gpr[14]) },

    { "r15", offsetof(CPUState, gpr[15]) },

    { "r16", offsetof(CPUState, gpr[16]) },

    { "r17", offsetof(CPUState, gpr[17]) },

    { "r18", offsetof(CPUState, gpr[18]) },

    { "r19", offsetof(CPUState, gpr[19]) },

    { "r20", offsetof(CPUState, gpr[20]) },

    { "r21", offsetof(CPUState, gpr[21]) },

    { "r22", offsetof(CPUState, gpr[22]) },

    { "r23", offsetof(CPUState, gpr[23]) },

    { "r24", offsetof(CPUState, gpr[24]) },

    { "r25", offsetof(CPUState, gpr[25]) },

    { "r26", offsetof(CPUState, gpr[26]) },

    { "r27", offsetof(CPUState, gpr[27]) },

    { "r28", offsetof(CPUState, gpr[28]) },

    { "r29", offsetof(CPUState, gpr[29]) },

    { "r30", offsetof(CPUState, gpr[30]) },

    { "r31", offsetof(CPUState, gpr[31]) },

    { "nip|pc", offsetof(CPUState, nip) },

    { "lr", offsetof(CPUState, lr) },

    { "ctr", offsetof(CPUState, ctr) },

    { "decr", 0, &monitor_get_decr, },

    { "ccr", 0, &monitor_get_ccr, },

    { "msr", 0, &monitor_get_msr, },

    { "xer", 0, &monitor_get_xer, },

    { "tbu", 0, &monitor_get_tbu, },

    { "tbl", 0, &monitor_get_tbl, },

    { "sdr1", offsetof(CPUState, sdr1) },

    { "sr0", offsetof(CPUState, sr[0]) },

    { "sr1", offsetof(CPUState, sr[1]) },

    { "sr2", offsetof(CPUState, sr[2]) },

    { "sr3", offsetof(CPUState, sr[3]) },

    { "sr4", offsetof(CPUState, sr[4]) },

    { "sr5", offsetof(CPUState, sr[5]) },

    { "sr6", offsetof(CPUState, sr[6]) },

    { "sr7", offsetof(CPUState, sr[7]) },

    { "sr8", offsetof(CPUState, sr[8]) },

    { "sr9", offsetof(CPUState, sr[9]) },

    { "sr10", offsetof(CPUState, sr[10]) },

    { "sr11", offsetof(CPUState, sr[11]) },

    { "sr12", offsetof(CPUState, sr[12]) },

    { "sr13", offsetof(CPUState, sr[13]) },

    { "sr14", offsetof(CPUState, sr[14]) },

    { "sr15", offsetof(CPUState, sr[15]) },

    /* Too lazy to put BATs and SPRs ... */

#endif

    { NULL },

};

static void expr_error(const char *fmt) 

{

    term_printf(fmt);

    term_printf("\n");

    longjmp(expr_env, 1);

}

static int get_monitor_def(int *pval, const char *name)

{

    MonitorDef *md;

    for(md = monitor_defs; md->name != NULL; md++) {

        if (compare_cmd(name, md->name)) {

            if (md->get_value) {

                *pval = md->get_value(md);

            } else {

                *pval = *(uint32_t *)((uint8_t *)cpu_single_env + md->offset);

            }

            return 0;

        }

    }

    return -1;

}

static void next(void)

{

    if (pch != '\0') {

        pch++;

        while (isspace(*pch))

            pch++;

    }

}

static int expr_sum(void);

static int expr_unary(void)

{

    int n;

    char *p;

    switch(*pch) {

    case '+':

        next();

        n = expr_unary();

        break;

    case '-':

        next();

        n = -expr_unary();

        break;

    case '~':

        next();

        n = ~expr_unary();

        break;

    case '(':

        next();

        n = expr_sum();

        if (*pch != ')') {

            expr_error("')' expected");

        }

        next();

        break;

    case '$':

        {

            char buf[128], *q;

            pch++;

            q = buf;

            while ((*pch >= 'a' && *pch <= 'z') ||

                   (*pch >= 'A' && *pch <= 'Z') ||

                   (*pch >= '0' && *pch <= '9') ||

                   *pch == '_' || *pch == '.') {

                if ((q - buf) < sizeof(buf) - 1)

                    *q++ = *pch;

                pch++;

            }

            while (isspace(*pch))

                pch++;

            *q = 0;

            if (get_monitor_def(&n, buf))

                expr_error("unknown register");

        }

        break;

    case '\0':

        expr_error("unexpected end of expression");

        n = 0;

        break;

    default:

        n = strtoul(pch, &p, 0);

        if (pch == p) {

            expr_error("invalid char in expression");

        }

        pch = p;

        while (isspace(*pch))

            pch++;

        break;

    }

    return n;

}

static int expr_prod(void)

{

    int val, val2, op;

    val = expr_unary();