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 "monitor/qdev.h"

#include "hw/usb.h"

#include "hw/pcmcia.h"

#include "hw/i386/pc.h"

#include "hw/pci/pci.h"

#include "sysemu/watchdog.h"

#include "hw/loader.h"

#include "exec/gdbstub.h"

#include "net/net.h"

#include "net/slirp.h"

#include "sysemu/char.h"

#include "ui/qemu-spice.h"

#include "sysemu/sysemu.h"

#include "monitor/monitor.h"

#include "monitor/readline.h"

#include "ui/console.h"

#include "sysemu/blockdev.h"

#include "audio/audio.h"

#include "disas/disas.h"

#include "sysemu/balloon.h"

#include "qemu/timer.h"

#include "migration/migration.h"

#include "sysemu/kvm.h"

#include "qemu/acl.h"

#include "sysemu/tpm.h"

#include "qapi/qmp/qint.h"

#include "qapi/qmp/qfloat.h"

#include "qapi/qmp/qlist.h"

#include "qapi/qmp/qbool.h"

#include "qapi/qmp/qstring.h"

#include "qapi/qmp/qjson.h"

#include "qapi/qmp/json-streamer.h"

#include "qapi/qmp/json-parser.h"

#include "qemu/osdep.h"

#include "cpu.h"

#include "trace.h"

#include "trace/control.h"

#ifdef CONFIG_TRACE_SIMPLE

#include "trace/simple.h"

#endif

#include "exec/memory.h"

#include "qmp-commands.h"

#include "hmp.h"

#include "qemu/thread.h"

/* for pic/irq_info */

#if defined(TARGET_SPARC)

#include "hw/sparc/sun4m.h"

#endif

#include "hw/lm32/lm32_pic.h"

//#define DEBUG

//#define DEBUG_COMPLETION

/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'S'          it just appends the rest of the 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 E, e, P, p, T, t, G, g, M, m,

 *              K, k suffix, which multiplies the value by 2^60 for suffixes E

 *              and e, 2^50 for suffixes P and p, 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 (*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;

    /* @sub_table is a list of 2nd level of commands. If it do not exist,

     * mhandler should be used. If it exist, sub_table[?].mhandler should be

     * used, and mhandler of 1st level plays the role of help function.

     */

    struct mon_cmd_t *sub_table;

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

    bool skip_flush;

    QString *outbuf;

    guint watch;

    ReadLineState *rs;

    MonitorControl *mc;

    CPUState *mon_cpu;

    BlockDriverCompletionFunc *password_completion_cb;

    void *password_opaque;

    mon_cmd_t *cmd_table;

    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;

    }

}

static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,

                                  void *opaque)

{

    Monitor *mon = opaque;

    mon->watch = 0;

    monitor_flush(mon);

    return FALSE;

}

void monitor_flush(Monitor *mon)

{

    int rc;

    size_t len;

    const char *buf;

    if (mon->skip_flush) {

        return;

    }

    buf = qstring_get_str(mon->outbuf);

    len = qstring_get_length(mon->outbuf);

    if (len && !mon->mux_out) {

        rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);

        if (rc == len) {

            /* all flushed */

            QDECREF(mon->outbuf);

            mon->outbuf = qstring_new();

            return;

        }

        if (rc > 0) {

            /* partinal write */

            QString *tmp = qstring_from_str(buf + rc);

            QDECREF(mon->outbuf);

            mon->outbuf = tmp;

        }

        if (mon->watch == 0) {

            mon->watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT,

                                               monitor_unblocked, mon);

        }

    }

}

/* flush at every end of line */

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

{

    char c;

    for(;;) {

        c = *str++;

        if (c == '\0')

            break;

        if (c == '\n') {

            qstring_append_chr(mon->outbuf, '\r');

        }

        qstring_append_chr(mon->outbuf, c);

        if (c == '\n') {

            monitor_flush(mon);

        }

    }

}

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

{

    char *buf;

    if (!mon)

        return;

    if (monitor_ctrl_mode(mon)) {

        return;

    }

    buf = g_strdup_vprintf(fmt, ap);

    monitor_puts(mon, buf);

    g_free(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_BLOCK_JOB_READY] = "BLOCK_JOB_READY",

    [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",

    [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",

    [QEVENT_NIC_RX_FILTER_CHANGED] = "NIC_RX_FILTER_CHANGED",

    [QEVENT_SUSPEND] = "SUSPEND",

    [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",

    [QEVENT_WAKEUP] = "WAKEUP",

    [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",

    [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",

    [QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",

};

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_clock_get_ns(QEMU_CLOCK_REALTIME);

    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;

                timer_mod_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_clock_get_ns(QEMU_CLOCK_REALTIME);

    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 = timer_new(QEMU_CLOCK_REALTIME,

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

static void monitor_data_init(Monitor *mon)

{

    memset(mon, 0, sizeof(Monitor));

    mon->outbuf = qstring_new();

    /* Use *mon_cmds by default. */

    mon->cmd_table = mon_cmds;

}

static void monitor_data_destroy(Monitor *mon)

{

    QDECREF(mon->outbuf);

}

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;

    monitor_data_init(&hmp);

    hmp.skip_flush = true;

    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 (qstring_get_length(hmp.outbuf) > 0) {

        output = g_strdup(qstring_get_str(hmp.outbuf));

    } else {

        output = g_strdup("");

    }

out:

    monitor_data_destroy(&hmp);

    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 int get_str(char *buf, int buf_size, const char **pp)

{

    const char *p;

    char *q;

    int c;

    q = buf;

    p = *pp;

    while (qemu_isspace(*p)) {

        p++;

    }

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

    fail:

        *q = '\0';

        *pp = p;

        return -1;

    }

    if (*p == '\"') {

        p++;

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

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

                p++;

                c = *p++;

                switch (c) {

                case 'n':

                    c = '\n';

                    break;

                case 'r':

                    c = '\r';

                    break;

                case '\\':

                case '\'':

                case '\"':

                    break;

                default:

                    qemu_printf("unsupported escape code: '\\%c'\n", c);

                    goto fail;

                }

                if ((q - buf) < buf_size - 1) {

                    *q++ = c;

                }

            } else {

                if ((q - buf) < buf_size - 1) {

                    *q++ = *p;

                }

                p++;

            }

        }

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

            qemu_printf("unterminated string\n");

            goto fail;

        }

        p++;

    } else {

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

            if ((q - buf) < buf_size - 1) {

                *q++ = *p;

            }

            p++;

        }

    }

    *q = '\0';

    *pp = p;

    return 0;

}

#define MAX_ARGS 16

static void free_cmdline_args(char **args, int nb_args)

{

    int i;

    assert(nb_args <= MAX_ARGS);

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

        g_free(args[i]);

    }

}

/*

 * Parse the command line to get valid args.

 * @cmdline: command line to be parsed.

 * @pnb_args: location to store the number of args, must NOT be NULL.

 * @args: location to store the args, which should be freed by caller, must

 *        NOT be NULL.

 *

 * Returns 0 on success, negative on failure.

 *

 * NOTE: this parser is an approximate form of the real command parser. Number

 *       of args have a limit of MAX_ARGS. If cmdline contains more, it will

 *       return with failure.

 */

static int parse_cmdline(const char *cmdline,

                         int *pnb_args, char **args)

{

    const char *p;

    int nb_args, ret;

    char buf[1024];

    p = cmdline;

    nb_args = 0;

    for (;;) {

        while (qemu_isspace(*p)) {

            p++;

        }

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

            break;

        }

        if (nb_args >= MAX_ARGS) {

            goto fail;

        }

        ret = get_str(buf, sizeof(buf), &p);

        if (ret < 0) {

            goto fail;

        }

        args[nb_args] = g_strdup(buf);

        nb_args++;

    }

    *pnb_args = nb_args;

    return 0;

 fail:

    free_cmdline_args(args, nb_args);

    return -1;

}

static void help_cmd_dump_one(Monitor *mon,

                              const mon_cmd_t *cmd,

                              char **prefix_args,

                              int prefix_args_nb)

{

    int i;

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

        monitor_printf(mon, "%s ", prefix_args[i]);

    }

    monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);

}

/* @args[@arg_index] is the valid command need to find in @cmds */

static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,

                          char **args, int nb_args, int arg_index)

{

    const mon_cmd_t *cmd;

    /* No valid arg need to compare with, dump all in *cmds */

    if (arg_index >= nb_args) {

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

            help_cmd_dump_one(mon, cmd, args, arg_index);

        }

        return;

    }

    /* Find one entry to dump */

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

        if (compare_cmd(args[arg_index], cmd->name)) {

            if (cmd->sub_table) {

                /* continue with next arg */

                help_cmd_dump(mon, cmd->sub_table,

                              args, nb_args, arg_index + 1);

            } else {

                help_cmd_dump_one(mon, cmd, args, arg_index);

            }

            break;

        }

    }

}

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

{

    char *args[MAX_ARGS];

    int nb_args = 0;

    /* 1. parse user input */

    if (name) {

        /* special case for log, directly dump and return */

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

            const QEMULogItem *item;

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

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

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

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

            }

            return;

        }

        if (parse_cmdline(name, &nb_args, args) < 0) {

            return;

        }

    }

    /* 2. dump the contents according to parsed args */

    help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);

    free_cmdline_args(args, nb_args);

}

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

    bool found = false;

    TraceEvent *ev = NULL;

    while ((ev = trace_event_pattern(tp_name, ev)) != NULL) {

        found = true;

        if (!trace_event_get_state_static(ev)) {

            monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);

        } else {

            trace_event_set_state_dynamic(ev, new_state);

        }

    }

    if (!trace_event_is_pattern(tp_name) && !found) {

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

{

    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)

{

    CPUState *cpu;

    cpu = qemu_get_cpu(cpu_index);

    if (cpu == NULL) {

        return -1;

    }

    cur_mon->mon_cpu = cpu;

    return 0;

}

static CPUArchState *mon_get_cpu(void)

{

    if (!cur_mon->mon_cpu) {

        monitor_set_cpu(0);

    }

    cpu_synchronize_state(cur_mon->mon_cpu);

    return cur_mon->mon_cpu->env_ptr;

}

int monitor_get_cpu_index(void)

{

    CPUState *cpu = ENV_GET_CPU(mon_get_cpu());

    return cpu->cpu_index;

}

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

{

    CPUState *cpu;

    CPUArchState *env;

    env = mon_get_cpu();

    cpu = ENV_GET_CPU(env);

    cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);

}

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

{

    dump_exec_info((FILE *)mon, monitor_fprintf);

}

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

{

    int i;

    const char *str;

    if (!mon->rs)

        return;

    i = 0;

    for(;;) {

        str = readline_get_history(mon->rs, i);

        if (!str)

            break;

        monitor_printf(mon, "%d: '%s'\n", i, str);

        i++;

    }

}

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

{

    CPUState *cpu;

    CPUArchState *env;

    env = mon_get_cpu();

    cpu = ENV_GET_CPU(env);

    cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);

}

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

{

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

}

static int client_migrate_info(Monitor *mon, const QDict *qdict,

                               MonitorCompletion cb, void *opaque)

{

    const char *protocol = qdict_get_str(qdict, "protocol");

    const char *hostname = qdict_get_str(qdict, "hostname");

    const char *subject  = qdict_get_try_str(qdict, "cert-subject");

    int port             = qdict_get_try_int(qdict, "port", -1);

    int tls_port         = qdict_get_try_int(qdict, "tls-port", -1);

    int ret;

    if (strcmp(protocol, "spice") == 0) {

        if (!using_spice) {

            qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");

            return -1;

        }

        if (port == -1 && tls_port == -1) {

            qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");

            return -1;

        }

        ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,

                                      cb, opaque);

        if (ret != 0) {

            qerror_report(QERR_UNDEFINED_ERROR);

            return -1;

        }

        return 0;

    }

    qerror_report(QERR_INVALID_PARAMETER, "protocol");

    return -1;

}

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

{

    qemu_set_log_filename(qdict_get_str(qdict, "filename"));

}

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

{

    int mask;

    const char *items = qdict_get_str(qdict, "items");

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

        mask = 0;

    } else {

        mask = qemu_str_to_log_mask(items);

        if (!mask) {

            help_cmd(mon, "log");

            return;

        }

    }

    qemu_set_log(mask);

}

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

{

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

    if (!option || !strcmp(option, "on")) {

        singlestep = 1;

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

        singlestep = 0;

    } else {

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

    }

}

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

{

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

    if (!device)

        device = "tcp::" DEFAULT_GDBSTUB_PORT;

    if (gdbserver_start(device) < 0) {

        monitor_printf(mon, "Could not open gdbserver on device '%s'\n",

                       device);

    } else if (strcmp(device, "none") == 0) {

        monitor_printf(mon, "Disabled gdbserver\n");

    } else {

        monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",

                       device);

    }

}

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

{

    const char *action = qdict_get_str(qdict, "action");

    if (select_watchdog_action(action) == -1) {

        monitor_printf(mon, "Unknown watchdog action '%s'\n", action);

    }

}

static void monitor_printc(Monitor *mon, int c)

{

    monitor_printf(mon, "'");

    switch(c) {

    case '\'':

        monitor_printf(mon, "\\'");

        break;

    case '\\':

        monitor_printf(mon, "\\\\");

        break;

    case '\n':

        monitor_printf(mon, "\\n");

        break;

    case '\r':

        monitor_printf(mon, "\\r");

        break;

    default:

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

            monitor_printf(mon, "%c", c);

        } else {

            monitor_printf(mon, "\\x%02x", c);

        }

        break;

    }

    monitor_printf(mon, "'");

}

static void memory_dump(Monitor *mon, int count, int format, int wsize,

                        hwaddr addr, int is_physical)

{

    CPUArchState *env;

    int l, line_size, i, max_digits, len;

    uint8_t buf[16];

    uint64_t v;

    if (format == 'i') {

        int flags;

        flags = 0;

        env = mon_get_cpu();

#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 (env) {

#ifdef TARGET_X86_64

                if ((env->efer & MSR_EFER_LMA) &&

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

                    flags = 2;

                else

#endif

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

                    flags = 1;