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 "qemu-char.h"

#include "sysemu.h"

#include "monitor.h"

#include "readline.h"

#include "console.h"

#include "block.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 "qlist.h"

#include "qdict.h"

#include "qstring.h"

#include "qerror.h"

#include "qjson.h"

//#define DEBUG

//#define DEBUG_COMPLETION

/*

 * Supported types:

 *

 * 'F'          filename

 * 'B'          block device name

 * 's'          string (accept optional quote)

 * 'i'          32 bit integer

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

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

 *

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

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

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

 *

 */

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

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

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

    } mhandler;

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

};

struct Monitor {

    CharDriverState *chr;

    int mux_out;

    int reset_seen;

    int flags;

    int suspend_cnt;

    uint8_t outbuf[1024];

    int outbuf_index;

    ReadLineState *rs;

    CPUState *mon_cpu;

    BlockDriverCompletionFunc *password_completion_cb;

    void *password_opaque;

    QError *error;

    QLIST_HEAD(,mon_fd_t) fds;

    QLIST_ENTRY(Monitor) entry;

};

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 = NULL;

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

                               void *opaque);

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

static inline int monitor_ctrl_mode(const Monitor *mon)

{

    return (mon->flags & MONITOR_USE_CONTROL);

}

static void monitor_read_command(Monitor *mon, int show_prompt)

{

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

    if (!mon)

        return;

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

    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 int monitor_has_error(const Monitor *mon)

{

    return mon->error != NULL;

}

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

{

    switch (qobject_type(data)) {

        case QTYPE_QSTRING:

            monitor_printf(mon, "%s",qstring_get_str(qobject_to_qstring(data)));

            break;

        case QTYPE_QINT:

            monitor_printf(mon, "%" PRId64,qint_get_int(qobject_to_qint(data)));

            break;

        default:

            monitor_printf(mon, "ERROR: unsupported type: %d",

                                                        qobject_type(data));

            break;

    }

    monitor_puts(mon, "\n");

}

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

{

    QString *json;

    json = qobject_to_json(data);

    assert(json != NULL);

    monitor_printf(mon, "%s\n", 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 {

            qdict_put(qmp, "return", qstring_from_str("OK"));

        }

    } else {

        /* error response */

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

        QINCREF(mon->error->error);

        QDECREF(mon->error);

        mon->error = NULL;

    }

    monitor_json_emitter(mon, QOBJECT(qmp));

    QDECREF(qmp);

}

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

{

    int all_devices;

    DriveInfo *dinfo;

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

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

    QTAILQ_FOREACH(dinfo, &drives, next) {

        if (!all_devices)

            if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))

                continue;

        bdrv_commit(dinfo->bdrv);

    }

}

static void 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)) {

            qemu_error_new(QERR_COMMAND_NOT_FOUND, item);

            return;

        }

        goto help;

    }

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

            qemu_error_new(QERR_COMMAND_NOT_FOUND, item);

        } else {

            cmd->mhandler.info(mon);

        }

    }

    return;

help:

    help_cmd(mon, "info");

}

/**

 * do_info_version(): Show QEMU version

 */

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

{

    *ret_data = QOBJECT(qstring_from_str(QEMU_VERSION QEMU_PKGVERSION));

}

static void do_info_name(Monitor *mon)

{

    if (qemu_name)

        monitor_printf(mon, "%s\n", qemu_name);

}

/**

 * do_info_commands(): List QMP available commands

 *

 * Return a QList of QStrings.

 */

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(cmd_list, qstring_from_str(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(cmd_list, qstring_from_str(buf));

        }

    }

    *ret_data = QOBJECT(cmd_list);

}

#if defined(TARGET_I386)

static void do_info_hpet(Monitor *mon)

{

    monitor_printf(mon, "HPET is %s by QEMU\n",

                   (no_hpet) ? "disabled" : "enabled");

}

#endif

static void do_info_uuid(Monitor *mon)

{

    monitor_printf(mon, UUID_FMT "\n", 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]);

}

/* 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();

    if (!env)

        return;

#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 (strcmp(qdict_get_str(cpu, "current"), "yes") == 0)

        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 (strcmp(qdict_get_str(cpu, "halted"), "yes") == 0)

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

}

/**

 * do_info_cpus(): Show CPU information

 *

 * Return a QList with a QDict for each CPU.

 *

 * For example:

 *

 * [ { "CPU": 0, "current": "yes", "pc": 0x..., "halted": "no" },

 *   { "CPU": 1, "current": "no",  "pc": 0x..., "halted": "yes" } ]

 */

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

        const char *answer;

        QDict *cpu = qdict_new();

        cpu_synchronize_state(env);

        qdict_put(cpu, "CPU", qint_from_int(env->cpu_index));

        answer = (env == mon->mon_cpu) ? "yes" : "no";

        qdict_put(cpu, "current", qstring_from_str(answer));

#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

        answer = env->halted ? "yes" : "no";

        qdict_put(cpu, "halted", qstring_from_str(answer));

        qlist_append(cpu_list, cpu);

    }

    *ret_data = QOBJECT(cpu_list);

}

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

{

    int index = qdict_get_int(qdict, "index");

    if (mon_set_cpu(index) < 0)

        monitor_printf(mon, "Invalid CPU index\n");

}

static void do_info_jit(Monitor *mon)

{

    dump_exec_info((FILE *)mon, monitor_fprintf);

}

static void do_info_history(Monitor *mon)

{

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

    }

}

#if defined(TARGET_PPC)

/* XXX: not implemented in other targets */

static void do_info_cpu_stats(Monitor *mon)

{

    CPUState *env;

    env = mon_get_cpu();

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

}

#endif

/**

 * do_quit(): Quit QEMU execution

 */

static void do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    exit(0);

}

static int eject_device(Monitor *mon, BlockDriverState *bs, int force)

{

    if (bdrv_is_inserted(bs)) {

        if (!force) {

            if (!bdrv_is_removable(bs)) {

                monitor_printf(mon, "device is not removable\n");

                return -1;

            }

            if (bdrv_is_locked(bs)) {

                monitor_printf(mon, "device is locked\n");

                return -1;

            }

        }

        bdrv_close(bs);

    }

    return 0;

}

static void do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    BlockDriverState *bs;

    int force = qdict_get_int(qdict, "force");

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

    bs = bdrv_find(filename);

    if (!bs) {

        monitor_printf(mon, "device not found\n");

        return;

    }

    eject_device(mon, bs, force);

}

static void do_change_block(Monitor *mon, const char *device,

                            const char *filename, const char *fmt)

{

    BlockDriverState *bs;

    BlockDriver *drv = NULL;

    bs = bdrv_find(device);

    if (!bs) {

        monitor_printf(mon, "device not found\n");

        return;

    }

    if (fmt) {

        drv = bdrv_find_whitelisted_format(fmt);

        if (!drv) {

            monitor_printf(mon, "invalid format %s\n", fmt);

            return;

        }

    }

    if (eject_device(mon, bs, 0) < 0)

        return;

    bdrv_open2(bs, filename, 0, drv);

    monitor_read_bdrv_key_start(mon, bs, NULL, NULL);

}

static void change_vnc_password_cb(Monitor *mon, const char *password,

                                   void *opaque)

{

    if (vnc_display_password(NULL, password) < 0)

        monitor_printf(mon, "could not set VNC server password\n");

    monitor_read_command(mon, 1);

}

static void do_change_vnc(Monitor *mon, const char *target, const char *arg)

{

    if (strcmp(target, "passwd") == 0 ||

        strcmp(target, "password") == 0) {

        if (arg) {

            char password[9];

            strncpy(password, arg, sizeof(password));

            password[sizeof(password) - 1] = '\0';

            change_vnc_password_cb(mon, password, NULL);

        } else {

            monitor_read_password(mon, change_vnc_password_cb, NULL);

        }

    } else {

        if (vnc_display_open(NULL, target) < 0)

            monitor_printf(mon, "could not start VNC server on %s\n", target);

    }

}

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

{

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

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

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

    if (strcmp(device, "vnc") == 0) {

        do_change_vnc(mon, target, arg);

    } else {

        do_change_block(mon, device, target, arg);

    }

}

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

{

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

}

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

{

    cpu_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 = cpu_str_to_log_mask(items);

        if (!mask) {

            help_cmd(mon, "log");

            return;

        }

    }

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

    }

}

/**

 * do_stop(): Stop VM execution

 */

static void do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    vm_stop(EXCP_INTERRUPT);

}

static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);

struct bdrv_iterate_context {

    Monitor *mon;

    int err;

};

/**

 * do_cont(): Resume emulation.

 */

static void do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)

{

    struct bdrv_iterate_context context = { mon, 0 };

    bdrv_iterate(encrypted_bdrv_it, &context);

    /* only resume the vm if all keys are set and valid */

    if (!context.err)

        vm_start();

}

static void bdrv_key_cb(void *opaque, int err)

{

    Monitor *mon = opaque;

    /* another key was set successfully, retry to continue */

    if (!err)

        do_cont(mon, NULL, NULL);

}

static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)

{

    struct bdrv_iterate_context *context = opaque;

    if (!context->err && bdrv_key_required(bs)) {

        context->err = -EBUSY;

        monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,

                                    context->mon);

    }

}

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