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

/*

 * Supported types:

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

    all_devices = !strcmp(device, "all");

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

        if (bs_table[i]) {

                !strcmp(bdrv_get_device_name(bs_table[i]), device))

                bdrv_commit(bs_table[i]);

        }

    if (!item)

        goto help;

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

            goto found;

    }

 help:

    cpu_dump_state(env, NULL, monitor_fprintf,

                   X86_DUMP_FPU);

#else

                   0);

#endif

}

    mon_get_cpu();

    for(env = first_cpu; env != NULL; env = env->next_cpu) {

                    (env == mon_cpu) ? '*' : ' ',

                    env->cpu_index);

#if defined(TARGET_I386)

{

    int i;

    const char *str;

    i = 0;

    for(;;) {

        str = readline_get_history(i);

static void do_log(const char *items)

{

    int mask;

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

        mask = 0;

    } else {

    term_printf("'");

}

                        target_ulong addr, int is_physical)

{

    CPUState *env;

            flags = 0;

            if (env) {

#ifdef TARGET_X86_64

                    (env->segs[R_CS].flags & DESC_L_MASK))

                    flags = 2;

                else

                break;

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

        }

        while (i < l) {

            switch(wsize) {

            default:

#define GET_TLONG(h, l) (l)

#endif

                           uint32_t addrh, uint32_t addrl)

{

    target_long addr = GET_TLONG(addrh, addrl);

    term_printf("\n");

}

                           uint32_t size, const char *filename)

{

    FILE *f;

static const KeyDef key_defs[] = {

    { 0x2a, "shift" },

    { 0x36, "shift_r" },

    { 0x38, "alt" },

    { 0xb8, "alt_r" },

    { 0x1d, "ctrl" },

    { 0x30, "b" },

    { 0x31, "n" },

    { 0x32, "m" },

    { 0x39, "spc" },

    { 0x3a, "caps_lock" },

    { 0x3b, "f1" },

    { 0x47, "kp_7" },

    { 0x48, "kp_8" },

    { 0x49, "kp_9" },

    { 0x56, "<" },

    { 0x57, "f11" },

    uint8_t keycodes[16];

    const char *p;

    int nb_keycodes, keycode, i;

    nb_keycodes = 0;

    p = string;

    while (*p != '\0') {

static int mouse_button_state;

                          const char *dz_str)

{

    int dx, dy, dz;

    dx = strtol(dx_str, NULL, 0);

    dy = strtol(dy_str, NULL, 0);

    dz = 0;

        dz = strtol(dz_str, NULL, 0);

    kbd_mouse_event(dx, dy, dz, mouse_button_state);

}

#if defined(TARGET_I386)

static void print_pte(uint32_t addr, uint32_t pte, uint32_t mask)

{

                addr,

                pte & mask,

                pte & PG_GLOBAL_MASK ? 'G' : '-',

                print_pte((l1 << 22), pde, ~((1 << 20) - 1));

            } else {

                for(l2 = 0; l2 < 1024; l2++) {

                                             (uint8_t *)&pte, 4);

                    pte = le32_to_cpu(pte);

                    if (pte & PG_PRESENT_MASK) {

                                  ~0xfff);

                    }

                }

    }

}

                      uint32_t end, int prot)

{

    int prot1;

    if (prot != prot1) {

        if (*pstart != -1) {

            term_printf("%08x-%08x %08x %c%c%c\n",

                        prot1 & PG_USER_MASK ? 'u' : '-',

                        'r',

                        prot1 & PG_RW_MASK ? 'w' : '-');

                mem_print(&start, &last_prot, end, prot);

            } else {

                for(l2 = 0; l2 < 1024; l2++) {

                                             (uint8_t *)&pte, 4);

                    pte = le32_to_cpu(pte);

                    end = (l1 << 22) + (l2 << 12);

#else

    term_printf("kqemu support: not compiled\n");

#endif

#ifdef CONFIG_PROFILER

#endif

static term_cmd_t term_cmds[] = {

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

      "device|all", "commit changes to the disk images (if -snapshot is used) or backing files" },

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

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

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

    { "change", "BF", do_change,

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

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

    { "logfile", "s", do_logfile,

      "filename", "output logs to 'filename'" },

    { "log", "s", do_log,

    { "savevm", "s?", do_savevm,

    { "loadvm", "s", do_loadvm,

    { "delvm", "s", do_delvm,

      "", "stop emulation", },

      "", "resume emulation", },

#ifdef CONFIG_GDBSTUB

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

#endif

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

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

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

      "/fmt addr", "I/O port read" },

      "keys", "send keys to the VM (e.g. 'sendkey ctrl-alt-f1')" },

      "", "reset the system" },

      "", "send system power down event" },

      "addr size", "compute the checksum of a memory region" },

    { "usb_add", "s", do_usb_add,

      "device", "add USB device (e.g. 'host:bus.addr' or 'host:vendor_id:product_id')" },

    { "usb_del", "s", do_usb_del,

      "device", "remove USB device 'bus.addr'" },

      "index", "set the default CPU" },

      "dx dy [dz]", "send mouse move events" },

      "state", "change mouse button state (1=L, 2=M, 4=R)" },

    { "mouse_set", "i", do_mouse_set,

      "index", "set which mouse device receives events" },

#endif

     { "stopcapture", "i", do_stop_capture,

       "capture index", "stop capture" },

      "addr size file", "save to disk virtual memory dump starting at 'addr' of size 'size'", },

};

static term_cmd_t info_cmds[] = {

    { NULL },

};

{

    term_printf(fmt);

    term_printf("\n");

    case '$':

        {

            char buf[128], *q;

            pch++;

            q = buf;

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

            ret = get_monitor_def(&n, buf);

            if (ret == -1)

                expr_error("unknown register");

                expr_error("no cpu defined");

        }

        break;

{

    target_long val, val2;

    int op;

    val = expr_unary();

    for(;;) {

        op = *pch;

            break;

        case '/':

        case '%':

                expr_error("division by zero");

            if (op == '/')

                val /= val2;

#ifdef DEBUG

    term_printf("command='%s'\n", cmdline);

#endif

    /* extract the command name */

    p = cmdline;

    q = cmdname;

        len = sizeof(cmdname) - 1;

    memcpy(cmdname, pstart, len);

    cmdname[len] = '\0';

    /* find the command */

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

            goto found;

    }

    term_printf("unknown command: '%s'\n", cmdname);

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

        str_allocated[i] = NULL;

    /* parse the parameters */

    typestr = cmd->args_type;

    nb_args = 0;

            {

                int ret;

                char *str;

                    p++;

                if (*typestr == '?') {

                    typestr++;

        case '/':

            {

                int count, format, size;

                while (isspace(*p))

                    p++;

                if (*p == '/') {

        case 'l':

            {

                target_long val;

                    p++;

                if (*typestr == '?' || *typestr == '.') {

                    if (*typestr == '?') {

                    } else {

                        if (*p == '.') {

                            p++;

                                p++;

                            has_arg = 1;

                        } else {

            {

                int has_option;

                /* option */

                c = *typestr++;

                if (c == '\0')

                    goto bad_type;

                    p++;

                has_option = 0;

                if (*p == '-') {

                    p++;

                    if (*p != c) {

                                    cmdname, *p);

                        goto fail;

                    }

    while (isspace(*p))

        p++;

    if (*p != '\0') {

                    cmdname);

        goto fail;

    }

    int input_path_len;

    const char *p;

    if (!p) {

        input_path_len = 0;

        pstrcpy(file_prefix, sizeof(file_prefix), input);