[RFC,10/10] monitor: Split out monitor/core.c
diff mbox series

Message ID 20190607135430.22149-11-kwolf@redhat.com
State New
Headers show
Series
  • monitor: Split monitor.c in core/HMP/QMP/misc
Related show

Commit Message

Kevin Wolf June 7, 2019, 1:54 p.m. UTC
Move the monitor core infrastructure from monitor/misc.c to
monitor/core.c. This is code that can be shared for all targets, so
compile it only once.

What remains in monitor/misc.c after this patch is mostly monitor
command implementations and code that requires a system emulator or is
even target-dependent.

The amount of function and particularly extern variables in
monitor_int.h is probably a bit larger than it needs to be, but this way
no non-trivial code modifications are needed. The interfaces between all
monitor parts can be cleaned up later.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/monitor/monitor.h |   1 +
 monitor/monitor_int.h     |   1 +
 monitor/core.c            | 604 ++++++++++++++++++++++++++++++++++++++
 monitor/misc.c            | 567 +----------------------------------
 monitor/Makefile.objs     |   2 +-
 5 files changed, 608 insertions(+), 567 deletions(-)
 create mode 100644 monitor/core.c

Comments

Dr. David Alan Gilbert June 7, 2019, 5:29 p.m. UTC | #1
* Kevin Wolf (kwolf@redhat.com) wrote:
> Move the monitor core infrastructure from monitor/misc.c to
> monitor/core.c. This is code that can be shared for all targets, so
> compile it only once.
> 
> What remains in monitor/misc.c after this patch is mostly monitor
> command implementations and code that requires a system emulator or is
> even target-dependent.
> 
> The amount of function and particularly extern variables in
> monitor_int.h is probably a bit larger than it needs to be, but this way
> no non-trivial code modifications are needed. The interfaces between all
> monitor parts can be cleaned up later.
> 
> Signed-off-by: Kevin Wolf <kwolf@redhat.com>

OK, but can you call it anything other than core.* - I regularly end up
deleting things like that!

Other than that,


Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>

> ---
>  include/monitor/monitor.h |   1 +
>  monitor/monitor_int.h     |   1 +
>  monitor/core.c            | 604 ++++++++++++++++++++++++++++++++++++++
>  monitor/misc.c            | 567 +----------------------------------
>  monitor/Makefile.objs     |   2 +-
>  5 files changed, 608 insertions(+), 567 deletions(-)
>  create mode 100644 monitor/core.c
> 
> diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h
> index 8547529e49..b9f8d175ed 100644
> --- a/include/monitor/monitor.h
> +++ b/include/monitor/monitor.h
> @@ -20,6 +20,7 @@ typedef struct MonitorHMP MonitorHMP;
>  bool monitor_cur_is_qmp(void);
>  
>  void monitor_init_globals(void);
> +void monitor_init_globals_core(void);
>  void monitor_init(Chardev *chr, int flags);
>  void monitor_init_qmp(Chardev *chr, int flags);
>  void monitor_init_hmp(Chardev *chr, int flags);
> diff --git a/monitor/monitor_int.h b/monitor/monitor_int.h
> index 8c5d95f942..1a7af6a223 100644
> --- a/monitor/monitor_int.h
> +++ b/monitor/monitor_int.h
> @@ -190,6 +190,7 @@ extern mon_cmd_t mon_cmds[];
>  int monitor_puts(Monitor *mon, const char *str);
>  void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
>                         bool use_io_thread);
> +void monitor_data_destroy(Monitor *mon);
>  int monitor_can_read(void *opaque);
>  void monitor_list_append(Monitor *mon);
>  void monitor_fdsets_cleanup(void);
> diff --git a/monitor/core.c b/monitor/core.c
> new file mode 100644
> index 0000000000..1cea56054b
> --- /dev/null
> +++ b/monitor/core.c
> @@ -0,0 +1,604 @@
> +/*
> + * 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 "qemu/osdep.h"
> +#include "monitor_int.h"
> +
> +#include "qapi/error.h"
> +#include "qapi/qapi-emit-events.h"
> +#include "qapi/qmp/qstring.h"
> +
> +#include "qemu/option.h"
> +#include "sysemu/qtest.h"
> +
> +#include "trace-root.h"
> +
> +/*
> + * To prevent flooding clients, events can be throttled. The
> + * throttling is calculated globally, rather than per-Monitor
> + * instance.
> + */
> +typedef struct MonitorQAPIEventState {
> +    QAPIEvent event;    /* Throttling state for this event type and... */
> +    QDict *data;        /* ... data, see qapi_event_throttle_equal() */
> +    QEMUTimer *timer;   /* Timer for handling delayed events */
> +    QDict *qdict;       /* Delayed event (if any) */
> +} MonitorQAPIEventState;
> +
> +typedef struct {
> +    int64_t rate;       /* Minimum time (in ns) between two events */
> +} MonitorQAPIEventConf;
> +
> +/* Shared monitor I/O thread */
> +IOThread *mon_iothread;
> +
> +/* Bottom half to dispatch the requests received from I/O thread */
> +QEMUBH *qmp_dispatcher_bh;
> +
> +/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */
> +QemuMutex monitor_lock;
> +static GHashTable *monitor_qapi_event_state;
> +
> +MonitorList mon_list;
> +int mon_refcount;
> +static bool monitor_destroyed;
> +
> +/**
> + * Is @mon is using readline?
> + * Note: not all HMP monitors use readline, e.g., gdbserver has a
> + * non-interactive HMP monitor, so readline is not used there.
> + */
> +static inline bool monitor_uses_readline(const Monitor *mon)
> +{
> +    return mon->flags & MONITOR_USE_READLINE;
> +}
> +
> +static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
> +{
> +    return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
> +}
> +
> +static void monitor_flush_locked(Monitor *mon);
> +
> +static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
> +                                  void *opaque)
> +{
> +    Monitor *mon = opaque;
> +
> +    qemu_mutex_lock(&mon->mon_lock);
> +    mon->out_watch = 0;
> +    monitor_flush_locked(mon);
> +    qemu_mutex_unlock(&mon->mon_lock);
> +    return FALSE;
> +}
> +
> +/* Caller must hold mon->mon_lock */
> +static void monitor_flush_locked(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 < 0 && errno != EAGAIN) || (rc == len)) {
> +            /* all flushed or error */
> +            qobject_unref(mon->outbuf);
> +            mon->outbuf = qstring_new();
> +            return;
> +        }
> +        if (rc > 0) {
> +            /* partial write */
> +            QString *tmp = qstring_from_str(buf + rc);
> +            qobject_unref(mon->outbuf);
> +            mon->outbuf = tmp;
> +        }
> +        if (mon->out_watch == 0) {
> +            mon->out_watch =
> +                qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
> +                                      monitor_unblocked, mon);
> +        }
> +    }
> +}
> +
> +void monitor_flush(Monitor *mon)
> +{
> +    qemu_mutex_lock(&mon->mon_lock);
> +    monitor_flush_locked(mon);
> +    qemu_mutex_unlock(&mon->mon_lock);
> +}
> +
> +/* flush at every end of line */
> +int monitor_puts(Monitor *mon, const char *str)
> +{
> +    int i;
> +    char c;
> +
> +    qemu_mutex_lock(&mon->mon_lock);
> +    for (i = 0; str[i]; i++) {
> +        c = str[i];
> +        if (c == '\n') {
> +            qstring_append_chr(mon->outbuf, '\r');
> +        }
> +        qstring_append_chr(mon->outbuf, c);
> +        if (c == '\n') {
> +            monitor_flush_locked(mon);
> +        }
> +    }
> +    qemu_mutex_unlock(&mon->mon_lock);
> +
> +    return i;
> +}
> +
> +int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
> +{
> +    char *buf;
> +    int n;
> +
> +    if (!mon)
> +        return -1;
> +
> +    if (monitor_is_qmp(mon)) {
> +        return -1;
> +    }
> +
> +    buf = g_strdup_vprintf(fmt, ap);
> +    n = monitor_puts(mon, buf);
> +    g_free(buf);
> +    return n;
> +}
> +
> +int monitor_printf(Monitor *mon, const char *fmt, ...)
> +{
> +    int ret;
> +
> +    va_list ap;
> +    va_start(ap, fmt);
> +    ret = monitor_vprintf(mon, fmt, ap);
> +    va_end(ap);
> +    return ret;
> +}
> +
> +
> +static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
> +    /* Limit guest-triggerable events to 1 per second */
> +    [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
> +    [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
> +    [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
> +    [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
> +    [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
> +    [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
> +};
> +
> +/*
> + * Return the clock to use for recording an event's time.
> + * It's QEMU_CLOCK_REALTIME, except for qtests it's
> + * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
> + * Beware: result is invalid before configure_accelerator().
> + */
> +static inline QEMUClockType monitor_get_event_clock(void)
> +{
> +    return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
> +}
> +
> +/*
> + * Broadcast an event to all monitors.
> + * @qdict is the event object.  Its member "event" must match @event.
> + * Caller must hold monitor_lock.
> + */
> +static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
> +{
> +    Monitor *mon;
> +    MonitorQMP *qmp_mon;
> +
> +    trace_monitor_protocol_event_emit(event, qdict);
> +    QTAILQ_FOREACH(mon, &mon_list, entry) {
> +        if (!monitor_is_qmp(mon)) {
> +            continue;
> +        }
> +
> +        qmp_mon = container_of(mon, MonitorQMP, common);
> +        if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
> +            qmp_send_response(qmp_mon, qdict);
> +        }
> +    }
> +}
> +
> +static void monitor_qapi_event_handler(void *opaque);
> +
> +/*
> + * Queue a new event for emission to Monitor instances,
> + * applying any rate limiting if required.
> + */
> +static void
> +monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
> +{
> +    MonitorQAPIEventConf *evconf;
> +    MonitorQAPIEventState *evstate;
> +
> +    assert(event < QAPI_EVENT__MAX);
> +    evconf = &monitor_qapi_event_conf[event];
> +    trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
> +
> +    qemu_mutex_lock(&monitor_lock);
> +
> +    if (!evconf->rate) {
> +        /* Unthrottled event */
> +        monitor_qapi_event_emit(event, qdict);
> +    } else {
> +        QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
> +        MonitorQAPIEventState key = { .event = event, .data = data };
> +
> +        evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
> +        assert(!evstate || timer_pending(evstate->timer));
> +
> +        if (evstate) {
> +            /*
> +             * Timer is pending for (at least) evconf->rate ns after
> +             * last send.  Store event for sending when timer fires,
> +             * replacing a prior stored event if any.
> +             */
> +            qobject_unref(evstate->qdict);
> +            evstate->qdict = qobject_ref(qdict);
> +        } else {
> +            /*
> +             * Last send was (at least) evconf->rate ns ago.
> +             * Send immediately, and arm the timer to call
> +             * monitor_qapi_event_handler() in evconf->rate ns.  Any
> +             * events arriving before then will be delayed until then.
> +             */
> +            int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
> +
> +            monitor_qapi_event_emit(event, qdict);
> +
> +            evstate = g_new(MonitorQAPIEventState, 1);
> +            evstate->event = event;
> +            evstate->data = qobject_ref(data);
> +            evstate->qdict = NULL;
> +            evstate->timer = timer_new_ns(monitor_get_event_clock(),
> +                                          monitor_qapi_event_handler,
> +                                          evstate);
> +            g_hash_table_add(monitor_qapi_event_state, evstate);
> +            timer_mod_ns(evstate->timer, now + evconf->rate);
> +        }
> +    }
> +
> +    qemu_mutex_unlock(&monitor_lock);
> +}
> +
> +void qapi_event_emit(QAPIEvent event, QDict *qdict)
> +{
> +    /*
> +     * monitor_qapi_event_queue_no_reenter() is not reentrant: it
> +     * would deadlock on monitor_lock.  Work around by queueing
> +     * events in thread-local storage.
> +     * TODO: remove this, make it re-enter safe.
> +     */
> +    typedef struct MonitorQapiEvent {
> +        QAPIEvent event;
> +        QDict *qdict;
> +        QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
> +    } MonitorQapiEvent;
> +    static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
> +    static __thread bool reentered;
> +    MonitorQapiEvent *ev;
> +
> +    if (!reentered) {
> +        QSIMPLEQ_INIT(&event_queue);
> +    }
> +
> +    ev = g_new(MonitorQapiEvent, 1);
> +    ev->qdict = qobject_ref(qdict);
> +    ev->event = event;
> +    QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
> +    if (reentered) {
> +        return;
> +    }
> +
> +    reentered = true;
> +
> +    while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
> +        QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
> +        monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
> +        qobject_unref(ev->qdict);
> +        g_free(ev);
> +    }
> +
> +    reentered = false;
> +}
> +
> +/*
> + * This function runs evconf->rate ns after sending a throttled
> + * event.
> + * If another event has since been stored, send it.
> + */
> +static void monitor_qapi_event_handler(void *opaque)
> +{
> +    MonitorQAPIEventState *evstate = opaque;
> +    MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
> +
> +    trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
> +    qemu_mutex_lock(&monitor_lock);
> +
> +    if (evstate->qdict) {
> +        int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
> +
> +        monitor_qapi_event_emit(evstate->event, evstate->qdict);
> +        qobject_unref(evstate->qdict);
> +        evstate->qdict = NULL;
> +        timer_mod_ns(evstate->timer, now + evconf->rate);
> +    } else {
> +        g_hash_table_remove(monitor_qapi_event_state, evstate);
> +        qobject_unref(evstate->data);
> +        timer_free(evstate->timer);
> +        g_free(evstate);
> +    }
> +
> +    qemu_mutex_unlock(&monitor_lock);
> +}
> +
> +static unsigned int qapi_event_throttle_hash(const void *key)
> +{
> +    const MonitorQAPIEventState *evstate = key;
> +    unsigned int hash = evstate->event * 255;
> +
> +    if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
> +        hash += g_str_hash(qdict_get_str(evstate->data, "id"));
> +    }
> +
> +    if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
> +        hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
> +    }
> +
> +    return hash;
> +}
> +
> +static gboolean qapi_event_throttle_equal(const void *a, const void *b)
> +{
> +    const MonitorQAPIEventState *eva = a;
> +    const MonitorQAPIEventState *evb = b;
> +
> +    if (eva->event != evb->event) {
> +        return FALSE;
> +    }
> +
> +    if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
> +        return !strcmp(qdict_get_str(eva->data, "id"),
> +                       qdict_get_str(evb->data, "id"));
> +    }
> +
> +    if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
> +        return !strcmp(qdict_get_str(eva->data, "node-name"),
> +                       qdict_get_str(evb->data, "node-name"));
> +    }
> +
> +    return TRUE;
> +}
> +
> +int monitor_suspend(Monitor *mon)
> +{
> +    if (monitor_is_hmp_non_interactive(mon)) {
> +        return -ENOTTY;
> +    }
> +
> +    atomic_inc(&mon->suspend_cnt);
> +
> +    if (mon->use_io_thread) {
> +        /*
> +         * Kick I/O thread to make sure this takes effect.  It'll be
> +         * evaluated again in prepare() of the watch object.
> +         */
> +        aio_notify(iothread_get_aio_context(mon_iothread));
> +    }
> +
> +    trace_monitor_suspend(mon, 1);
> +    return 0;
> +}
> +
> +static void monitor_accept_input(void *opaque)
> +{
> +    Monitor *mon = opaque;
> +
> +    qemu_chr_fe_accept_input(&mon->chr);
> +}
> +
> +void monitor_resume(Monitor *mon)
> +{
> +    if (monitor_is_hmp_non_interactive(mon)) {
> +        return;
> +    }
> +
> +    if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
> +        AioContext *ctx;
> +
> +        if (mon->use_io_thread) {
> +            ctx = iothread_get_aio_context(mon_iothread);
> +        } else {
> +            ctx = qemu_get_aio_context();
> +        }
> +
> +        if (!monitor_is_qmp(mon)) {
> +            MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
> +            assert(hmp_mon->rs);
> +            readline_show_prompt(hmp_mon->rs);
> +        }
> +
> +        aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
> +    }
> +
> +    trace_monitor_suspend(mon, -1);
> +}
> +
> +int monitor_can_read(void *opaque)
> +{
> +    Monitor *mon = opaque;
> +
> +    return !atomic_mb_read(&mon->suspend_cnt);
> +}
> +
> +void monitor_list_append(Monitor *mon)
> +{
> +    qemu_mutex_lock(&monitor_lock);
> +    /*
> +     * This prevents inserting new monitors during monitor_cleanup().
> +     * A cleaner solution would involve the main thread telling other
> +     * threads to terminate, waiting for their termination.
> +     */
> +    if (!monitor_destroyed) {
> +        QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
> +        mon = NULL;
> +    }
> +    qemu_mutex_unlock(&monitor_lock);
> +
> +    if (mon) {
> +        monitor_data_destroy(mon);
> +        g_free(mon);
> +    }
> +}
> +
> +static void monitor_iothread_init(void)
> +{
> +    mon_iothread = iothread_create("mon_iothread", &error_abort);
> +}
> +
> +void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
> +                       bool use_io_thread)
> +{
> +    if (use_io_thread && !mon_iothread) {
> +        monitor_iothread_init();
> +    }
> +    memset(mon, 0, sizeof(Monitor));
> +    qemu_mutex_init(&mon->mon_lock);
> +    mon->outbuf = qstring_new();
> +    mon->skip_flush = skip_flush;
> +    mon->use_io_thread = use_io_thread;
> +    mon->flags = flags;
> +}
> +
> +void monitor_data_destroy(Monitor *mon)
> +{
> +    g_free(mon->mon_cpu_path);
> +    qemu_chr_fe_deinit(&mon->chr, false);
> +    if (monitor_is_qmp(mon)) {
> +        MonitorQMP *qmp_mon = container_of(mon, MonitorQMP, common);
> +        monitor_data_destroy_qmp(qmp_mon);
> +    } else {
> +        MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
> +        readline_free(hmp_mon->rs);
> +    }
> +    qobject_unref(mon->outbuf);
> +    qemu_mutex_destroy(&mon->mon_lock);
> +}
> +
> +void monitor_init(Chardev *chr, int flags)
> +{
> +    if (flags & MONITOR_USE_CONTROL) {
> +        monitor_init_qmp(chr, flags);
> +    } else {
> +        monitor_init_hmp(chr, flags);
> +    }
> +}
> +
> +void monitor_cleanup(void)
> +{
> +    /*
> +     * We need to explicitly stop the I/O thread (but not destroy it),
> +     * clean up the monitor resources, then destroy the I/O thread since
> +     * we need to unregister from chardev below in
> +     * monitor_data_destroy(), and chardev is not thread-safe yet
> +     */
> +    if (mon_iothread) {
> +        iothread_stop(mon_iothread);
> +    }
> +
> +    /* Flush output buffers and destroy monitors */
> +    qemu_mutex_lock(&monitor_lock);
> +    monitor_destroyed = true;
> +    while (!QTAILQ_EMPTY(&mon_list)) {
> +        Monitor *mon = QTAILQ_FIRST(&mon_list);
> +        QTAILQ_REMOVE(&mon_list, mon, entry);
> +        /* Permit QAPI event emission from character frontend release */
> +        qemu_mutex_unlock(&monitor_lock);
> +        monitor_flush(mon);
> +        monitor_data_destroy(mon);
> +        qemu_mutex_lock(&monitor_lock);
> +        g_free(mon);
> +    }
> +    qemu_mutex_unlock(&monitor_lock);
> +
> +    /* QEMUBHs needs to be deleted before destroying the I/O thread */
> +    qemu_bh_delete(qmp_dispatcher_bh);
> +    qmp_dispatcher_bh = NULL;
> +    if (mon_iothread) {
> +        iothread_destroy(mon_iothread);
> +        mon_iothread = NULL;
> +    }
> +}
> +
> +static void monitor_qapi_event_init(void)
> +{
> +    monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
> +                                                qapi_event_throttle_equal);
> +}
> +
> +void monitor_init_globals_core(void)
> +{
> +    monitor_qapi_event_init();
> +    qemu_mutex_init(&monitor_lock);
> +
> +    /*
> +     * The dispatcher BH must run in the main loop thread, since we
> +     * have commands assuming that context.  It would be nice to get
> +     * rid of those assumptions.
> +     */
> +    qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
> +                                   monitor_qmp_bh_dispatcher,
> +                                   NULL);
> +}
> +
> +QemuOptsList qemu_mon_opts = {
> +    .name = "mon",
> +    .implied_opt_name = "chardev",
> +    .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
> +    .desc = {
> +        {
> +            .name = "mode",
> +            .type = QEMU_OPT_STRING,
> +        },{
> +            .name = "chardev",
> +            .type = QEMU_OPT_STRING,
> +        },{
> +            .name = "pretty",
> +            .type = QEMU_OPT_BOOL,
> +        },
> +        { /* end of list */ }
> +    },
> +};
> diff --git a/monitor/misc.c b/monitor/misc.c
> index 408d11e1fe..1f60f31c95 100644
> --- a/monitor/misc.c
> +++ b/monitor/misc.c
> @@ -117,43 +117,13 @@ struct MonFdset {
>      QLIST_ENTRY(MonFdset) next;
>  };
>  
> -/*
> - * To prevent flooding clients, events can be throttled. The
> - * throttling is calculated globally, rather than per-Monitor
> - * instance.
> - */
> -typedef struct MonitorQAPIEventState {
> -    QAPIEvent event;    /* Throttling state for this event type and... */
> -    QDict *data;        /* ... data, see qapi_event_throttle_equal() */
> -    QEMUTimer *timer;   /* Timer for handling delayed events */
> -    QDict *qdict;       /* Delayed event (if any) */
> -} MonitorQAPIEventState;
> -
> -typedef struct {
> -    int64_t rate;       /* Minimum time (in ns) between two events */
> -} MonitorQAPIEventConf;
> -
> -/* Shared monitor I/O thread */
> -IOThread *mon_iothread;
> -
> -/* Bottom half to dispatch the requests received from I/O thread */
> -QEMUBH *qmp_dispatcher_bh;
> -
>  /* QMP checker flags */
>  #define QMP_ACCEPT_UNKNOWNS 1
>  
> -/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */
> -QemuMutex monitor_lock;
> -static GHashTable *monitor_qapi_event_state;
> -MonitorList mon_list;
> -static bool monitor_destroyed;
> -
>  /* Protects mon_fdsets */
>  static QemuMutex mon_fdsets_lock;
>  static QLIST_HEAD(, MonFdset) mon_fdsets;
>  
> -int mon_refcount;
> -
>  static mon_cmd_t info_cmds[];
>  
>  __thread Monitor *cur_mon;
> @@ -161,32 +131,6 @@ __thread Monitor *cur_mon;
>  static void monitor_command_cb(void *opaque, const char *cmdline,
>                                 void *readline_opaque);
>  
> -/**
> - * Is @mon is using readline?
> - * Note: not all HMP monitors use readline, e.g., gdbserver has a
> - * non-interactive HMP monitor, so readline is not used there.
> - */
> -static inline bool monitor_uses_readline(const Monitor *mon)
> -{
> -    return mon->flags & MONITOR_USE_READLINE;
> -}
> -
> -static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
> -{
> -    return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
> -}
> -
> -/*
> - * Return the clock to use for recording an event's time.
> - * It's QEMU_CLOCK_REALTIME, except for qtests it's
> - * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
> - * Beware: result is invalid before configure_accelerator().
> - */
> -static inline QEMUClockType monitor_get_event_clock(void)
> -{
> -    return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
> -}
> -
>  /**
>   * Is the current monitor, if any, a QMP monitor?
>   */
> @@ -220,355 +164,6 @@ int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
>  }
>  
>  
> -static void monitor_flush_locked(Monitor *mon);
> -
> -static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
> -                                  void *opaque)
> -{
> -    Monitor *mon = opaque;
> -
> -    qemu_mutex_lock(&mon->mon_lock);
> -    mon->out_watch = 0;
> -    monitor_flush_locked(mon);
> -    qemu_mutex_unlock(&mon->mon_lock);
> -    return FALSE;
> -}
> -
> -/* Caller must hold mon->mon_lock */
> -static void monitor_flush_locked(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 < 0 && errno != EAGAIN) || (rc == len)) {
> -            /* all flushed or error */
> -            qobject_unref(mon->outbuf);
> -            mon->outbuf = qstring_new();
> -            return;
> -        }
> -        if (rc > 0) {
> -            /* partial write */
> -            QString *tmp = qstring_from_str(buf + rc);
> -            qobject_unref(mon->outbuf);
> -            mon->outbuf = tmp;
> -        }
> -        if (mon->out_watch == 0) {
> -            mon->out_watch =
> -                qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
> -                                      monitor_unblocked, mon);
> -        }
> -    }
> -}
> -
> -void monitor_flush(Monitor *mon)
> -{
> -    qemu_mutex_lock(&mon->mon_lock);
> -    monitor_flush_locked(mon);
> -    qemu_mutex_unlock(&mon->mon_lock);
> -}
> -
> -/* flush at every end of line */
> -int monitor_puts(Monitor *mon, const char *str)
> -{
> -    int i;
> -    char c;
> -
> -    qemu_mutex_lock(&mon->mon_lock);
> -    for (i = 0; str[i]; i++) {
> -        c = str[i];
> -        if (c == '\n') {
> -            qstring_append_chr(mon->outbuf, '\r');
> -        }
> -        qstring_append_chr(mon->outbuf, c);
> -        if (c == '\n') {
> -            monitor_flush_locked(mon);
> -        }
> -    }
> -    qemu_mutex_unlock(&mon->mon_lock);
> -
> -    return i;
> -}
> -
> -int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
> -{
> -    char *buf;
> -    int n;
> -
> -    if (!mon)
> -        return -1;
> -
> -    if (monitor_is_qmp(mon)) {
> -        return -1;
> -    }
> -
> -    buf = g_strdup_vprintf(fmt, ap);
> -    n = monitor_puts(mon, buf);
> -    g_free(buf);
> -    return n;
> -}
> -
> -int monitor_printf(Monitor *mon, const char *fmt, ...)
> -{
> -    int ret;
> -
> -    va_list ap;
> -    va_start(ap, fmt);
> -    ret = monitor_vprintf(mon, fmt, ap);
> -    va_end(ap);
> -    return ret;
> -}
> -
> -static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
> -    /* Limit guest-triggerable events to 1 per second */
> -    [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
> -    [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
> -    [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
> -    [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
> -    [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
> -    [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
> -};
> -
> -/*
> - * Broadcast an event to all monitors.
> - * @qdict is the event object.  Its member "event" must match @event.
> - * Caller must hold monitor_lock.
> - */
> -static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
> -{
> -    Monitor *mon;
> -    MonitorQMP *qmp_mon;
> -
> -    trace_monitor_protocol_event_emit(event, qdict);
> -    QTAILQ_FOREACH(mon, &mon_list, entry) {
> -        if (!monitor_is_qmp(mon)) {
> -            continue;
> -        }
> -
> -        qmp_mon = container_of(mon, MonitorQMP, common);
> -        if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
> -            qmp_send_response(qmp_mon, qdict);
> -        }
> -    }
> -}
> -
> -static void monitor_qapi_event_handler(void *opaque);
> -
> -/*
> - * Queue a new event for emission to Monitor instances,
> - * applying any rate limiting if required.
> - */
> -static void
> -monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
> -{
> -    MonitorQAPIEventConf *evconf;
> -    MonitorQAPIEventState *evstate;
> -
> -    assert(event < QAPI_EVENT__MAX);
> -    evconf = &monitor_qapi_event_conf[event];
> -    trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
> -
> -    qemu_mutex_lock(&monitor_lock);
> -
> -    if (!evconf->rate) {
> -        /* Unthrottled event */
> -        monitor_qapi_event_emit(event, qdict);
> -    } else {
> -        QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
> -        MonitorQAPIEventState key = { .event = event, .data = data };
> -
> -        evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
> -        assert(!evstate || timer_pending(evstate->timer));
> -
> -        if (evstate) {
> -            /*
> -             * Timer is pending for (at least) evconf->rate ns after
> -             * last send.  Store event for sending when timer fires,
> -             * replacing a prior stored event if any.
> -             */
> -            qobject_unref(evstate->qdict);
> -            evstate->qdict = qobject_ref(qdict);
> -        } else {
> -            /*
> -             * Last send was (at least) evconf->rate ns ago.
> -             * Send immediately, and arm the timer to call
> -             * monitor_qapi_event_handler() in evconf->rate ns.  Any
> -             * events arriving before then will be delayed until then.
> -             */
> -            int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
> -
> -            monitor_qapi_event_emit(event, qdict);
> -
> -            evstate = g_new(MonitorQAPIEventState, 1);
> -            evstate->event = event;
> -            evstate->data = qobject_ref(data);
> -            evstate->qdict = NULL;
> -            evstate->timer = timer_new_ns(monitor_get_event_clock(),
> -                                          monitor_qapi_event_handler,
> -                                          evstate);
> -            g_hash_table_add(monitor_qapi_event_state, evstate);
> -            timer_mod_ns(evstate->timer, now + evconf->rate);
> -        }
> -    }
> -
> -    qemu_mutex_unlock(&monitor_lock);
> -}
> -
> -void qapi_event_emit(QAPIEvent event, QDict *qdict)
> -{
> -    /*
> -     * monitor_qapi_event_queue_no_reenter() is not reentrant: it
> -     * would deadlock on monitor_lock.  Work around by queueing
> -     * events in thread-local storage.
> -     * TODO: remove this, make it re-enter safe.
> -     */
> -    typedef struct MonitorQapiEvent {
> -        QAPIEvent event;
> -        QDict *qdict;
> -        QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
> -    } MonitorQapiEvent;
> -    static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
> -    static __thread bool reentered;
> -    MonitorQapiEvent *ev;
> -
> -    if (!reentered) {
> -        QSIMPLEQ_INIT(&event_queue);
> -    }
> -
> -    ev = g_new(MonitorQapiEvent, 1);
> -    ev->qdict = qobject_ref(qdict);
> -    ev->event = event;
> -    QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
> -    if (reentered) {
> -        return;
> -    }
> -
> -    reentered = true;
> -
> -    while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
> -        QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
> -        monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
> -        qobject_unref(ev->qdict);
> -        g_free(ev);
> -    }
> -
> -    reentered = false;
> -}
> -
> -/*
> - * This function runs evconf->rate ns after sending a throttled
> - * event.
> - * If another event has since been stored, send it.
> - */
> -static void monitor_qapi_event_handler(void *opaque)
> -{
> -    MonitorQAPIEventState *evstate = opaque;
> -    MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
> -
> -    trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
> -    qemu_mutex_lock(&monitor_lock);
> -
> -    if (evstate->qdict) {
> -        int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
> -
> -        monitor_qapi_event_emit(evstate->event, evstate->qdict);
> -        qobject_unref(evstate->qdict);
> -        evstate->qdict = NULL;
> -        timer_mod_ns(evstate->timer, now + evconf->rate);
> -    } else {
> -        g_hash_table_remove(monitor_qapi_event_state, evstate);
> -        qobject_unref(evstate->data);
> -        timer_free(evstate->timer);
> -        g_free(evstate);
> -    }
> -
> -    qemu_mutex_unlock(&monitor_lock);
> -}
> -
> -static unsigned int qapi_event_throttle_hash(const void *key)
> -{
> -    const MonitorQAPIEventState *evstate = key;
> -    unsigned int hash = evstate->event * 255;
> -
> -    if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
> -        hash += g_str_hash(qdict_get_str(evstate->data, "id"));
> -    }
> -
> -    if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
> -        hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
> -    }
> -
> -    return hash;
> -}
> -
> -static gboolean qapi_event_throttle_equal(const void *a, const void *b)
> -{
> -    const MonitorQAPIEventState *eva = a;
> -    const MonitorQAPIEventState *evb = b;
> -
> -    if (eva->event != evb->event) {
> -        return FALSE;
> -    }
> -
> -    if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
> -        return !strcmp(qdict_get_str(eva->data, "id"),
> -                       qdict_get_str(evb->data, "id"));
> -    }
> -
> -    if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
> -        return !strcmp(qdict_get_str(eva->data, "node-name"),
> -                       qdict_get_str(evb->data, "node-name"));
> -    }
> -
> -    return TRUE;
> -}
> -
> -static void monitor_qapi_event_init(void)
> -{
> -    monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
> -                                                qapi_event_throttle_equal);
> -}
> -
> -static void monitor_iothread_init(void);
> -
> -void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
> -                       bool use_io_thread)
> -{
> -    if (use_io_thread && !mon_iothread) {
> -        monitor_iothread_init();
> -    }
> -    memset(mon, 0, sizeof(Monitor));
> -    qemu_mutex_init(&mon->mon_lock);
> -    mon->outbuf = qstring_new();
> -    mon->skip_flush = skip_flush;
> -    mon->use_io_thread = use_io_thread;
> -    mon->flags = flags;
> -}
> -
> -static void monitor_data_destroy(Monitor *mon)
> -{
> -    g_free(mon->mon_cpu_path);
> -    qemu_chr_fe_deinit(&mon->chr, false);
> -    if (monitor_is_qmp(mon)) {
> -        MonitorQMP *qmp_mon = container_of(mon, MonitorQMP, common);
> -        monitor_data_destroy_qmp(qmp_mon);
> -    } else {
> -        MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
> -        readline_free(hmp_mon->rs);
> -    }
> -    qobject_unref(mon->outbuf);
> -    qemu_mutex_destroy(&mon->mon_lock);
> -}
> -
>  char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
>                                  int64_t cpu_index, Error **errp)
>  {
> @@ -2738,13 +2333,6 @@ void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
>      }
>  }
>  
> -int monitor_can_read(void *opaque)
> -{
> -    Monitor *mon = opaque;
> -
> -    return !atomic_mb_read(&mon->suspend_cnt);
> -}
> -
>  static void monitor_command_cb(void *opaque, const char *cmdline,
>                                 void *readline_opaque)
>  {
> @@ -2755,60 +2343,6 @@ static void monitor_command_cb(void *opaque, const char *cmdline,
>      monitor_resume(&mon->common);
>  }
>  
> -int monitor_suspend(Monitor *mon)
> -{
> -    if (monitor_is_hmp_non_interactive(mon)) {
> -        return -ENOTTY;
> -    }
> -
> -    atomic_inc(&mon->suspend_cnt);
> -
> -    if (mon->use_io_thread) {
> -        /*
> -         * Kick I/O thread to make sure this takes effect.  It'll be
> -         * evaluated again in prepare() of the watch object.
> -         */
> -        aio_notify(iothread_get_aio_context(mon_iothread));
> -    }
> -
> -    trace_monitor_suspend(mon, 1);
> -    return 0;
> -}
> -
> -static void monitor_accept_input(void *opaque)
> -{
> -    Monitor *mon = opaque;
> -
> -    qemu_chr_fe_accept_input(&mon->chr);
> -}
> -
> -void monitor_resume(Monitor *mon)
> -{
> -    if (monitor_is_hmp_non_interactive(mon)) {
> -        return;
> -    }
> -
> -    if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
> -        AioContext *ctx;
> -
> -        if (mon->use_io_thread) {
> -            ctx = iothread_get_aio_context(mon_iothread);
> -        } else {
> -            ctx = qemu_get_aio_context();
> -        }
> -
> -        if (!monitor_is_qmp(mon)) {
> -            MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
> -            assert(hmp_mon->rs);
> -            readline_show_prompt(hmp_mon->rs);
> -        }
> -
> -        aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
> -    }
> -
> -    trace_monitor_suspend(mon, -1);
> -}
> -
>  static int
>  compare_mon_cmd(const void *a, const void *b)
>  {
> @@ -2828,27 +2362,12 @@ static void sortcmdlist(void)
>      qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
>  }
>  
> -static void monitor_iothread_init(void)
> -{
> -    mon_iothread = iothread_create("mon_iothread", &error_abort);
> -}
> -
>  void monitor_init_globals(void)
>  {
> +    monitor_init_globals_core();
>      monitor_init_qmp_commands();
> -    monitor_qapi_event_init();
>      sortcmdlist();
> -    qemu_mutex_init(&monitor_lock);
>      qemu_mutex_init(&mon_fdsets_lock);
> -
> -    /*
> -     * The dispatcher BH must run in the main loop thread, since we
> -     * have commands assuming that context.  It would be nice to get
> -     * rid of those assumptions.
> -     */
> -    qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
> -                                   monitor_qmp_bh_dispatcher,
> -                                   NULL);
>  }
>  
>  /*
> @@ -2873,90 +2392,6 @@ int error_vprintf_unless_qmp(const char *fmt, va_list ap)
>      return -1;
>  }
>  
> -void monitor_list_append(Monitor *mon)
> -{
> -    qemu_mutex_lock(&monitor_lock);
> -    /*
> -     * This prevents inserting new monitors during monitor_cleanup().
> -     * A cleaner solution would involve the main thread telling other
> -     * threads to terminate, waiting for their termination.
> -     */
> -    if (!monitor_destroyed) {
> -        QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
> -        mon = NULL;
> -    }
> -    qemu_mutex_unlock(&monitor_lock);
> -
> -    if (mon) {
> -        monitor_data_destroy(mon);
> -        g_free(mon);
> -    }
> -}
> -
> -void monitor_init(Chardev *chr, int flags)
> -{
> -    if (flags & MONITOR_USE_CONTROL) {
> -        monitor_init_qmp(chr, flags);
> -    } else {
> -        monitor_init_hmp(chr, flags);
> -    }
> -}
> -
> -void monitor_cleanup(void)
> -{
> -    /*
> -     * We need to explicitly stop the I/O thread (but not destroy it),
> -     * clean up the monitor resources, then destroy the I/O thread since
> -     * we need to unregister from chardev below in
> -     * monitor_data_destroy(), and chardev is not thread-safe yet
> -     */
> -    if (mon_iothread) {
> -        iothread_stop(mon_iothread);
> -    }
> -
> -    /* Flush output buffers and destroy monitors */
> -    qemu_mutex_lock(&monitor_lock);
> -    monitor_destroyed = true;
> -    while (!QTAILQ_EMPTY(&mon_list)) {
> -        Monitor *mon = QTAILQ_FIRST(&mon_list);
> -        QTAILQ_REMOVE(&mon_list, mon, entry);
> -        /* Permit QAPI event emission from character frontend release */
> -        qemu_mutex_unlock(&monitor_lock);
> -        monitor_flush(mon);
> -        monitor_data_destroy(mon);
> -        qemu_mutex_lock(&monitor_lock);
> -        g_free(mon);
> -    }
> -    qemu_mutex_unlock(&monitor_lock);
> -
> -    /* QEMUBHs needs to be deleted before destroying the I/O thread */
> -    qemu_bh_delete(qmp_dispatcher_bh);
> -    qmp_dispatcher_bh = NULL;
> -    if (mon_iothread) {
> -        iothread_destroy(mon_iothread);
> -        mon_iothread = NULL;
> -    }
> -}
> -
> -QemuOptsList qemu_mon_opts = {
> -    .name = "mon",
> -    .implied_opt_name = "chardev",
> -    .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
> -    .desc = {
> -        {
> -            .name = "mode",
> -            .type = QEMU_OPT_STRING,
> -        },{
> -            .name = "chardev",
> -            .type = QEMU_OPT_STRING,
> -        },{
> -            .name = "pretty",
> -            .type = QEMU_OPT_BOOL,
> -        },
> -        { /* end of list */ }
> -    },
> -};
> -
>  HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
>  {
>      MachineState *ms = MACHINE(qdev_get_machine());
> diff --git a/monitor/Makefile.objs b/monitor/Makefile.objs
> index 48c73eed51..c8dff5e4b5 100644
> --- a/monitor/Makefile.objs
> +++ b/monitor/Makefile.objs
> @@ -1,2 +1,2 @@
>  obj-y += misc.o
> -common-obj-y += qmp.o hmp.o
> +common-obj-y += core.o qmp.o hmp.o
> -- 
> 2.20.1
> 
--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK
Dr. David Alan Gilbert June 7, 2019, 5:30 p.m. UTC | #2
Oh, can you also fix up the paths in writing-qmp-commands.txt?

Thanks for this split!

Dave

--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK
Kevin Wolf June 11, 2019, 9:22 a.m. UTC | #3
Am 07.06.2019 um 19:29 hat Dr. David Alan Gilbert geschrieben:
> * Kevin Wolf (kwolf@redhat.com) wrote:
> > Move the monitor core infrastructure from monitor/misc.c to
> > monitor/core.c. This is code that can be shared for all targets, so
> > compile it only once.
> > 
> > What remains in monitor/misc.c after this patch is mostly monitor
> > command implementations and code that requires a system emulator or is
> > even target-dependent.
> > 
> > The amount of function and particularly extern variables in
> > monitor_int.h is probably a bit larger than it needs to be, but this way
> > no non-trivial code modifications are needed. The interfaces between all
> > monitor parts can be cleaned up later.
> > 
> > Signed-off-by: Kevin Wolf <kwolf@redhat.com>
> 
> OK, but can you call it anything other than core.* - I regularly end up
> deleting things like that!

Oh, I didn't even think of this kind of core.*!

I imagine in practice it wouldn't be so bad to have a monitor/core.c
because it's in a subdirectory, and it's under version control anyway.
We already seem to have quite a few of them in subdirectories:

    ./hw/acpi/core.c
    ./hw/bt/core.c
    ./hw/cpu/core.c
    ./hw/i2c/core.c
    ./hw/ide/core.c
    ./hw/sd/core.c
    ./hw/usb/core.c

But I'll gladly rename it if I can find a good name. Do you have any
suggestions? Maybe just monitor/monitor.c?

Kevin
Dr. David Alan Gilbert June 11, 2019, 9:25 a.m. UTC | #4
* Kevin Wolf (kwolf@redhat.com) wrote:
> Am 07.06.2019 um 19:29 hat Dr. David Alan Gilbert geschrieben:
> > * Kevin Wolf (kwolf@redhat.com) wrote:
> > > Move the monitor core infrastructure from monitor/misc.c to
> > > monitor/core.c. This is code that can be shared for all targets, so
> > > compile it only once.
> > > 
> > > What remains in monitor/misc.c after this patch is mostly monitor
> > > command implementations and code that requires a system emulator or is
> > > even target-dependent.
> > > 
> > > The amount of function and particularly extern variables in
> > > monitor_int.h is probably a bit larger than it needs to be, but this way
> > > no non-trivial code modifications are needed. The interfaces between all
> > > monitor parts can be cleaned up later.
> > > 
> > > Signed-off-by: Kevin Wolf <kwolf@redhat.com>
> > 
> > OK, but can you call it anything other than core.* - I regularly end up
> > deleting things like that!
> 
> Oh, I didn't even think of this kind of core.*!
> 
> I imagine in practice it wouldn't be so bad to have a monitor/core.c
> because it's in a subdirectory, and it's under version control anyway.
> We already seem to have quite a few of them in subdirectories:
> 
>     ./hw/acpi/core.c
>     ./hw/bt/core.c
>     ./hw/cpu/core.c
>     ./hw/i2c/core.c
>     ./hw/ide/core.c
>     ./hw/sd/core.c
>     ./hw/usb/core.c

Yes, they all annoy me in the same way :-)

> But I'll gladly rename it if I can find a good name. Do you have any
> suggestions? Maybe just monitor/monitor.c?

Yes that's fine, thanks!

Dave

> Kevin
--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK

Patch
diff mbox series

diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h
index 8547529e49..b9f8d175ed 100644
--- a/include/monitor/monitor.h
+++ b/include/monitor/monitor.h
@@ -20,6 +20,7 @@  typedef struct MonitorHMP MonitorHMP;
 bool monitor_cur_is_qmp(void);
 
 void monitor_init_globals(void);
+void monitor_init_globals_core(void);
 void monitor_init(Chardev *chr, int flags);
 void monitor_init_qmp(Chardev *chr, int flags);
 void monitor_init_hmp(Chardev *chr, int flags);
diff --git a/monitor/monitor_int.h b/monitor/monitor_int.h
index 8c5d95f942..1a7af6a223 100644
--- a/monitor/monitor_int.h
+++ b/monitor/monitor_int.h
@@ -190,6 +190,7 @@  extern mon_cmd_t mon_cmds[];
 int monitor_puts(Monitor *mon, const char *str);
 void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
                        bool use_io_thread);
+void monitor_data_destroy(Monitor *mon);
 int monitor_can_read(void *opaque);
 void monitor_list_append(Monitor *mon);
 void monitor_fdsets_cleanup(void);
diff --git a/monitor/core.c b/monitor/core.c
new file mode 100644
index 0000000000..1cea56054b
--- /dev/null
+++ b/monitor/core.c
@@ -0,0 +1,604 @@ 
+/*
+ * 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 "qemu/osdep.h"
+#include "monitor_int.h"
+
+#include "qapi/error.h"
+#include "qapi/qapi-emit-events.h"
+#include "qapi/qmp/qstring.h"
+
+#include "qemu/option.h"
+#include "sysemu/qtest.h"
+
+#include "trace-root.h"
+
+/*
+ * To prevent flooding clients, events can be throttled. The
+ * throttling is calculated globally, rather than per-Monitor
+ * instance.
+ */
+typedef struct MonitorQAPIEventState {
+    QAPIEvent event;    /* Throttling state for this event type and... */
+    QDict *data;        /* ... data, see qapi_event_throttle_equal() */
+    QEMUTimer *timer;   /* Timer for handling delayed events */
+    QDict *qdict;       /* Delayed event (if any) */
+} MonitorQAPIEventState;
+
+typedef struct {
+    int64_t rate;       /* Minimum time (in ns) between two events */
+} MonitorQAPIEventConf;
+
+/* Shared monitor I/O thread */
+IOThread *mon_iothread;
+
+/* Bottom half to dispatch the requests received from I/O thread */
+QEMUBH *qmp_dispatcher_bh;
+
+/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */
+QemuMutex monitor_lock;
+static GHashTable *monitor_qapi_event_state;
+
+MonitorList mon_list;
+int mon_refcount;
+static bool monitor_destroyed;
+
+/**
+ * Is @mon is using readline?
+ * Note: not all HMP monitors use readline, e.g., gdbserver has a
+ * non-interactive HMP monitor, so readline is not used there.
+ */
+static inline bool monitor_uses_readline(const Monitor *mon)
+{
+    return mon->flags & MONITOR_USE_READLINE;
+}
+
+static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
+{
+    return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
+}
+
+static void monitor_flush_locked(Monitor *mon);
+
+static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
+                                  void *opaque)
+{
+    Monitor *mon = opaque;
+
+    qemu_mutex_lock(&mon->mon_lock);
+    mon->out_watch = 0;
+    monitor_flush_locked(mon);
+    qemu_mutex_unlock(&mon->mon_lock);
+    return FALSE;
+}
+
+/* Caller must hold mon->mon_lock */
+static void monitor_flush_locked(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 < 0 && errno != EAGAIN) || (rc == len)) {
+            /* all flushed or error */
+            qobject_unref(mon->outbuf);
+            mon->outbuf = qstring_new();
+            return;
+        }
+        if (rc > 0) {
+            /* partial write */
+            QString *tmp = qstring_from_str(buf + rc);
+            qobject_unref(mon->outbuf);
+            mon->outbuf = tmp;
+        }
+        if (mon->out_watch == 0) {
+            mon->out_watch =
+                qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
+                                      monitor_unblocked, mon);
+        }
+    }
+}
+
+void monitor_flush(Monitor *mon)
+{
+    qemu_mutex_lock(&mon->mon_lock);
+    monitor_flush_locked(mon);
+    qemu_mutex_unlock(&mon->mon_lock);
+}
+
+/* flush at every end of line */
+int monitor_puts(Monitor *mon, const char *str)
+{
+    int i;
+    char c;
+
+    qemu_mutex_lock(&mon->mon_lock);
+    for (i = 0; str[i]; i++) {
+        c = str[i];
+        if (c == '\n') {
+            qstring_append_chr(mon->outbuf, '\r');
+        }
+        qstring_append_chr(mon->outbuf, c);
+        if (c == '\n') {
+            monitor_flush_locked(mon);
+        }
+    }
+    qemu_mutex_unlock(&mon->mon_lock);
+
+    return i;
+}
+
+int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
+{
+    char *buf;
+    int n;
+
+    if (!mon)
+        return -1;
+
+    if (monitor_is_qmp(mon)) {
+        return -1;
+    }
+
+    buf = g_strdup_vprintf(fmt, ap);
+    n = monitor_puts(mon, buf);
+    g_free(buf);
+    return n;
+}
+
+int monitor_printf(Monitor *mon, const char *fmt, ...)
+{
+    int ret;
+
+    va_list ap;
+    va_start(ap, fmt);
+    ret = monitor_vprintf(mon, fmt, ap);
+    va_end(ap);
+    return ret;
+}
+
+
+static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
+    /* Limit guest-triggerable events to 1 per second */
+    [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
+    [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
+    [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
+    [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
+    [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
+    [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
+};
+
+/*
+ * Return the clock to use for recording an event's time.
+ * It's QEMU_CLOCK_REALTIME, except for qtests it's
+ * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
+ * Beware: result is invalid before configure_accelerator().
+ */
+static inline QEMUClockType monitor_get_event_clock(void)
+{
+    return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
+}
+
+/*
+ * Broadcast an event to all monitors.
+ * @qdict is the event object.  Its member "event" must match @event.
+ * Caller must hold monitor_lock.
+ */
+static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
+{
+    Monitor *mon;
+    MonitorQMP *qmp_mon;
+
+    trace_monitor_protocol_event_emit(event, qdict);
+    QTAILQ_FOREACH(mon, &mon_list, entry) {
+        if (!monitor_is_qmp(mon)) {
+            continue;
+        }
+
+        qmp_mon = container_of(mon, MonitorQMP, common);
+        if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
+            qmp_send_response(qmp_mon, qdict);
+        }
+    }
+}
+
+static void monitor_qapi_event_handler(void *opaque);
+
+/*
+ * Queue a new event for emission to Monitor instances,
+ * applying any rate limiting if required.
+ */
+static void
+monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
+{
+    MonitorQAPIEventConf *evconf;
+    MonitorQAPIEventState *evstate;
+
+    assert(event < QAPI_EVENT__MAX);
+    evconf = &monitor_qapi_event_conf[event];
+    trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
+
+    qemu_mutex_lock(&monitor_lock);
+
+    if (!evconf->rate) {
+        /* Unthrottled event */
+        monitor_qapi_event_emit(event, qdict);
+    } else {
+        QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
+        MonitorQAPIEventState key = { .event = event, .data = data };
+
+        evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
+        assert(!evstate || timer_pending(evstate->timer));
+
+        if (evstate) {
+            /*
+             * Timer is pending for (at least) evconf->rate ns after
+             * last send.  Store event for sending when timer fires,
+             * replacing a prior stored event if any.
+             */
+            qobject_unref(evstate->qdict);
+            evstate->qdict = qobject_ref(qdict);
+        } else {
+            /*
+             * Last send was (at least) evconf->rate ns ago.
+             * Send immediately, and arm the timer to call
+             * monitor_qapi_event_handler() in evconf->rate ns.  Any
+             * events arriving before then will be delayed until then.
+             */
+            int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
+
+            monitor_qapi_event_emit(event, qdict);
+
+            evstate = g_new(MonitorQAPIEventState, 1);
+            evstate->event = event;
+            evstate->data = qobject_ref(data);
+            evstate->qdict = NULL;
+            evstate->timer = timer_new_ns(monitor_get_event_clock(),
+                                          monitor_qapi_event_handler,
+                                          evstate);
+            g_hash_table_add(monitor_qapi_event_state, evstate);
+            timer_mod_ns(evstate->timer, now + evconf->rate);
+        }
+    }
+
+    qemu_mutex_unlock(&monitor_lock);
+}
+
+void qapi_event_emit(QAPIEvent event, QDict *qdict)
+{
+    /*
+     * monitor_qapi_event_queue_no_reenter() is not reentrant: it
+     * would deadlock on monitor_lock.  Work around by queueing
+     * events in thread-local storage.
+     * TODO: remove this, make it re-enter safe.
+     */
+    typedef struct MonitorQapiEvent {
+        QAPIEvent event;
+        QDict *qdict;
+        QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
+    } MonitorQapiEvent;
+    static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
+    static __thread bool reentered;
+    MonitorQapiEvent *ev;
+
+    if (!reentered) {
+        QSIMPLEQ_INIT(&event_queue);
+    }
+
+    ev = g_new(MonitorQapiEvent, 1);
+    ev->qdict = qobject_ref(qdict);
+    ev->event = event;
+    QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
+    if (reentered) {
+        return;
+    }
+
+    reentered = true;
+
+    while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
+        QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
+        monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
+        qobject_unref(ev->qdict);
+        g_free(ev);
+    }
+
+    reentered = false;
+}
+
+/*
+ * This function runs evconf->rate ns after sending a throttled
+ * event.
+ * If another event has since been stored, send it.
+ */
+static void monitor_qapi_event_handler(void *opaque)
+{
+    MonitorQAPIEventState *evstate = opaque;
+    MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
+
+    trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
+    qemu_mutex_lock(&monitor_lock);
+
+    if (evstate->qdict) {
+        int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
+
+        monitor_qapi_event_emit(evstate->event, evstate->qdict);
+        qobject_unref(evstate->qdict);
+        evstate->qdict = NULL;
+        timer_mod_ns(evstate->timer, now + evconf->rate);
+    } else {
+        g_hash_table_remove(monitor_qapi_event_state, evstate);
+        qobject_unref(evstate->data);
+        timer_free(evstate->timer);
+        g_free(evstate);
+    }
+
+    qemu_mutex_unlock(&monitor_lock);
+}
+
+static unsigned int qapi_event_throttle_hash(const void *key)
+{
+    const MonitorQAPIEventState *evstate = key;
+    unsigned int hash = evstate->event * 255;
+
+    if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
+        hash += g_str_hash(qdict_get_str(evstate->data, "id"));
+    }
+
+    if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
+        hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
+    }
+
+    return hash;
+}
+
+static gboolean qapi_event_throttle_equal(const void *a, const void *b)
+{
+    const MonitorQAPIEventState *eva = a;
+    const MonitorQAPIEventState *evb = b;
+
+    if (eva->event != evb->event) {
+        return FALSE;
+    }
+
+    if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
+        return !strcmp(qdict_get_str(eva->data, "id"),
+                       qdict_get_str(evb->data, "id"));
+    }
+
+    if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
+        return !strcmp(qdict_get_str(eva->data, "node-name"),
+                       qdict_get_str(evb->data, "node-name"));
+    }
+
+    return TRUE;
+}
+
+int monitor_suspend(Monitor *mon)
+{
+    if (monitor_is_hmp_non_interactive(mon)) {
+        return -ENOTTY;
+    }
+
+    atomic_inc(&mon->suspend_cnt);
+
+    if (mon->use_io_thread) {
+        /*
+         * Kick I/O thread to make sure this takes effect.  It'll be
+         * evaluated again in prepare() of the watch object.
+         */
+        aio_notify(iothread_get_aio_context(mon_iothread));
+    }
+
+    trace_monitor_suspend(mon, 1);
+    return 0;
+}
+
+static void monitor_accept_input(void *opaque)
+{
+    Monitor *mon = opaque;
+
+    qemu_chr_fe_accept_input(&mon->chr);
+}
+
+void monitor_resume(Monitor *mon)
+{
+    if (monitor_is_hmp_non_interactive(mon)) {
+        return;
+    }
+
+    if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
+        AioContext *ctx;
+
+        if (mon->use_io_thread) {
+            ctx = iothread_get_aio_context(mon_iothread);
+        } else {
+            ctx = qemu_get_aio_context();
+        }
+
+        if (!monitor_is_qmp(mon)) {
+            MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
+            assert(hmp_mon->rs);
+            readline_show_prompt(hmp_mon->rs);
+        }
+
+        aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
+    }
+
+    trace_monitor_suspend(mon, -1);
+}
+
+int monitor_can_read(void *opaque)
+{
+    Monitor *mon = opaque;
+
+    return !atomic_mb_read(&mon->suspend_cnt);
+}
+
+void monitor_list_append(Monitor *mon)
+{
+    qemu_mutex_lock(&monitor_lock);
+    /*
+     * This prevents inserting new monitors during monitor_cleanup().
+     * A cleaner solution would involve the main thread telling other
+     * threads to terminate, waiting for their termination.
+     */
+    if (!monitor_destroyed) {
+        QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
+        mon = NULL;
+    }
+    qemu_mutex_unlock(&monitor_lock);
+
+    if (mon) {
+        monitor_data_destroy(mon);
+        g_free(mon);
+    }
+}
+
+static void monitor_iothread_init(void)
+{
+    mon_iothread = iothread_create("mon_iothread", &error_abort);
+}
+
+void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
+                       bool use_io_thread)
+{
+    if (use_io_thread && !mon_iothread) {
+        monitor_iothread_init();
+    }
+    memset(mon, 0, sizeof(Monitor));
+    qemu_mutex_init(&mon->mon_lock);
+    mon->outbuf = qstring_new();
+    mon->skip_flush = skip_flush;
+    mon->use_io_thread = use_io_thread;
+    mon->flags = flags;
+}
+
+void monitor_data_destroy(Monitor *mon)
+{
+    g_free(mon->mon_cpu_path);
+    qemu_chr_fe_deinit(&mon->chr, false);
+    if (monitor_is_qmp(mon)) {
+        MonitorQMP *qmp_mon = container_of(mon, MonitorQMP, common);
+        monitor_data_destroy_qmp(qmp_mon);
+    } else {
+        MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
+        readline_free(hmp_mon->rs);
+    }
+    qobject_unref(mon->outbuf);
+    qemu_mutex_destroy(&mon->mon_lock);
+}
+
+void monitor_init(Chardev *chr, int flags)
+{
+    if (flags & MONITOR_USE_CONTROL) {
+        monitor_init_qmp(chr, flags);
+    } else {
+        monitor_init_hmp(chr, flags);
+    }
+}
+
+void monitor_cleanup(void)
+{
+    /*
+     * We need to explicitly stop the I/O thread (but not destroy it),
+     * clean up the monitor resources, then destroy the I/O thread since
+     * we need to unregister from chardev below in
+     * monitor_data_destroy(), and chardev is not thread-safe yet
+     */
+    if (mon_iothread) {
+        iothread_stop(mon_iothread);
+    }
+
+    /* Flush output buffers and destroy monitors */
+    qemu_mutex_lock(&monitor_lock);
+    monitor_destroyed = true;
+    while (!QTAILQ_EMPTY(&mon_list)) {
+        Monitor *mon = QTAILQ_FIRST(&mon_list);
+        QTAILQ_REMOVE(&mon_list, mon, entry);
+        /* Permit QAPI event emission from character frontend release */
+        qemu_mutex_unlock(&monitor_lock);
+        monitor_flush(mon);
+        monitor_data_destroy(mon);
+        qemu_mutex_lock(&monitor_lock);
+        g_free(mon);
+    }
+    qemu_mutex_unlock(&monitor_lock);
+
+    /* QEMUBHs needs to be deleted before destroying the I/O thread */
+    qemu_bh_delete(qmp_dispatcher_bh);
+    qmp_dispatcher_bh = NULL;
+    if (mon_iothread) {
+        iothread_destroy(mon_iothread);
+        mon_iothread = NULL;
+    }
+}
+
+static void monitor_qapi_event_init(void)
+{
+    monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
+                                                qapi_event_throttle_equal);
+}
+
+void monitor_init_globals_core(void)
+{
+    monitor_qapi_event_init();
+    qemu_mutex_init(&monitor_lock);
+
+    /*
+     * The dispatcher BH must run in the main loop thread, since we
+     * have commands assuming that context.  It would be nice to get
+     * rid of those assumptions.
+     */
+    qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
+                                   monitor_qmp_bh_dispatcher,
+                                   NULL);
+}
+
+QemuOptsList qemu_mon_opts = {
+    .name = "mon",
+    .implied_opt_name = "chardev",
+    .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
+    .desc = {
+        {
+            .name = "mode",
+            .type = QEMU_OPT_STRING,
+        },{
+            .name = "chardev",
+            .type = QEMU_OPT_STRING,
+        },{
+            .name = "pretty",
+            .type = QEMU_OPT_BOOL,
+        },
+        { /* end of list */ }
+    },
+};
diff --git a/monitor/misc.c b/monitor/misc.c
index 408d11e1fe..1f60f31c95 100644
--- a/monitor/misc.c
+++ b/monitor/misc.c
@@ -117,43 +117,13 @@  struct MonFdset {
     QLIST_ENTRY(MonFdset) next;
 };
 
-/*
- * To prevent flooding clients, events can be throttled. The
- * throttling is calculated globally, rather than per-Monitor
- * instance.
- */
-typedef struct MonitorQAPIEventState {
-    QAPIEvent event;    /* Throttling state for this event type and... */
-    QDict *data;        /* ... data, see qapi_event_throttle_equal() */
-    QEMUTimer *timer;   /* Timer for handling delayed events */
-    QDict *qdict;       /* Delayed event (if any) */
-} MonitorQAPIEventState;
-
-typedef struct {
-    int64_t rate;       /* Minimum time (in ns) between two events */
-} MonitorQAPIEventConf;
-
-/* Shared monitor I/O thread */
-IOThread *mon_iothread;
-
-/* Bottom half to dispatch the requests received from I/O thread */
-QEMUBH *qmp_dispatcher_bh;
-
 /* QMP checker flags */
 #define QMP_ACCEPT_UNKNOWNS 1
 
-/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */
-QemuMutex monitor_lock;
-static GHashTable *monitor_qapi_event_state;
-MonitorList mon_list;
-static bool monitor_destroyed;
-
 /* Protects mon_fdsets */
 static QemuMutex mon_fdsets_lock;
 static QLIST_HEAD(, MonFdset) mon_fdsets;
 
-int mon_refcount;
-
 static mon_cmd_t info_cmds[];
 
 __thread Monitor *cur_mon;
@@ -161,32 +131,6 @@  __thread Monitor *cur_mon;
 static void monitor_command_cb(void *opaque, const char *cmdline,
                                void *readline_opaque);
 
-/**
- * Is @mon is using readline?
- * Note: not all HMP monitors use readline, e.g., gdbserver has a
- * non-interactive HMP monitor, so readline is not used there.
- */
-static inline bool monitor_uses_readline(const Monitor *mon)
-{
-    return mon->flags & MONITOR_USE_READLINE;
-}
-
-static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
-{
-    return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
-}
-
-/*
- * Return the clock to use for recording an event's time.
- * It's QEMU_CLOCK_REALTIME, except for qtests it's
- * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
- * Beware: result is invalid before configure_accelerator().
- */
-static inline QEMUClockType monitor_get_event_clock(void)
-{
-    return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
-}
-
 /**
  * Is the current monitor, if any, a QMP monitor?
  */
@@ -220,355 +164,6 @@  int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
 }
 
 
-static void monitor_flush_locked(Monitor *mon);
-
-static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
-                                  void *opaque)
-{
-    Monitor *mon = opaque;
-
-    qemu_mutex_lock(&mon->mon_lock);
-    mon->out_watch = 0;
-    monitor_flush_locked(mon);
-    qemu_mutex_unlock(&mon->mon_lock);
-    return FALSE;
-}
-
-/* Caller must hold mon->mon_lock */
-static void monitor_flush_locked(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 < 0 && errno != EAGAIN) || (rc == len)) {
-            /* all flushed or error */
-            qobject_unref(mon->outbuf);
-            mon->outbuf = qstring_new();
-            return;
-        }
-        if (rc > 0) {
-            /* partial write */
-            QString *tmp = qstring_from_str(buf + rc);
-            qobject_unref(mon->outbuf);
-            mon->outbuf = tmp;
-        }
-        if (mon->out_watch == 0) {
-            mon->out_watch =
-                qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
-                                      monitor_unblocked, mon);
-        }
-    }
-}
-
-void monitor_flush(Monitor *mon)
-{
-    qemu_mutex_lock(&mon->mon_lock);
-    monitor_flush_locked(mon);
-    qemu_mutex_unlock(&mon->mon_lock);
-}
-
-/* flush at every end of line */
-int monitor_puts(Monitor *mon, const char *str)
-{
-    int i;
-    char c;
-
-    qemu_mutex_lock(&mon->mon_lock);
-    for (i = 0; str[i]; i++) {
-        c = str[i];
-        if (c == '\n') {
-            qstring_append_chr(mon->outbuf, '\r');
-        }
-        qstring_append_chr(mon->outbuf, c);
-        if (c == '\n') {
-            monitor_flush_locked(mon);
-        }
-    }
-    qemu_mutex_unlock(&mon->mon_lock);
-
-    return i;
-}
-
-int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
-{
-    char *buf;
-    int n;
-
-    if (!mon)
-        return -1;
-
-    if (monitor_is_qmp(mon)) {
-        return -1;
-    }
-
-    buf = g_strdup_vprintf(fmt, ap);
-    n = monitor_puts(mon, buf);
-    g_free(buf);
-    return n;
-}
-
-int monitor_printf(Monitor *mon, const char *fmt, ...)
-{
-    int ret;
-
-    va_list ap;
-    va_start(ap, fmt);
-    ret = monitor_vprintf(mon, fmt, ap);
-    va_end(ap);
-    return ret;
-}
-
-static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
-    /* Limit guest-triggerable events to 1 per second */
-    [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
-    [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
-    [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
-    [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
-    [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
-    [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
-};
-
-/*
- * Broadcast an event to all monitors.
- * @qdict is the event object.  Its member "event" must match @event.
- * Caller must hold monitor_lock.
- */
-static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
-{
-    Monitor *mon;
-    MonitorQMP *qmp_mon;
-
-    trace_monitor_protocol_event_emit(event, qdict);
-    QTAILQ_FOREACH(mon, &mon_list, entry) {
-        if (!monitor_is_qmp(mon)) {
-            continue;
-        }
-
-        qmp_mon = container_of(mon, MonitorQMP, common);
-        if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
-            qmp_send_response(qmp_mon, qdict);
-        }
-    }
-}
-
-static void monitor_qapi_event_handler(void *opaque);
-
-/*
- * Queue a new event for emission to Monitor instances,
- * applying any rate limiting if required.
- */
-static void
-monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
-{
-    MonitorQAPIEventConf *evconf;
-    MonitorQAPIEventState *evstate;
-
-    assert(event < QAPI_EVENT__MAX);
-    evconf = &monitor_qapi_event_conf[event];
-    trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
-
-    qemu_mutex_lock(&monitor_lock);
-
-    if (!evconf->rate) {
-        /* Unthrottled event */
-        monitor_qapi_event_emit(event, qdict);
-    } else {
-        QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
-        MonitorQAPIEventState key = { .event = event, .data = data };
-
-        evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
-        assert(!evstate || timer_pending(evstate->timer));
-
-        if (evstate) {
-            /*
-             * Timer is pending for (at least) evconf->rate ns after
-             * last send.  Store event for sending when timer fires,
-             * replacing a prior stored event if any.
-             */
-            qobject_unref(evstate->qdict);
-            evstate->qdict = qobject_ref(qdict);
-        } else {
-            /*
-             * Last send was (at least) evconf->rate ns ago.
-             * Send immediately, and arm the timer to call
-             * monitor_qapi_event_handler() in evconf->rate ns.  Any
-             * events arriving before then will be delayed until then.
-             */
-            int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
-
-            monitor_qapi_event_emit(event, qdict);
-
-            evstate = g_new(MonitorQAPIEventState, 1);
-            evstate->event = event;
-            evstate->data = qobject_ref(data);
-            evstate->qdict = NULL;
-            evstate->timer = timer_new_ns(monitor_get_event_clock(),
-                                          monitor_qapi_event_handler,
-                                          evstate);
-            g_hash_table_add(monitor_qapi_event_state, evstate);
-            timer_mod_ns(evstate->timer, now + evconf->rate);
-        }
-    }
-
-    qemu_mutex_unlock(&monitor_lock);
-}
-
-void qapi_event_emit(QAPIEvent event, QDict *qdict)
-{
-    /*
-     * monitor_qapi_event_queue_no_reenter() is not reentrant: it
-     * would deadlock on monitor_lock.  Work around by queueing
-     * events in thread-local storage.
-     * TODO: remove this, make it re-enter safe.
-     */
-    typedef struct MonitorQapiEvent {
-        QAPIEvent event;
-        QDict *qdict;
-        QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
-    } MonitorQapiEvent;
-    static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
-    static __thread bool reentered;
-    MonitorQapiEvent *ev;
-
-    if (!reentered) {
-        QSIMPLEQ_INIT(&event_queue);
-    }
-
-    ev = g_new(MonitorQapiEvent, 1);
-    ev->qdict = qobject_ref(qdict);
-    ev->event = event;
-    QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
-    if (reentered) {
-        return;
-    }
-
-    reentered = true;
-
-    while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
-        QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
-        monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
-        qobject_unref(ev->qdict);
-        g_free(ev);
-    }
-
-    reentered = false;
-}
-
-/*
- * This function runs evconf->rate ns after sending a throttled
- * event.
- * If another event has since been stored, send it.
- */
-static void monitor_qapi_event_handler(void *opaque)
-{
-    MonitorQAPIEventState *evstate = opaque;
-    MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
-
-    trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
-    qemu_mutex_lock(&monitor_lock);
-
-    if (evstate->qdict) {
-        int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
-
-        monitor_qapi_event_emit(evstate->event, evstate->qdict);
-        qobject_unref(evstate->qdict);
-        evstate->qdict = NULL;
-        timer_mod_ns(evstate->timer, now + evconf->rate);
-    } else {
-        g_hash_table_remove(monitor_qapi_event_state, evstate);
-        qobject_unref(evstate->data);
-        timer_free(evstate->timer);
-        g_free(evstate);
-    }
-
-    qemu_mutex_unlock(&monitor_lock);
-}
-
-static unsigned int qapi_event_throttle_hash(const void *key)
-{
-    const MonitorQAPIEventState *evstate = key;
-    unsigned int hash = evstate->event * 255;
-
-    if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
-        hash += g_str_hash(qdict_get_str(evstate->data, "id"));
-    }
-
-    if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
-        hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
-    }
-
-    return hash;
-}
-
-static gboolean qapi_event_throttle_equal(const void *a, const void *b)
-{
-    const MonitorQAPIEventState *eva = a;
-    const MonitorQAPIEventState *evb = b;
-
-    if (eva->event != evb->event) {
-        return FALSE;
-    }
-
-    if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
-        return !strcmp(qdict_get_str(eva->data, "id"),
-                       qdict_get_str(evb->data, "id"));
-    }
-
-    if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
-        return !strcmp(qdict_get_str(eva->data, "node-name"),
-                       qdict_get_str(evb->data, "node-name"));
-    }
-
-    return TRUE;
-}
-
-static void monitor_qapi_event_init(void)
-{
-    monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
-                                                qapi_event_throttle_equal);
-}
-
-static void monitor_iothread_init(void);
-
-void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
-                       bool use_io_thread)
-{
-    if (use_io_thread && !mon_iothread) {
-        monitor_iothread_init();
-    }
-    memset(mon, 0, sizeof(Monitor));
-    qemu_mutex_init(&mon->mon_lock);
-    mon->outbuf = qstring_new();
-    mon->skip_flush = skip_flush;
-    mon->use_io_thread = use_io_thread;
-    mon->flags = flags;
-}
-
-static void monitor_data_destroy(Monitor *mon)
-{
-    g_free(mon->mon_cpu_path);
-    qemu_chr_fe_deinit(&mon->chr, false);
-    if (monitor_is_qmp(mon)) {
-        MonitorQMP *qmp_mon = container_of(mon, MonitorQMP, common);
-        monitor_data_destroy_qmp(qmp_mon);
-    } else {
-        MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
-        readline_free(hmp_mon->rs);
-    }
-    qobject_unref(mon->outbuf);
-    qemu_mutex_destroy(&mon->mon_lock);
-}
-
 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
                                 int64_t cpu_index, Error **errp)
 {
@@ -2738,13 +2333,6 @@  void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
     }
 }
 
-int monitor_can_read(void *opaque)
-{
-    Monitor *mon = opaque;
-
-    return !atomic_mb_read(&mon->suspend_cnt);
-}
-
 static void monitor_command_cb(void *opaque, const char *cmdline,
                                void *readline_opaque)
 {
@@ -2755,60 +2343,6 @@  static void monitor_command_cb(void *opaque, const char *cmdline,
     monitor_resume(&mon->common);
 }
 
-int monitor_suspend(Monitor *mon)
-{
-    if (monitor_is_hmp_non_interactive(mon)) {
-        return -ENOTTY;
-    }
-
-    atomic_inc(&mon->suspend_cnt);
-
-    if (mon->use_io_thread) {
-        /*
-         * Kick I/O thread to make sure this takes effect.  It'll be
-         * evaluated again in prepare() of the watch object.
-         */
-        aio_notify(iothread_get_aio_context(mon_iothread));
-    }
-
-    trace_monitor_suspend(mon, 1);
-    return 0;
-}
-
-static void monitor_accept_input(void *opaque)
-{
-    Monitor *mon = opaque;
-
-    qemu_chr_fe_accept_input(&mon->chr);
-}
-
-void monitor_resume(Monitor *mon)
-{
-    if (monitor_is_hmp_non_interactive(mon)) {
-        return;
-    }
-
-    if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
-        AioContext *ctx;
-
-        if (mon->use_io_thread) {
-            ctx = iothread_get_aio_context(mon_iothread);
-        } else {
-            ctx = qemu_get_aio_context();
-        }
-
-        if (!monitor_is_qmp(mon)) {
-            MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
-            assert(hmp_mon->rs);
-            readline_show_prompt(hmp_mon->rs);
-        }
-
-        aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
-    }
-
-    trace_monitor_suspend(mon, -1);
-}
-
 static int
 compare_mon_cmd(const void *a, const void *b)
 {
@@ -2828,27 +2362,12 @@  static void sortcmdlist(void)
     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
 }
 
-static void monitor_iothread_init(void)
-{
-    mon_iothread = iothread_create("mon_iothread", &error_abort);
-}
-
 void monitor_init_globals(void)
 {
+    monitor_init_globals_core();
     monitor_init_qmp_commands();
-    monitor_qapi_event_init();
     sortcmdlist();
-    qemu_mutex_init(&monitor_lock);
     qemu_mutex_init(&mon_fdsets_lock);
-
-    /*
-     * The dispatcher BH must run in the main loop thread, since we
-     * have commands assuming that context.  It would be nice to get
-     * rid of those assumptions.
-     */
-    qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
-                                   monitor_qmp_bh_dispatcher,
-                                   NULL);
 }
 
 /*
@@ -2873,90 +2392,6 @@  int error_vprintf_unless_qmp(const char *fmt, va_list ap)
     return -1;
 }
 
-void monitor_list_append(Monitor *mon)
-{
-    qemu_mutex_lock(&monitor_lock);
-    /*
-     * This prevents inserting new monitors during monitor_cleanup().
-     * A cleaner solution would involve the main thread telling other
-     * threads to terminate, waiting for their termination.
-     */
-    if (!monitor_destroyed) {
-        QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
-        mon = NULL;
-    }
-    qemu_mutex_unlock(&monitor_lock);
-
-    if (mon) {
-        monitor_data_destroy(mon);
-        g_free(mon);
-    }
-}
-
-void monitor_init(Chardev *chr, int flags)
-{
-    if (flags & MONITOR_USE_CONTROL) {
-        monitor_init_qmp(chr, flags);
-    } else {
-        monitor_init_hmp(chr, flags);
-    }
-}
-
-void monitor_cleanup(void)
-{
-    /*
-     * We need to explicitly stop the I/O thread (but not destroy it),
-     * clean up the monitor resources, then destroy the I/O thread since
-     * we need to unregister from chardev below in
-     * monitor_data_destroy(), and chardev is not thread-safe yet
-     */
-    if (mon_iothread) {
-        iothread_stop(mon_iothread);
-    }
-
-    /* Flush output buffers and destroy monitors */
-    qemu_mutex_lock(&monitor_lock);
-    monitor_destroyed = true;
-    while (!QTAILQ_EMPTY(&mon_list)) {
-        Monitor *mon = QTAILQ_FIRST(&mon_list);
-        QTAILQ_REMOVE(&mon_list, mon, entry);
-        /* Permit QAPI event emission from character frontend release */
-        qemu_mutex_unlock(&monitor_lock);
-        monitor_flush(mon);
-        monitor_data_destroy(mon);
-        qemu_mutex_lock(&monitor_lock);
-        g_free(mon);
-    }
-    qemu_mutex_unlock(&monitor_lock);
-
-    /* QEMUBHs needs to be deleted before destroying the I/O thread */
-    qemu_bh_delete(qmp_dispatcher_bh);
-    qmp_dispatcher_bh = NULL;
-    if (mon_iothread) {
-        iothread_destroy(mon_iothread);
-        mon_iothread = NULL;
-    }
-}
-
-QemuOptsList qemu_mon_opts = {
-    .name = "mon",
-    .implied_opt_name = "chardev",
-    .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
-    .desc = {
-        {
-            .name = "mode",
-            .type = QEMU_OPT_STRING,
-        },{
-            .name = "chardev",
-            .type = QEMU_OPT_STRING,
-        },{
-            .name = "pretty",
-            .type = QEMU_OPT_BOOL,
-        },
-        { /* end of list */ }
-    },
-};
-
 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
 {
     MachineState *ms = MACHINE(qdev_get_machine());
diff --git a/monitor/Makefile.objs b/monitor/Makefile.objs
index 48c73eed51..c8dff5e4b5 100644
--- a/monitor/Makefile.objs
+++ b/monitor/Makefile.objs
@@ -1,2 +1,2 @@ 
 obj-y += misc.o
-common-obj-y += qmp.o hmp.o
+common-obj-y += core.o qmp.o hmp.o