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 <dirent.h>

#include "hw/hw.h"

#include "hw/qdev.h"

#include "hw/usb.h"

#include "hw/pcmcia.h"

#include "hw/pc.h"

#include "hw/pci.h"

#include "hw/watchdog.h"

#include "hw/loader.h"

#include "gdbstub.h"

#include "net.h"

#include "net/slirp.h"

#include "qemu-char.h"

#include "sysemu.h"

#include "monitor.h"

#include "readline.h"

#include "console.h"

#include "blockdev.h"

#include "audio/audio.h"

#include "disas.h"

#include "balloon.h"

#include "qemu-timer.h"

#include "migration.h"

#include "kvm.h"

#include "acl.h"

#include "qint.h"

#include "qfloat.h"

#include "qlist.h"

#include "qbool.h"

#include "qstring.h"

#include "qjson.h"

#include "json-streamer.h"

#include "json-parser.h"

#include "osdep.h"

#include "exec-all.h"

//#define DEBUG

//#define DEBUG_COMPLETION

/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'O'          option string of the form NAME=VALUE,...

 *              parsed according to QemuOptsList given by its name

 *              Example: 'device:O' uses qemu_device_opts.

 *              Restriction: only lists with empty desc are supported

 *              TODO lift the restriction

 * 'i'          32 bit integer

 * 'l'          target long (32 or 64 bit)

 * 'M'          just like 'l', except in user mode the value is

 *              multiplied by 2^20 (think Mebibyte)

 * 'f'          double

 *              user mode accepts an optional G, g, M, m, K, k suffix,

 *              which multiplies the value by 2^30 for suffixes G and

 *              g, 2^20 for M and m, 2^10 for K and k

 * 'T'          double

 *              user mode accepts an optional ms, us, ns suffix,

 *              which divides the value by 1e3, 1e6, 1e9, respectively

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

 *

 * '?'          optional type (for all types, except '/')

 * '.'          other form of optional type (for 'i' and 'l')

 * 'b'          boolean

 *              user mode accepts "on" or "off"

 * '-'          optional parameter (eg. '-f')

 *

 */

typedef struct MonitorCompletionData MonitorCompletionData;

struct MonitorCompletionData {

    Monitor *mon;

    void (*user_print)(Monitor *mon, const QObject *data);

};

typedef struct mon_cmd_t {

    const char *name;

    const char *args_type;

    const char *params;

    const char *help;

    void (*user_print)(Monitor *mon, const QObject *data);

    union {

        void (*info)(Monitor *mon);

        void (*info_new)(Monitor *mon, QObject **ret_data);

        int  (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);

        void (*cmd)(Monitor *mon, const QDict *qdict);

        int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);

        int  (*cmd_async)(Monitor *mon, const QDict *params,

                          MonitorCompletion *cb, void *opaque);

    } mhandler;

    int async;

} mon_cmd_t;

/* file descriptors passed via SCM_RIGHTS */

typedef struct mon_fd_t mon_fd_t;

struct mon_fd_t {

    char *name;

    int fd;

    QLIST_ENTRY(mon_fd_t) next;

};

typedef struct MonitorControl {

    QObject *id;

    JSONMessageParser parser;

    int command_mode;

} MonitorControl;

struct Monitor {

    CharDriverState *chr;

    int mux_out;

    int reset_seen;

    int flags;

    int suspend_cnt;

    uint8_t outbuf[1024];

    int outbuf_index;

    ReadLineState *rs;

    MonitorControl *mc;

    CPUState *mon_cpu;

    BlockDriverCompletionFunc *password_completion_cb;

    void *password_opaque;

#ifdef CONFIG_DEBUG_MONITOR

    int print_calls_nr;

#endif

    QError *error;

    QLIST_HEAD(,mon_fd_t) fds;

    QLIST_ENTRY(Monitor) entry;

};

#ifdef CONFIG_DEBUG_MONITOR

#define MON_DEBUG(fmt, ...) do {    \

    fprintf(stderr, "Monitor: ");       \

    fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)

static inline void mon_print_count_inc(Monitor *mon)

{

    mon->print_calls_nr++;

}

static inline void mon_print_count_init(Monitor *mon)

{

    mon->print_calls_nr = 0;

}

static inline int mon_print_count_get(const Monitor *mon)

{

    return mon->print_calls_nr;

}

#else /* !CONFIG_DEBUG_MONITOR */

#define MON_DEBUG(fmt, ...) do { } while (0)

static inline void mon_print_count_inc(Monitor *mon) { }

static inline void mon_print_count_init(Monitor *mon) { }

static inline int mon_print_count_get(const Monitor *mon) { return 0; }

#endif /* CONFIG_DEBUG_MONITOR */

static QLIST_HEAD(mon_list, Monitor) mon_list;

static const mon_cmd_t mon_cmds[];

static const mon_cmd_t info_cmds[];

Monitor *cur_mon;

Monitor *default_mon;

static void monitor_command_cb(Monitor *mon, const char *cmdline,

                               void *opaque);

static inline int qmp_cmd_mode(const Monitor *mon)

{

    return (mon->mc ? mon->mc->command_mode : 0);

}

/* Return true if in control mode, false otherwise */

static inline int monitor_ctrl_mode(const Monitor *mon)

{

    return (mon->flags & MONITOR_USE_CONTROL);

}

/* Return non-zero iff we have a current monitor, and it is in QMP mode.  */

int monitor_cur_is_qmp(void)

{

    return cur_mon && monitor_ctrl_mode(cur_mon);

}

static void monitor_read_command(Monitor *mon, int show_prompt)

{

    if (!mon->rs)

        return;

    readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);

    if (show_prompt)

        readline_show_prompt(mon->rs);

}

static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,

                                 void *opaque)

{

    if (monitor_ctrl_mode(mon)) {

        qerror_report(QERR_MISSING_PARAMETER, "password");

        return -EINVAL;

    } else if (mon->rs) {

        readline_start(mon->rs, "Password: ", 1, readline_func, opaque);

        /* prompt is printed on return from the command handler */

        return 0;

    } else {

        monitor_printf(mon, "terminal does not support password prompting\n");

        return -ENOTTY;

    }

}

void monitor_flush(Monitor *mon)

{

    if (mon && mon->outbuf_index != 0 && !mon->mux_out) {

        qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);

        mon->outbuf_index = 0;

    }

}

/* flush at every end of line or if the buffer is full */

static void monitor_puts(Monitor *mon, const char *str)

{

    char c;

    for(;;) {

        c = *str++;

        if (c == '\0')

            break;

        if (c == '\n')

            mon->outbuf[mon->outbuf_index++] = '\r';

        mon->outbuf[mon->outbuf_index++] = c;

        if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)

            || c == '\n')

            monitor_flush(mon);

    }

}

void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)

{

    char buf[4096];

    if (!mon)

        return;

    mon_print_count_inc(mon);

    if (monitor_ctrl_mode(mon)) {

        return;

    }

    vsnprintf(buf, sizeof(buf), fmt, ap);

    monitor_puts(mon, buf);

}

void monitor_printf(Monitor *mon, const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    monitor_vprintf(mon, fmt, ap);

    va_end(ap);

}

void monitor_print_filename(Monitor *mon, const char *filename)

{

    int i;

    for (i = 0; filename[i]; i++) {

        switch (filename[i]) {

        case ' ':

        case '"':

        case '\\':

            monitor_printf(mon, "\\%c", filename[i]);

            break;

        case '\t':

            monitor_printf(mon, "\\t");

            break;

        case '\r':

            monitor_printf(mon, "\\r");

            break;

        case '\n':

            monitor_printf(mon, "\\n");

            break;

        default:

            monitor_printf(mon, "%c", filename[i]);

            break;

        }

    }

}

static int monitor_fprintf(FILE *stream, const char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    monitor_vprintf((Monitor *)stream, fmt, ap);

    va_end(ap);

    return 0;

}

static void monitor_user_noop(Monitor *mon, const QObject *data) { }

static inline int monitor_handler_ported(const mon_cmd_t *cmd)

{

    return cmd->user_print != NULL;

}

static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)

{

    return cmd->async != 0;

}

static inline int monitor_has_error(const Monitor *mon)

{

    return mon->error != NULL;

}

static void monitor_json_emitter(Monitor *mon, const QObject *data)

{

    QString *json;

    json = qobject_to_json(data);

    assert(json != NULL);

    qstring_append_chr(json, '\n');

    monitor_puts(mon, qstring_get_str(json));

    QDECREF(json);

}

static void monitor_protocol_emitter(Monitor *mon, QObject *data)

{

    QDict *qmp;

    qmp = qdict_new();

    if (!monitor_has_error(mon)) {

        /* success response */

        if (data) {

            qobject_incref(data);

            qdict_put_obj(qmp, "return", data);

        } else {

            /* return an empty QDict by default */

            qdict_put(qmp, "return", qdict_new());

        }

    } else {

        /* error response */

        qdict_put(mon->error->error, "desc", qerror_human(mon->error));

        qdict_put(qmp, "error", mon->error->error);

        QINCREF(mon->error->error);

        QDECREF(mon->error);

        mon->error = NULL;

    }

    if (mon->mc->id) {

        qdict_put_obj(qmp, "id", mon->mc->id);

        mon->mc->id = NULL;

    }

    monitor_json_emitter(mon, QOBJECT(qmp));

    QDECREF(qmp);

}

static void timestamp_put(QDict *qdict)

{

    int err;

    QObject *obj;

    qemu_timeval tv;

    err = qemu_gettimeofday(&tv);

    if (err < 0)

        return;

    obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "

                                "'microseconds': %" PRId64 " }",

                                (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);

    qdict_put_obj(qdict, "timestamp", obj);

}

/**

 * monitor_protocol_event(): Generate a Monitor event

 *

 * Event-specific data can be emitted through the (optional) 'data' parameter.

 */

void monitor_protocol_event(MonitorEvent event, QObject *data)

{

    QDict *qmp;

    const char *event_name;

    Monitor *mon;

    assert(event < QEVENT_MAX);

    switch (event) {

        case QEVENT_SHUTDOWN:

            event_name = "SHUTDOWN";

            break;

        case QEVENT_RESET:

            event_name = "RESET";

            break;

        case QEVENT_POWERDOWN:

            event_name = "POWERDOWN";

            break;

        case QEVENT_STOP:

            event_name = "STOP";

            break;

        case QEVENT_RESUME:

            event_name = "RESUME";

            break;

        case QEVENT_VNC_CONNECTED:

            event_name = "VNC_CONNECTED";

            break;

        case QEVENT_VNC_INITIALIZED:

            event_name = "VNC_INITIALIZED";

            break;

        case QEVENT_VNC_DISCONNECTED:

            event_name = "VNC_DISCONNECTED";

            break;

        case QEVENT_BLOCK_IO_ERROR:

            event_name = "BLOCK_IO_ERROR";

            break;

        case QEVENT_RTC_CHANGE:

            event_name = "RTC_CHANGE";

            break;

        case QEVENT_WATCHDOG:

            event_name = "WATCHDOG";

            break;

        default:

            abort();

            break;

    }

    qmp = qdict_new();

    timestamp_put(qmp);

    qdict_put(qmp, "event", qstring_from_str(event_name));

    if (data) {

        qobject_incref(data);

        qdict_put_obj(qmp, "data", data);

    }

    QLIST_FOREACH(mon, &mon_list, entry) {

        if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {

            monitor_json_emitter(mon, QOBJECT(qmp));

        }

    }

    QDECREF(qmp);

}

static int do_qmp_capabilities(Monitor *mon, const QDict *params,

                               QObject **ret_data)

{

    /* Will setup QMP capabilities in the future */

    if (monitor_ctrl_mode(mon)) {

        mon->mc->command_mode = 1;

    }

    return 0;

}

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_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,

                          const char *prefix, const char *name)

{

    const mon_cmd_t *cmd;

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

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

            monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,

                           cmd->params, cmd->help);

    }

}

static void help_cmd(Monitor *mon, const char *name)

{

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

        help_cmd_dump(mon, info_cmds, "info ", NULL);

    } else {

        help_cmd_dump(mon, mon_cmds, "", name);

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

            const CPULogItem *item;

            monitor_printf(mon, "Log items (comma separated):\n");

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

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

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

            }

        }

    }

}

static void do_help_cmd(Monitor *mon, const QDict *qdict)

{

    help_cmd(mon, qdict_get_try_str(qdict, "name"));

}

static void user_monitor_complete(void *opaque, QObject *ret_data)

{

    MonitorCompletionData *data = (MonitorCompletionData *)opaque; 

    if (ret_data) {

        data->user_print(data->mon, ret_data);

    }

    monitor_resume(data->mon);

    qemu_free(data);

}

static void qmp_monitor_complete(void *opaque, QObject *ret_data)

{

    monitor_protocol_emitter(opaque, ret_data);

}

static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,

                                  const QDict *params)

{

    cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);

}

static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)

{

    cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);

}

static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,

                                   const QDict *params)

{

    int ret;

    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));

    cb_data->mon = mon;

    cb_data->user_print = cmd->user_print;

    monitor_suspend(mon);

    ret = cmd->mhandler.cmd_async(mon, params,

                                  user_monitor_complete, cb_data);

    if (ret < 0) {

        monitor_resume(mon);

        qemu_free(cb_data);

    }

}

static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)

{

    int ret;

    MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));

    cb_data->mon = mon;

    cb_data->user_print = cmd->user_print;

    monitor_suspend(mon);

    ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);

    if (ret < 0) {

        monitor_resume(mon);

        qemu_free(cb_data);

    }

}

static int do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    const mon_cmd_t *cmd;

    const char *item = qdict_get_try_str(qdict, "item");

    if (!item) {

        assert(monitor_ctrl_mode(mon) == 0);

        goto help;

    }

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

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

            break;

    }

    if (cmd->name == NULL) {

        if (monitor_ctrl_mode(mon)) {

            qerror_report(QERR_COMMAND_NOT_FOUND, item);

            return -1;

        }

        goto help;

    }

    if (monitor_handler_is_async(cmd)) {

        if (monitor_ctrl_mode(mon)) {

            qmp_async_info_handler(mon, cmd);

        } else {

            user_async_info_handler(mon, cmd);

        }

        /*

         * Indicate that this command is asynchronous and will not return any

         * data (not even empty).  Instead, the data will be returned via a

         * completion callback.

         */

        *ret_data = qobject_from_jsonf("{ '__mon_async': 'return' }");

    } else if (monitor_handler_ported(cmd)) {

        cmd->mhandler.info_new(mon, ret_data);

        if (!monitor_ctrl_mode(mon)) {

            /*

             * User Protocol function is called here, Monitor Protocol is

             * handled by monitor_call_handler()

             */

            if (*ret_data)

                cmd->user_print(mon, *ret_data);

        }

    } else {

        if (monitor_ctrl_mode(mon)) {

            /* handler not converted yet */

            qerror_report(QERR_COMMAND_NOT_FOUND, item);

            return -1;

        } else {

            cmd->mhandler.info(mon);

        }

    }

    return 0;

help:

    help_cmd(mon, "info");

    return 0;

}

static void do_info_version_print(Monitor *mon, const QObject *data)

{

    QDict *qdict;

    qdict = qobject_to_qdict(data);

    monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),

                                  qdict_get_str(qdict, "package"));

}

static void do_info_version(Monitor *mon, QObject **ret_data)

{

    *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",

                                   QEMU_VERSION, QEMU_PKGVERSION);

}

static void do_info_name_print(Monitor *mon, const QObject *data)

{

    QDict *qdict;

    qdict = qobject_to_qdict(data);

    if (qdict_size(qdict) == 0) {

        return;

    }

    monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));

}

static void do_info_name(Monitor *mon, QObject **ret_data)

{

    *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :

                            qobject_from_jsonf("{}");

}

static QObject *get_cmd_dict(const char *name)

{

    const char *p;

    /* Remove '|' from some commands */

    p = strchr(name, '|');

    if (p) {

        p++;

    } else {

        p = name;

    }

    return qobject_from_jsonf("{ 'name': %s }", p);

}

static void do_info_commands(Monitor *mon, QObject **ret_data)

{

    QList *cmd_list;

    const mon_cmd_t *cmd;

    cmd_list = qlist_new();

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

        if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {

            qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));

        }

    }

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

        if (monitor_handler_ported(cmd)) {

            char buf[128];

            snprintf(buf, sizeof(buf), "query-%s", cmd->name);

            qlist_append_obj(cmd_list, get_cmd_dict(buf));

        }

    }

    *ret_data = QOBJECT(cmd_list);

}

static void do_info_uuid_print(Monitor *mon, const QObject *data)

{

    monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));

}

static void do_info_uuid(Monitor *mon, QObject **ret_data)

{

    char uuid[64];

    snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],

                   qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],

                   qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],

                   qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],

                   qemu_uuid[14], qemu_uuid[15]);

    *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);

}

/* get the current CPU defined by the user */

static int mon_set_cpu(int cpu_index)

{

    CPUState *env;

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

        if (env->cpu_index == cpu_index) {

            cur_mon->mon_cpu = env;

            return 0;

        }

    }

    return -1;

}

static CPUState *mon_get_cpu(void)

{

    if (!cur_mon->mon_cpu) {

        mon_set_cpu(0);

    }

    cpu_synchronize_state(cur_mon->mon_cpu);

    return cur_mon->mon_cpu;

}

static void do_info_registers(Monitor *mon)

{

    CPUState *env;

    env = mon_get_cpu();

#ifdef TARGET_I386

    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,

                   X86_DUMP_FPU);

#else

    cpu_dump_state(env, (FILE *)mon, monitor_fprintf,

                   0);

#endif

}

static void print_cpu_iter(QObject *obj, void *opaque)

{

    QDict *cpu;

    int active = ' ';

    Monitor *mon = opaque;

    assert(qobject_type(obj) == QTYPE_QDICT);

    cpu = qobject_to_qdict(obj);

    if (qdict_get_bool(cpu, "current")) {

        active = '*';

    }

    monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));

#if defined(TARGET_I386)

    monitor_printf(mon, "pc=0x" TARGET_FMT_lx,

                   (target_ulong) qdict_get_int(cpu, "pc"));

#elif defined(TARGET_PPC)

    monitor_printf(mon, "nip=0x" TARGET_FMT_lx,

                   (target_long) qdict_get_int(cpu, "nip"));

#elif defined(TARGET_SPARC)

    monitor_printf(mon, "pc=0x " TARGET_FMT_lx,

                   (target_long) qdict_get_int(cpu, "pc"));

    monitor_printf(mon, "npc=0x" TARGET_FMT_lx,

                   (target_long) qdict_get_int(cpu, "npc"));

#elif defined(TARGET_MIPS)

    monitor_printf(mon, "PC=0x" TARGET_FMT_lx,

                   (target_long) qdict_get_int(cpu, "PC"));

#endif

    if (qdict_get_bool(cpu, "halted")) {

        monitor_printf(mon, " (halted)");

    }

    monitor_printf(mon, "\n");

}

static void monitor_print_cpus(Monitor *mon, const QObject *data)

{

    QList *cpu_list;

    assert(qobject_type(data) == QTYPE_QLIST);

    cpu_list = qobject_to_qlist(data);

    qlist_iter(cpu_list, print_cpu_iter, mon);

}

static void do_info_cpus(Monitor *mon, QObject **ret_data)

{

    CPUState *env;

    QList *cpu_list;

    cpu_list = qlist_new();

    /* just to set the default cpu if not already done */

    mon_get_cpu();

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

        QDict *cpu;

        QObject *obj;

        cpu_synchronize_state(env);

        obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",

                                 env->cpu_index, env == mon->mon_cpu,

                                 env->halted);

        cpu = qobject_to_qdict(obj);

#if defined(TARGET_I386)

        qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));

#elif defined(TARGET_PPC)

        qdict_put(cpu, "nip", qint_from_int(env->nip));

#elif defined(TARGET_SPARC)

        qdict_put(cpu, "pc", qint_from_int(env->pc));

        qdict_put(cpu, "npc", qint_from_int(env->npc));

#elif defined(TARGET_MIPS)

        qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));

#endif

        qlist_append(cpu_list, cpu);

    }

    *ret_data = QOBJECT(cpu_list);

}

static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)