RISC-V: Add priv_ver to DisasContext

[qemu.git] / monitor.c

diff --git a/monitor.c b/monitor.c
index 3b90c9eb5fc16417ce49851771156061bd24b57f..e5de5765b8d72a5e35cdf33996e17da24998e20b 100644 (file)
--- a/monitor.c
+++ b/monitor.c
@@ -83,6 +83,7 @@
 #include "sysemu/cpus.h"
 #include "sysemu/iothread.h"
 #include "qemu/cutils.h"
 #include "sysemu/cpus.h"
 #include "sysemu/iothread.h"
 #include "qemu/cutils.h"

+#include "tcg/tcg.h"

 
 #if defined(TARGET_S390X)
 #include "hw/s390x/storage-keys.h"
 
 #if defined(TARGET_S390X)
 #include "hw/s390x/storage-keys.h"


@@ -262,14 +263,15 @@ typedef struct QMPRequest QMPRequest;
 /* QMP checker flags */
 #define QMP_ACCEPT_UNKNOWNS 1
 
 /* QMP checker flags */
 #define QMP_ACCEPT_UNKNOWNS 1
 

-/* Protects mon_list, monitor_qapi_event_state.  */
+/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */

 static QemuMutex monitor_lock;
 static GHashTable *monitor_qapi_event_state;
 static QemuMutex monitor_lock;
 static GHashTable *monitor_qapi_event_state;

-static QTAILQ_HEAD(mon_list, Monitor) mon_list;
+static QTAILQ_HEAD(, Monitor) mon_list;
+static bool monitor_destroyed;

 
 /* Protects mon_fdsets */
 static QemuMutex mon_fdsets_lock;
 
 /* Protects mon_fdsets */
 static QemuMutex mon_fdsets_lock;

-static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
+static QLIST_HEAD(, MonFdset) mon_fdsets;

 
 static int mon_refcount;
 
 
 static int mon_refcount;
 


@@ -588,8 +590,7 @@ monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
     qemu_mutex_unlock(&monitor_lock);
 }
 
     qemu_mutex_unlock(&monitor_lock);
 }
 

-static void
-monitor_qapi_event_queue(QAPIEvent event, QDict *qdict)
+void qapi_event_emit(QAPIEvent event, QDict *qdict)

 {
     /*
      * monitor_qapi_event_queue_no_reenter() is not reentrant: it
 {
     /*
      * monitor_qapi_event_queue_no_reenter() is not reentrant: it


@@ -702,14 +703,18 @@ static void monitor_qapi_event_init(void)
 {
     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
                                                 qapi_event_throttle_equal);
 {
     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
                                                 qapi_event_throttle_equal);

-    qmp_event_set_func_emit(monitor_qapi_event_queue);

 }
 
 static void handle_hmp_command(Monitor *mon, const char *cmdline);
 
 }
 
 static void handle_hmp_command(Monitor *mon, const char *cmdline);
 

+static void monitor_iothread_init(void);
+

 static void monitor_data_init(Monitor *mon, bool skip_flush,
                               bool use_io_thread)
 {
 static void monitor_data_init(Monitor *mon, 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);
     qemu_mutex_init(&mon->qmp.qmp_queue_lock);
     memset(mon, 0, sizeof(Monitor));
     qemu_mutex_init(&mon->mon_lock);
     qemu_mutex_init(&mon->qmp.qmp_queue_lock);


@@ -952,6 +957,7 @@ static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
                           char **args, int nb_args, int arg_index)
 {
     const mon_cmd_t *cmd;
                           char **args, int nb_args, int arg_index)
 {
     const mon_cmd_t *cmd;

+    size_t i;

 
     /* No valid arg need to compare with, dump all in *cmds */
     if (arg_index >= nb_args) {
 
     /* No valid arg need to compare with, dump all in *cmds */
     if (arg_index >= nb_args) {


@@ -973,9 +979,15 @@ static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
             } else {
                 help_cmd_dump_one(mon, cmd, args, arg_index);
             }
             } else {
                 help_cmd_dump_one(mon, cmd, args, arg_index);
             }

-            break;
+            return;

         }
     }
         }
     }

+
+    /* Command not found */
+    monitor_printf(mon, "unknown command: '");
+    for (i = 0; i <= arg_index; i++) {
+        monitor_printf(mon, "%s%s", args[i], i == arg_index ? "'\n" : " ");
+    }

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


@@ -1133,11 +1145,6 @@ static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
  */
 static void qmp_unregister_commands_hack(void)
 {
  */
 static void qmp_unregister_commands_hack(void)
 {

-#ifndef CONFIG_REPLICATION
-    qmp_unregister_command(&qmp_commands, "xen-set-replication");
-    qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
-    qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
-#endif

 #ifndef TARGET_I386
     qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
     qmp_unregister_command(&qmp_commands, "query-sev");
 #ifndef TARGET_I386
     qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
     qmp_unregister_command(&qmp_commands, "query-sev");


@@ -1591,7 +1598,13 @@ static void memory_dump(Monitor *mon, int count, int format, int wsize,
         if (l > line_size)
             l = line_size;
         if (is_physical) {
         if (l > line_size)
             l = line_size;
         if (is_physical) {

-            cpu_physical_memory_read(addr, buf, l);
+            AddressSpace *as = cs ? cs->as : &address_space_memory;
+            MemTxResult r = address_space_read(as, addr,
+                                               MEMTXATTRS_UNSPECIFIED, buf, l);
+            if (r != MEMTX_OK) {
+                monitor_printf(mon, " Cannot access memory\n");
+                break;
+            }

         } else {
             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
                 monitor_printf(mon, " Cannot access memory\n");
         } else {
             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
                 monitor_printf(mon, " Cannot access memory\n");


@@ -1959,16 +1972,22 @@ static void hmp_info_numa(Monitor *mon, const QDict *qdict)
 
 #ifdef CONFIG_PROFILER
 
 
 #ifdef CONFIG_PROFILER
 

-int64_t tcg_time;

 int64_t dev_time;
 
 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
 {
 int64_t dev_time;
 
 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
 {

+    static int64_t last_cpu_exec_time;
+    int64_t cpu_exec_time;
+    int64_t delta;
+
+    cpu_exec_time = tcg_cpu_exec_time();
+    delta = cpu_exec_time - last_cpu_exec_time;
+

     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",

-                   tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
-    tcg_time = 0;
+                   delta, delta / (double)NANOSECONDS_PER_SECOND);
+    last_cpu_exec_time = cpu_exec_time;

     dev_time = 0;
 }
 #else
     dev_time = 0;
 }
 #else


@@ -3212,7 +3231,7 @@ static QDict *monitor_parse_arguments(Monitor *mon,
             {
                 int ret;
                 uint64_t val;
             {
                 int ret;
                 uint64_t val;

-                char *end;
+                const char *end;

 
                 while (qemu_isspace(*p)) {
                     p++;
 
                 while (qemu_isspace(*p)) {
                     p++;


@@ -4090,8 +4109,12 @@ static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
  * processing commands only on a very busy monitor.  To achieve that,
  * when we process one request on a specific monitor, we put that
  * monitor to the end of mon_list queue.
  * processing commands only on a very busy monitor.  To achieve that,
  * when we process one request on a specific monitor, we put that
  * monitor to the end of mon_list queue.

+ *
+ * Note: if the function returned with non-NULL, then the caller will
+ * be with mon->qmp.qmp_queue_lock held, and the caller is responsible
+ * to release it.

  */
  */

-static QMPRequest *monitor_qmp_requests_pop_any(void)
+static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)

 {
     QMPRequest *req_obj = NULL;
     Monitor *mon;
 {
     QMPRequest *req_obj = NULL;
     Monitor *mon;


@@ -4101,10 +4124,11 @@ static QMPRequest *monitor_qmp_requests_pop_any(void)
     QTAILQ_FOREACH(mon, &mon_list, entry) {
         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
         req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
     QTAILQ_FOREACH(mon, &mon_list, entry) {
         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
         req_obj = g_queue_pop_head(mon->qmp.qmp_requests);

-        qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);

         if (req_obj) {
         if (req_obj) {

+            /* With the lock of corresponding queue held */

             break;
         }
             break;
         }

+        qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);

     }
 
     if (req_obj) {
     }
 
     if (req_obj) {


@@ -4123,30 +4147,34 @@ static QMPRequest *monitor_qmp_requests_pop_any(void)
 
 static void monitor_qmp_bh_dispatcher(void *data)
 {
 
 static void monitor_qmp_bh_dispatcher(void *data)
 {

-    QMPRequest *req_obj = monitor_qmp_requests_pop_any();
+    QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();

     QDict *rsp;
     bool need_resume;
     QDict *rsp;
     bool need_resume;

+    Monitor *mon;

 
     if (!req_obj) {
         return;
     }
 
 
     if (!req_obj) {
         return;
     }
 

+    mon = req_obj->mon;

     /*  qmp_oob_enabled() might change after "qmp_capabilities" */
     /*  qmp_oob_enabled() might change after "qmp_capabilities" */

-    need_resume = !qmp_oob_enabled(req_obj->mon);
+    need_resume = !qmp_oob_enabled(mon) ||
+        mon->qmp.qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
+    qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);

     if (req_obj->req) {
         trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
     if (req_obj->req) {
         trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");

-        monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
+        monitor_qmp_dispatch(mon, req_obj->req, req_obj->id);

     } else {
         assert(req_obj->err);
         rsp = qmp_error_response(req_obj->err);
         req_obj->err = NULL;
     } else {
         assert(req_obj->err);
         rsp = qmp_error_response(req_obj->err);
         req_obj->err = NULL;

-        monitor_qmp_respond(req_obj->mon, rsp, NULL);
+        monitor_qmp_respond(mon, rsp, NULL);

         qobject_unref(rsp);
     }
 
     if (need_resume) {
         /* Pairs with the monitor_suspend() in handle_qmp_command() */
         qobject_unref(rsp);
     }
 
     if (need_resume) {
         /* Pairs with the monitor_suspend() in handle_qmp_command() */

-        monitor_resume(req_obj->mon);
+        monitor_resume(mon);

     }
     qmp_request_free(req_obj);
 
     }
     qmp_request_free(req_obj);
 


@@ -4154,8 +4182,6 @@ static void monitor_qmp_bh_dispatcher(void *data)
     qemu_bh_schedule(qmp_dispatcher_bh);
 }
 
     qemu_bh_schedule(qmp_dispatcher_bh);
 }
 

-#define  QMP_REQ_QUEUE_LEN_MAX  (8)
-

 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 {
     Monitor *mon = opaque;
 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 {
     Monitor *mon = opaque;


@@ -4197,28 +4223,14 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 
     /*
     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 
     /*

-     * If OOB is not enabled on the current monitor, we'll emulate the
-     * old behavior that we won't process the current monitor any more
-     * until it has responded.  This helps make sure that as long as
-     * OOB is not enabled, the server will never drop any command.
+     * Suspend the monitor when we can't queue more requests after
+     * this one.  Dequeuing in monitor_qmp_bh_dispatcher() will resume
+     * it.  Note that when OOB is disabled, we queue at most one
+     * command, for backward compatibility.

      */
      */

-    if (!qmp_oob_enabled(mon)) {
+    if (!qmp_oob_enabled(mon) ||
+        mon->qmp.qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {

         monitor_suspend(mon);
         monitor_suspend(mon);

-    } else {
-        /* Drop the request if queue is full. */
-        if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
-            qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
-            /*
-             * FIXME @id's scope is just @mon, and broadcasting it is
-             * wrong.  If another monitor's client has a command with
-             * the same ID in flight, the event will incorrectly claim
-             * that command was dropped.
-             */
-            qapi_event_send_command_dropped(id,
-                                            COMMAND_DROP_REASON_QUEUE_FULL);
-            qmp_request_free(req_obj);
-            return;
-        }

     }
 
     /*
     }
 
     /*


@@ -4226,6 +4238,7 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
      * handled in time order.  Ownership for req_obj, req, id,
      * etc. will be delivered to the handler side.
      */
      * handled in time order.  Ownership for req_obj, req, id,
      * etc. will be delivered to the handler side.
      */

+    assert(mon->qmp.qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);

     g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 
     g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 


@@ -4278,7 +4291,7 @@ int monitor_suspend(Monitor *mon)
 
     atomic_inc(&mon->suspend_cnt);
 
 
     atomic_inc(&mon->suspend_cnt);
 

-    if (monitor_is_qmp(mon)) {
+    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.
         /*
          * Kick I/O thread to make sure this takes effect.  It'll be
          * evaluated again in prepare() of the watch object.


@@ -4290,6 +4303,13 @@ int monitor_suspend(Monitor *mon)
     return 0;
 }
 
     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)) {
 void monitor_resume(Monitor *mon)
 {
     if (monitor_is_hmp_non_interactive(mon)) {


@@ -4297,20 +4317,22 @@ void monitor_resume(Monitor *mon)
     }
 
     if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
     }
 
     if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {

-        if (monitor_is_qmp(mon)) {
-            /*
-             * For QMP monitors that are running in the I/O thread,
-             * let's kick the thread in case it's sleeping.
-             */
-            if (mon->use_io_thread) {
-                aio_notify(iothread_get_aio_context(mon_iothread));
-            }
+        AioContext *ctx;
+
+        if (mon->use_io_thread) {
+            ctx = iothread_get_aio_context(mon_iothread);

         } else {
         } else {

+            ctx = qemu_get_aio_context();
+        }
+
+        if (!monitor_is_qmp(mon)) {

             assert(mon->rs);
             readline_show_prompt(mon->rs);
         }
             assert(mon->rs);
             readline_show_prompt(mon->rs);
         }

-        qemu_chr_fe_accept_input(&mon->chr);
+
+        aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);

     }
     }

+

     trace_monitor_suspend(mon, -1);
 }
 
     trace_monitor_suspend(mon, -1);
 }
 


@@ -4434,19 +4456,18 @@ static void sortcmdlist(void)
     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
 }
 
     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
 }
 

-static GMainContext *monitor_get_io_context(void)
-{
-    return iothread_get_g_main_context(mon_iothread);
-}
-
-static AioContext *monitor_get_aio_context(void)
+static void monitor_iothread_init(void)

 {
 {

-    return iothread_get_aio_context(mon_iothread);
+    mon_iothread = iothread_create("mon_iothread", &error_abort);

 }
 
 }
 

-static void monitor_iothread_init(void)
+void monitor_init_globals(void)

 {
 {

-    mon_iothread = iothread_create("mon_iothread", &error_abort);
+    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
 
     /*
      * The dispatcher BH must run in the main loop thread, since we


@@ -4458,16 +4479,6 @@ static void monitor_iothread_init(void)
                                    NULL);
 }
 
                                    NULL);
 }
 

-void monitor_init_globals(void)
-{
-    monitor_init_qmp_commands();
-    monitor_qapi_event_init();
-    sortcmdlist();
-    qemu_mutex_init(&monitor_lock);
-    qemu_mutex_init(&mon_fdsets_lock);
-    monitor_iothread_init();
-}
-

 /* These functions just adapt the readline interface in a typesafe way.  We
  * could cast function pointers but that discards compiler checks.
  */
 /* These functions just adapt the readline interface in a typesafe way.  We
  * could cast function pointers but that discards compiler checks.
  */


@@ -4486,19 +4497,29 @@ static void monitor_readline_flush(void *opaque)
 }
 
 /*
 }
 
 /*

- * Print to current monitor if we have one, else to stderr.
+ * Print to current monitor if we have one, else to stream.

  * TODO should return int, so callers can calculate width, but that
  * requires surgery to monitor_vprintf().  Left for another day.
  */
  * TODO should return int, so callers can calculate width, but that
  * requires surgery to monitor_vprintf().  Left for another day.
  */

-void error_vprintf(const char *fmt, va_list ap)
+void monitor_vfprintf(FILE *stream, const char *fmt, va_list ap)

 {
     if (cur_mon && !monitor_cur_is_qmp()) {
         monitor_vprintf(cur_mon, fmt, ap);
     } else {
 {
     if (cur_mon && !monitor_cur_is_qmp()) {
         monitor_vprintf(cur_mon, fmt, ap);
     } else {

-        vfprintf(stderr, fmt, ap);
+        vfprintf(stream, fmt, ap);

     }
 }
 
     }
 }
 

+/*
+ * Print to current monitor if we have one, else to stderr.
+ * TODO should return int, so callers can calculate width, but that
+ * requires surgery to monitor_vprintf().  Left for another day.
+ */
+void error_vprintf(const char *fmt, va_list ap)
+{
+    monitor_vfprintf(stderr, fmt, ap);
+}
+

 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
 {
     if (cur_mon && !monitor_cur_is_qmp()) {
 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
 {
     if (cur_mon && !monitor_cur_is_qmp()) {


@@ -4511,8 +4532,21 @@ void error_vprintf_unless_qmp(const char *fmt, va_list ap)
 static void monitor_list_append(Monitor *mon)
 {
     qemu_mutex_lock(&monitor_lock);
 static void monitor_list_append(Monitor *mon)
 {
     qemu_mutex_lock(&monitor_lock);

-    QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
+    /*
+     * 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);
     qemu_mutex_unlock(&monitor_lock);

+
+    if (mon) {
+        monitor_data_destroy(mon);
+        g_free(mon);
+    }

 }
 
 static void monitor_qmp_setup_handlers_bh(void *opaque)
 }
 
 static void monitor_qmp_setup_handlers_bh(void *opaque)


@@ -4521,7 +4555,7 @@ static void monitor_qmp_setup_handlers_bh(void *opaque)
     GMainContext *context;
 
     assert(mon->use_io_thread);
     GMainContext *context;
 
     assert(mon->use_io_thread);

-    context = monitor_get_io_context();
+    context = iothread_get_g_main_context(mon_iothread);

     assert(context);
     qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
                              monitor_qmp_event, NULL, mon, context, true);
     assert(context);
     qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
                              monitor_qmp_event, NULL, mon, context, true);


@@ -4532,21 +4566,12 @@ void monitor_init(Chardev *chr, int flags)
 {
     Monitor *mon = g_malloc(sizeof(*mon));
     bool use_readline = flags & MONITOR_USE_READLINE;
 {
     Monitor *mon = g_malloc(sizeof(*mon));
     bool use_readline = flags & MONITOR_USE_READLINE;

-    bool use_oob = flags & MONITOR_USE_OOB;
-
-    if (use_oob) {
-        if (CHARDEV_IS_MUX(chr)) {
-            error_report("Monitor out-of-band is not supported with "
-                         "MUX typed chardev backend");
-            exit(1);
-        }
-        if (use_readline) {
-            error_report("Monitor out-of-band is only supported by QMP");
-            exit(1);
-        }
-    }

 
 

-    monitor_data_init(mon, false, use_oob);
+    /* Note: we run QMP monitor in I/O thread when @chr supports that */
+    monitor_data_init(mon, false,
+                      (flags & MONITOR_USE_CONTROL)
+                      && qemu_chr_has_feature(chr,
+                                              QEMU_CHAR_FEATURE_GCONTEXT));

 
     qemu_chr_fe_init(&mon->chr, chr, &error_abort);
     mon->flags = flags;
 
     qemu_chr_fe_init(&mon->chr, chr, &error_abort);
     mon->flags = flags;


@@ -4573,7 +4598,7 @@ void monitor_init(Chardev *chr, int flags)
              * since chardev might be running in the monitor I/O
              * thread.  Schedule a bottom half.
              */
              * since chardev might be running in the monitor I/O
              * thread.  Schedule a bottom half.
              */

-            aio_bh_schedule_oneshot(monitor_get_aio_context(),
+            aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),

                                     monitor_qmp_setup_handlers_bh, mon);
             /* The bottom half will add @mon to @mon_list */
             return;
                                     monitor_qmp_setup_handlers_bh, mon);
             /* The bottom half will add @mon to @mon_list */
             return;


@@ -4592,22 +4617,27 @@ void monitor_init(Chardev *chr, int flags)
 
 void monitor_cleanup(void)
 {
 
 void monitor_cleanup(void)
 {

-    Monitor *mon, *next;
-

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

-    iothread_stop(mon_iothread);
+    if (mon_iothread) {
+        iothread_stop(mon_iothread);
+    }

 
     /* Flush output buffers and destroy monitors */
     qemu_mutex_lock(&monitor_lock);
 
     /* Flush output buffers and destroy monitors */
     qemu_mutex_lock(&monitor_lock);

-    QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
+    monitor_destroyed = true;
+    while (!QTAILQ_EMPTY(&mon_list)) {
+        Monitor *mon = QTAILQ_FIRST(&mon_list);

         QTAILQ_REMOVE(&mon_list, mon, entry);
         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);
         monitor_flush(mon);
         monitor_data_destroy(mon);

+        qemu_mutex_lock(&monitor_lock);

         g_free(mon);
     }
     qemu_mutex_unlock(&monitor_lock);
         g_free(mon);
     }
     qemu_mutex_unlock(&monitor_lock);


@@ -4615,9 +4645,10 @@ void monitor_cleanup(void)
     /* QEMUBHs needs to be deleted before destroying the I/O thread */
     qemu_bh_delete(qmp_dispatcher_bh);
     qmp_dispatcher_bh = NULL;
     /* QEMUBHs needs to be deleted before destroying the I/O thread */
     qemu_bh_delete(qmp_dispatcher_bh);
     qmp_dispatcher_bh = NULL;

-
-    iothread_destroy(mon_iothread);
-    mon_iothread = NULL;
+    if (mon_iothread) {
+        iothread_destroy(mon_iothread);
+        mon_iothread = NULL;
+    }

 }
 
 QemuOptsList qemu_mon_opts = {
 }
 
 QemuOptsList qemu_mon_opts = {


@@ -4634,9 +4665,6 @@ QemuOptsList qemu_mon_opts = {
         },{
             .name = "pretty",
             .type = QEMU_OPT_BOOL,
         },{
             .name = "pretty",
             .type = QEMU_OPT_BOOL,

-        },{
-            .name = "x-oob",
-            .type = QEMU_OPT_BOOL,

         },
         { /* end of list */ }
     },
         },
         { /* end of list */ }
     },