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 "ui/qemu-spice.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 "cpu.h"

#include "trace.h"

#include "trace/control.h"

#ifdef CONFIG_TRACE_SIMPLE

#include "trace/simple.h"

#endif

#include "ui/qemu-spice.h"

#include "memory.h"

#include "qmp-commands.h"

#include "hmp.h"

#include "qemu-thread.h"

/* for pic/irq_info */

#if defined(TARGET_SPARC)

#include "hw/sun4m.h"

#endif

#include "hw/lm32_pic.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'          Non-negative target long (32 or 64 bit), in user mode the

 *              value is multiplied by 2^20 (think Mebibyte)

 * 'o'          octets (aka bytes)

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

 *              suffix, which multiplies the value by 2^40 for

 *              suffixes T and t, 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 (*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 flags;

} 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;

};

/* file descriptor associated with a file descriptor set */

typedef struct MonFdsetFd MonFdsetFd;

struct MonFdsetFd {

    int fd;

    bool removed;

    char *opaque;

    QLIST_ENTRY(MonFdsetFd) next;

};

/* file descriptor set containing fds passed via SCM_RIGHTS */

typedef struct MonFdset MonFdset;

struct MonFdset {

    int64_t id;

    QLIST_HEAD(, MonFdsetFd) fds;

    QLIST_HEAD(, MonFdsetFd) dup_fds;

    QLIST_ENTRY(MonFdset) next;

};

typedef struct MonitorControl {

    QObject *id;

    JSONMessageParser parser;

    int command_mode;

} MonitorControl;

/*

 * To prevent flooding clients, events can be throttled. The

 * throttling is calculated globally, rather than per-Monitor

 * instance.

 */

typedef struct MonitorEventState {

    MonitorEvent event; /* Event being tracked */

    int64_t rate;       /* Period over which to throttle. 0 to disable */

    int64_t last;       /* Time at which event was last emitted */

    QEMUTimer *timer;   /* Timer for handling delayed events */

    QObject *data;      /* Event pending delayed dispatch */

} MonitorEventState;

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;

    CPUArchState *mon_cpu;

    BlockDriverCompletionFunc *password_completion_cb;

    void *password_opaque;

    QError *error;

    QLIST_HEAD(,mon_fd_t) fds;

    QLIST_ENTRY(Monitor) entry;

};

/* QMP checker flags */

#define QMP_ACCEPT_UNKNOWNS 1

static QLIST_HEAD(mon_list, Monitor) mon_list;

static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;

static int mon_refcount;

static mon_cmd_t mon_cmds[];

static mon_cmd_t info_cmds[];

static const mon_cmd_t qmp_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);

}

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);

}

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_fe_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;

    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 GCC_FMT_ATTR(2, 3) 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 handler_is_qobject(const mon_cmd_t *cmd)

{

    return cmd->user_print != NULL;

}

static inline bool handler_is_async(const mon_cmd_t *cmd)

{

    return cmd->flags & MONITOR_CMD_ASYNC;

}

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 = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :

                                             qobject_to_json(data);

    assert(json != NULL);

    qstring_append_chr(json, '\n');

    monitor_puts(mon, qstring_get_str(json));

    QDECREF(json);

}

static QDict *build_qmp_error_dict(const QError *err)

{

    QObject *obj;

    obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",

                             ErrorClass_lookup[err->err_class],

                             qerror_human(err));

    return qobject_to_qdict(obj);

}

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

{

    QDict *qmp;

    trace_monitor_protocol_emitter(mon);

    if (!monitor_has_error(mon)) {

        /* success response */

        qmp = qdict_new();

        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 */

        qmp = build_qmp_error_dict(mon->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);

}

static const char *monitor_event_names[] = {

    [QEVENT_SHUTDOWN] = "SHUTDOWN",

    [QEVENT_RESET] = "RESET",

    [QEVENT_POWERDOWN] = "POWERDOWN",

    [QEVENT_STOP] = "STOP",

    [QEVENT_RESUME] = "RESUME",

    [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",

    [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",

    [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",

    [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",

    [QEVENT_RTC_CHANGE] = "RTC_CHANGE",

    [QEVENT_WATCHDOG] = "WATCHDOG",

    [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",

    [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",

    [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",

    [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",

    [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",

    [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",

    [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",

    [QEVENT_SUSPEND] = "SUSPEND",

    [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",

    [QEVENT_WAKEUP] = "WAKEUP",

    [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",

    [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",

};

QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)

MonitorEventState monitor_event_state[QEVENT_MAX];

QemuMutex monitor_event_state_lock;

/*

 * Emits the event to every monitor instance

 */

static void

monitor_protocol_event_emit(MonitorEvent event,

                            QObject *data)

{

    Monitor *mon;

    trace_monitor_protocol_event_emit(event, data);

    QLIST_FOREACH(mon, &mon_list, entry) {

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

            monitor_json_emitter(mon, data);

        }

    }

}

/*

 * Queue a new event for emission to Monitor instances,

 * applying any rate limiting if required.

 */

static void

monitor_protocol_event_queue(MonitorEvent event,

                             QObject *data)

{

    MonitorEventState *evstate;

    int64_t now = qemu_get_clock_ns(rt_clock);

    assert(event < QEVENT_MAX);

    qemu_mutex_lock(&monitor_event_state_lock);

    evstate = &(monitor_event_state[event]);

    trace_monitor_protocol_event_queue(event,

                                       data,

                                       evstate->rate,

                                       evstate->last,

                                       now);

    /* Rate limit of 0 indicates no throttling */

    if (!evstate->rate) {

        monitor_protocol_event_emit(event, data);

        evstate->last = now;

    } else {

        int64_t delta = now - evstate->last;

        if (evstate->data ||

            delta < evstate->rate) {

            /* If there's an existing event pending, replace

             * it with the new event, otherwise schedule a

             * timer for delayed emission

             */

            if (evstate->data) {

                qobject_decref(evstate->data);

            } else {

                int64_t then = evstate->last + evstate->rate;

                qemu_mod_timer_ns(evstate->timer, then);

            }

            evstate->data = data;

            qobject_incref(evstate->data);

        } else {

            monitor_protocol_event_emit(event, data);

            evstate->last = now;

        }

    }

    qemu_mutex_unlock(&monitor_event_state_lock);

}

/*

 * The callback invoked by QemuTimer when a delayed

 * event is ready to be emitted

 */

static void monitor_protocol_event_handler(void *opaque)

{

    MonitorEventState *evstate = opaque;

    int64_t now = qemu_get_clock_ns(rt_clock);

    qemu_mutex_lock(&monitor_event_state_lock);

    trace_monitor_protocol_event_handler(evstate->event,

                                         evstate->data,

                                         evstate->last,

                                         now);

    if (evstate->data) {

        monitor_protocol_event_emit(evstate->event, evstate->data);

        qobject_decref(evstate->data);

        evstate->data = NULL;

    }

    evstate->last = now;

    qemu_mutex_unlock(&monitor_event_state_lock);

}

/*

 * @event: the event ID to be limited

 * @rate: the rate limit in milliseconds

 *

 * Sets a rate limit on a particular event, so no

 * more than 1 event will be emitted within @rate

 * milliseconds

 */

static void

monitor_protocol_event_throttle(MonitorEvent event,

                                int64_t rate)

{

    MonitorEventState *evstate;

    assert(event < QEVENT_MAX);

    evstate = &(monitor_event_state[event]);

    trace_monitor_protocol_event_throttle(event, rate);

    evstate->event = event;

    evstate->rate = rate * SCALE_MS;

    evstate->timer = qemu_new_timer(rt_clock,

                                    SCALE_MS,

                                    monitor_protocol_event_handler,

                                    evstate);

    evstate->last = 0;

    evstate->data = NULL;

}

/* Global, one-time initializer to configure the rate limiting

 * and initialize state */

static void monitor_protocol_event_init(void)

{

    qemu_mutex_init(&monitor_event_state_lock);

    /* Limit RTC & BALLOON events to 1 per second */

    monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);

    monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);

    monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);

}

/**

 * 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;

    assert(event < QEVENT_MAX);

    event_name = monitor_event_names[event];

    assert(event_name != NULL);

    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);

    }

    trace_monitor_protocol_event(event, event_name, qmp);

    monitor_protocol_event_queue(event, 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 void handle_user_command(Monitor *mon, const char *cmdline);

char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,

                                int64_t cpu_index, Error **errp)

{

    char *output = NULL;

    Monitor *old_mon, hmp;

    CharDriverState mchar;

    memset(&hmp, 0, sizeof(hmp));

    qemu_chr_init_mem(&mchar);

    hmp.chr = &mchar;

    old_mon = cur_mon;

    cur_mon = &hmp;

    if (has_cpu_index) {

        int ret = monitor_set_cpu(cpu_index);

        if (ret < 0) {

            cur_mon = old_mon;

            error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",

                      "a CPU number");

            goto out;

        }

    }

    handle_user_command(&hmp, command_line);

    cur_mon = old_mon;

    if (qemu_chr_mem_osize(hmp.chr) > 0) {

        QString *str = qemu_chr_mem_to_qs(hmp.chr);

        output = g_strdup(qstring_get_str(str));

        QDECREF(str);

    } else {

        output = g_strdup("");

    }

out:

    qemu_chr_close_mem(hmp.chr);

    return output;

}

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 do_trace_event_set_state(Monitor *mon, const QDict *qdict)

{

    const char *tp_name = qdict_get_str(qdict, "name");

    bool new_state = qdict_get_bool(qdict, "option");

    int ret = trace_event_set_state(tp_name, new_state);

    if (!ret) {

        monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);

    }

}

#ifdef CONFIG_TRACE_SIMPLE

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

{

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

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

    if (!op) {

        st_print_trace_file_status((FILE *)mon, &monitor_fprintf);

    } else if (!strcmp(op, "on")) {

        st_set_trace_file_enabled(true);

    } else if (!strcmp(op, "off")) {

        st_set_trace_file_enabled(false);

    } else if (!strcmp(op, "flush")) {

        st_flush_trace_buffer();

    } else if (!strcmp(op, "set")) {

        if (arg) {

            st_set_trace_file(arg);

        }

    } else {

        monitor_printf(mon, "unexpected argument \"%s\"\n", op);

        help_cmd(mon, "trace-file");

    }

}

#endif

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);

    g_free(data);

}

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

{

    monitor_protocol_emitter(opaque, ret_data);

}

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

                                 const QDict *params)

{

    return cmd->mhandler.cmd_async(mon, params, 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 = g_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);

        g_free(cb_data);

    }

}

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

{

    const mon_cmd_t *cmd;

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

    if (!item) {

        goto help;

    }

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

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

            break;

    }

    if (cmd->name == NULL) {

        goto help;

    }

    cmd->mhandler.info(mon);

    return;

help:

    help_cmd(mon, "info");

}

CommandInfoList *qmp_query_commands(Error **errp)

{

    CommandInfoList *info, *cmd_list = NULL;

    const mon_cmd_t *cmd;

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

        info = g_malloc0(sizeof(*info));

        info->value = g_malloc0(sizeof(*info->value));

        info->value->name = g_strdup(cmd->name);

        info->next = cmd_list;

        cmd_list = info;

    }

    return cmd_list;

}

EventInfoList *qmp_query_events(Error **errp)

{

    EventInfoList *info, *ev_list = NULL;

    MonitorEvent e;

    for (e = 0 ; e < QEVENT_MAX ; e++) {

        const char *event_name = monitor_event_names[e];

        assert(event_name != NULL);

        info = g_malloc0(sizeof(*info));

        info->value = g_malloc0(sizeof(*info->value));

        info->value->name = g_strdup(event_name);

        info->next = ev_list;

        ev_list = info;

    }

    return ev_list;

}

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

int monitor_set_cpu(int cpu_index)

{

    CPUArchState *env;

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

        if (env->cpu_index == cpu_index) {

            cur_mon->mon_cpu = env;

            return 0;