[PATCH v3 17/23] monitor: Rename MonitorQMP @mon -> @qmon

["Philippe Mathieu-Daudé" <philmd@oss.qualcomm.com>]

Mechanical change to sanitize using the following patterns:

  MonitorQMP *qmon  (this patch)
  MonitorHMP *hmon  (following one)
  Monitor *mon

Rename @mon (and @qmp_mon) as @qmon when the type is MonitorQMP.

Signed-off-by: Philippe Mathieu-Daudé <philmd@oss.qualcomm.com>
---
 monitor/monitor-internal.h |   4 +-
 monitor/qmp-cmds-control.c |  18 +--
 monitor/qmp.c              | 256 ++++++++++++++++++-------------------
 3 files changed, 139 insertions(+), 139 deletions(-)

diff --git a/monitor/monitor-internal.h b/monitor/monitor-internal.h
index bc0932c425a..cfbb3e5ecea 100644
--- a/monitor/monitor-internal.h
+++ b/monitor/monitor-internal.h
@@ -216,8 +216,8 @@ void monitor_list_append(Monitor *mon);
 void monitor_fdsets_cleanup(void);
 int monitor_set_cpu(Monitor *mon, int cpu_index);
 
-void qmp_send_response(MonitorQMP *mon, const QDict *rsp);
-void monitor_data_destroy_qmp(MonitorQMP *mon);
+void qmp_send_response(MonitorQMP *qmon, const QDict *rsp);
+void monitor_data_destroy_qmp(MonitorQMP *qmon);
 void coroutine_fn monitor_qmp_dispatcher_co(void *data);
 void qmp_dispatcher_co_wake(void);
 
diff --git a/monitor/qmp-cmds-control.c b/monitor/qmp-cmds-control.c
index 8fe0876a3da..45f4fe4f6fb 100644
--- a/monitor/qmp-cmds-control.c
+++ b/monitor/qmp-cmds-control.c
@@ -39,7 +39,7 @@
  * On success, set mon->qmp.capab[], and return true.
  * On error, set @errp, and return false.
  */
-static bool qmp_caps_accept(MonitorQMP *mon, QMPCapabilityList *list,
+static bool qmp_caps_accept(MonitorQMP *qmon, QMPCapabilityList *list,
                             Error **errp)
 {
     GString *unavailable = NULL;
@@ -48,7 +48,7 @@ static bool qmp_caps_accept(MonitorQMP *mon, QMPCapabilityList *list,
     memset(capab, 0, sizeof(capab));
 
     for (; list; list = list->next) {
-        if (!mon->capab_offered[list->value]) {
+        if (!qmon->capab_offered[list->value]) {
             if (!unavailable) {
                 unavailable = g_string_new(QMPCapability_str(list->value));
             } else {
@@ -65,27 +65,27 @@ static bool qmp_caps_accept(MonitorQMP *mon, QMPCapabilityList *list,
         return false;
     }
 
-    memcpy(mon->capab, capab, sizeof(capab));
+    memcpy(qmon->capab, capab, sizeof(capab));
     return true;
 }
 
 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
                           Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(monitor_cur());
+    MonitorQMP *qmon = MONITOR_QMP(monitor_cur());
 
-    if (mon->commands == &qmp_commands) {
+    if (qmon->commands == &qmp_commands) {
         error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
                   "Capabilities negotiation is already complete, command "
                   "ignored");
         return;
     }
 
-    if (!qmp_caps_accept(mon, enable, errp)) {
+    if (!qmp_caps_accept(qmon, enable, errp)) {
         return;
     }
 
-    mon->commands = &qmp_commands;
+    qmon->commands = &qmp_commands;
 }
 
 VersionInfo *qmp_query_version(Error **errp)
@@ -118,9 +118,9 @@ static void query_commands_cb(const QmpCommand *cmd, void *opaque)
 CommandInfoList *qmp_query_commands(Error **errp)
 {
     CommandInfoList *list = NULL;
-    MonitorQMP *mon = MONITOR_QMP(monitor_cur());
+    MonitorQMP *qmon = MONITOR_QMP(monitor_cur());
 
-    qmp_for_each_command(mon->commands, query_commands_cb, &list);
+    qmp_for_each_command(qmon->commands, query_commands_cb, &list);
 
     return list;
 }
diff --git a/monitor/qmp.c b/monitor/qmp.c
index aec03157750..d6ce734916e 100644
--- a/monitor/qmp.c
+++ b/monitor/qmp.c
@@ -79,44 +79,44 @@ static MonitorQMP *qmp_dispatcher_current_mon;
 
 OBJECT_DEFINE_TYPE(MonitorQMP, monitor_qmp, MONITOR_QMP, MONITOR);
 
-static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon);
+static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *qmon);
 
 static void monitor_qmp_finalize(Object *obj)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    json_message_parser_destroy(&mon->parser);
-    qemu_mutex_destroy(&mon->qmp_queue_lock);
-    monitor_qmp_cleanup_req_queue_locked(mon);
-    g_queue_free(mon->qmp_requests);
+    json_message_parser_destroy(&qmon->parser);
+    qemu_mutex_destroy(&qmon->qmp_queue_lock);
+    monitor_qmp_cleanup_req_queue_locked(qmon);
+    g_queue_free(qmon->qmp_requests);
 }
 
 static bool monitor_qmp_get_pretty(Object *obj, Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    return mon->pretty;
+    return qmon->pretty;
 }
 
 static void monitor_qmp_set_pretty(Object *obj, bool val, Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    mon->pretty = val;
+    qmon->pretty = val;
 }
 
 static int monitor_qmp_get_close_action(Object *obj, Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    return mon->close_action;
+    return qmon->close_action;
 }
 
 static void monitor_qmp_set_close_action(Object *obj, int val, Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    mon->close_action = val;
+    qmon->close_action = val;
 }
 
 static void monitor_qmp_emit_event(Monitor *mon, QAPIEvent event, QDict *qdict);
@@ -150,25 +150,25 @@ static void monitor_qmp_class_init(ObjectClass *cls, const void *data)
 static void handle_qmp_command(void *opaque, QObject *req, Error *err);
 static void monitor_qmp_init(Object *obj)
 {
-    MonitorQMP *mon = MONITOR_QMP(obj);
+    MonitorQMP *qmon = MONITOR_QMP(obj);
 
-    qemu_mutex_init(&mon->qmp_queue_lock);
-    mon->qmp_requests = g_queue_new();
+    qemu_mutex_init(&qmon->qmp_queue_lock);
+    qmon->qmp_requests = g_queue_new();
 
-    json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
+    json_message_parser_init(&qmon->parser, handle_qmp_command, qmon, NULL);
 }
 
 static void monitor_qmp_emit_event(Monitor *mon, QAPIEvent event, QDict *qdict)
 {
-    MonitorQMP *qmp = MONITOR_QMP(mon);
+    MonitorQMP *qmon = MONITOR_QMP(mon);
 
     WITH_QEMU_LOCK_GUARD(&mon->mon_lock) {
-        if (qmp->commands == &qmp_cap_negotiation_commands) {
+        if (qmon->commands == &qmp_cap_negotiation_commands) {
             return;
         }
     }
 
-    qmp_send_response(qmp, qdict);
+    qmp_send_response(qmon, qdict);
 }
 
 static bool monitor_qmp_requires_iothread(const Monitor *mon)
@@ -177,17 +177,17 @@ static bool monitor_qmp_requires_iothread(const Monitor *mon)
                                 QEMU_CHAR_FEATURE_GCONTEXT);
 }
 
-static bool qmp_oob_enabled(MonitorQMP *mon)
+static bool qmp_oob_enabled(MonitorQMP *qmon)
 {
-    return mon->capab[QMP_CAPABILITY_OOB];
+    return qmon->capab[QMP_CAPABILITY_OOB];
 }
 
-static void monitor_qmp_caps_reset(MonitorQMP *mon)
+static void monitor_qmp_caps_reset(MonitorQMP *qmon)
 {
-    memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
-    memset(mon->capab, 0, sizeof(mon->capab));
-    mon->capab_offered[QMP_CAPABILITY_OOB] =
-        monitor_requires_iothread(MONITOR(mon));
+    memset(qmon->capab_offered, 0, sizeof(qmon->capab_offered));
+    memset(qmon->capab, 0, sizeof(qmon->capab));
+    qmon->capab_offered[QMP_CAPABILITY_OOB] =
+        monitor_requires_iothread(MONITOR(qmon));
 }
 
 static void qmp_request_free(QMPRequest *req)
@@ -198,22 +198,22 @@ static void qmp_request_free(QMPRequest *req)
 }
 
 /* Caller must hold mon->qmp.qmp_queue_lock */
-static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
+static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *qmon)
 {
-    while (!g_queue_is_empty(mon->qmp_requests)) {
-        qmp_request_free(g_queue_pop_head(mon->qmp_requests));
+    while (!g_queue_is_empty(qmon->qmp_requests)) {
+        qmp_request_free(g_queue_pop_head(qmon->qmp_requests));
     }
 }
 
-static void monitor_qmp_drain_queue(MonitorQMP *mon)
+static void monitor_qmp_drain_queue(MonitorQMP *qmon)
 {
-    QEMU_LOCK_GUARD(&mon->qmp_queue_lock);
-    monitor_qmp_cleanup_req_queue_locked(mon);
+    QEMU_LOCK_GUARD(&qmon->qmp_queue_lock);
+    monitor_qmp_cleanup_req_queue_locked(qmon);
 }
 
-static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
+static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *qmon)
 {
-    QEMU_LOCK_GUARD(&mon->qmp_queue_lock);
+    QEMU_LOCK_GUARD(&qmon->qmp_queue_lock);
 
     /*
      * Same condition as in monitor_qmp_dispatcher_co(), but before
@@ -221,11 +221,11 @@ static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
      * Also, the queue should not be empty either, otherwise the
      * monitor hasn't been suspended yet (or was already resumed).
      */
-    bool need_resume = (!qmp_oob_enabled(mon) ||
-        mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
-        && !g_queue_is_empty(mon->qmp_requests);
+    bool need_resume = (!qmp_oob_enabled(qmon) ||
+        qmon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
+        && !g_queue_is_empty(qmon->qmp_requests);
 
-    monitor_qmp_cleanup_req_queue_locked(mon);
+    monitor_qmp_cleanup_req_queue_locked(qmon);
 
     if (need_resume) {
         /*
@@ -237,22 +237,22 @@ static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
          * when we get here while the monitor is suspended.  An
          * unfortunately timed CHR_EVENT_CLOSED can do the trick.
          */
-        monitor_resume(&mon->parent_obj);
+        monitor_resume(&qmon->parent_obj);
     }
 
 }
 
-void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
+void qmp_send_response(MonitorQMP *qmon, const QDict *rsp)
 {
     const QObject *data = QOBJECT(rsp);
     GString *json;
 
-    json = qobject_to_json_pretty(data, mon->pretty);
+    json = qobject_to_json_pretty(data, qmon->pretty);
     assert(json != NULL);
-    trace_monitor_qmp_respond(mon, json->str);
+    trace_monitor_qmp_respond(qmon, json->str);
 
     g_string_append_c(json, '\n');
-    monitor_puts(&mon->parent_obj, json->str);
+    monitor_puts(&qmon->parent_obj, json->str);
 
     g_string_free(json, true);
 }
@@ -262,10 +262,10 @@ void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
  * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
  * Nothing is emitted then.
  */
-static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
+static void monitor_qmp_respond(MonitorQMP *qmon, QDict *rsp)
 {
     if (rsp) {
-        qmp_send_response(mon, rsp);
+        qmp_send_response(qmon, rsp);
     }
 }
 
@@ -273,15 +273,15 @@ static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
  * Runs outside of coroutine context for OOB commands, but in
  * coroutine context for everything else.
  */
-static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
+static void monitor_qmp_dispatch(MonitorQMP *qmon, QObject *req)
 {
     QDict *rsp;
     QDict *error;
 
-    rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon),
-                       &mon->parent_obj);
+    rsp = qmp_dispatch(qmon->commands, req, qmp_oob_enabled(qmon),
+                       &qmon->parent_obj);
 
-    if (mon->commands == &qmp_cap_negotiation_commands) {
+    if (qmon->commands == &qmp_cap_negotiation_commands) {
         error = qdict_get_qdict(rsp, "error");
         if (error
             && !g_strcmp0(qdict_get_try_str(error, "class"),
@@ -293,7 +293,7 @@ static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
         }
     }
 
-    monitor_qmp_respond(mon, rsp);
+    monitor_qmp_respond(qmon, rsp);
     qobject_unref(rsp);
 }
 
@@ -313,22 +313,22 @@ static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
 {
     QMPRequest *req_obj = NULL;
     Monitor *mon;
-    MonitorQMP *qmp_mon;
+    MonitorQMP *qmon;
 
     QTAILQ_FOREACH(mon, &mon_list, entry) {
-        qmp_mon = MONITOR_QMP(
+        qmon = MONITOR_QMP(
             object_dynamic_cast(OBJECT(mon), TYPE_MONITOR_QMP));
-        if (!qmp_mon) {
+        if (!qmon) {
             continue;
         }
 
-        qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
-        req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
+        qemu_mutex_lock(&qmon->qmp_queue_lock);
+        req_obj = g_queue_pop_head(qmon->qmp_requests);
         if (req_obj) {
             /* With the lock of corresponding queue held */
             break;
         }
-        qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
+        qemu_mutex_unlock(&qmon->qmp_queue_lock);
     }
 
     if (req_obj) {
@@ -391,7 +391,7 @@ void coroutine_fn monitor_qmp_dispatcher_co(void *data)
     QMPRequest *req_obj;
     QDict *rsp;
     bool oob_enabled;
-    MonitorQMP *mon;
+    MonitorQMP *qmon;
 
     while ((req_obj = monitor_qmp_dispatcher_pop_any()) != NULL) {
         trace_monitor_qmp_in_band_dequeue(req_obj,
@@ -401,8 +401,8 @@ void coroutine_fn monitor_qmp_dispatcher_co(void *data)
          * @req_obj has a request, we hold req_obj->mon->qmp_queue_lock
          */
 
-        mon = req_obj->mon;
-        qmp_dispatcher_current_mon = mon;
+        qmon = req_obj->mon;
+        qmp_dispatcher_current_mon = qmon;
 
         /*
          * We need to resume the monitor if handle_qmp_command()
@@ -415,17 +415,17 @@ void coroutine_fn monitor_qmp_dispatcher_co(void *data)
          * We need to save qmp_oob_enabled() for later, because
          * qmp_qmp_capabilities() can change it.
          */
-        oob_enabled = qmp_oob_enabled(mon);
+        oob_enabled = qmp_oob_enabled(qmon);
         if (oob_enabled
-            && mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
-            monitor_resume(&mon->parent_obj);
+            && qmon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
+            monitor_resume(&qmon->parent_obj);
         }
 
         /*
          * Drop the queue mutex now, before yielding, otherwise we might
          * deadlock if the main thread tries to lock it.
          */
-        qemu_mutex_unlock(&mon->qmp_queue_lock);
+        qemu_mutex_unlock(&qmon->qmp_queue_lock);
 
         if (qatomic_xchg(&qmp_dispatcher_co_busy, true) == true) {
             /*
@@ -448,18 +448,18 @@ void coroutine_fn monitor_qmp_dispatcher_co(void *data)
                 trace_monitor_qmp_cmd_in_band(id_json->str);
                 g_string_free(id_json, true);
             }
-            monitor_qmp_dispatch(mon, req_obj->req);
+            monitor_qmp_dispatch(qmon, req_obj->req);
         } else {
             assert(req_obj->err);
             trace_monitor_qmp_err_in_band(error_get_pretty(req_obj->err));
             rsp = qmp_error_response(req_obj->err);
             req_obj->err = NULL;
-            monitor_qmp_respond(mon, rsp);
+            monitor_qmp_respond(qmon, rsp);
             qobject_unref(rsp);
         }
 
         if (!oob_enabled) {
-            monitor_resume(&mon->parent_obj);
+            monitor_resume(&qmon->parent_obj);
         }
 
         qmp_request_free(req_obj);
@@ -481,7 +481,7 @@ void qmp_dispatcher_co_wake(void)
 
 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 {
-    MonitorQMP *mon = opaque;
+    MonitorQMP *qmon = opaque;
     QDict *qdict = qobject_to(QDict, req);
     QMPRequest *req_obj;
 
@@ -489,7 +489,7 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 
     if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
         GString *req_json = qobject_to_json(req);
-        trace_handle_qmp_command(mon, req_json->str);
+        trace_handle_qmp_command(qmon, req_json->str);
         g_string_free(req_json, true);
     }
 
@@ -503,18 +503,18 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
             trace_monitor_qmp_cmd_out_of_band(id_json->str);
             g_string_free(id_json, true);
         }
-        monitor_qmp_dispatch(mon, req);
+        monitor_qmp_dispatch(qmon, req);
         qobject_unref(req);
         return;
     }
 
     req_obj = g_new0(QMPRequest, 1);
-    req_obj->mon = mon;
+    req_obj->mon = qmon;
     req_obj->req = req;
     req_obj->err = err;
 
     /* Protect qmp_requests and fetching its length. */
-    WITH_QEMU_LOCK_GUARD(&mon->qmp_queue_lock) {
+    WITH_QEMU_LOCK_GUARD(&qmon->qmp_queue_lock) {
 
         /*
          * Suspend the monitor when we can't queue more requests after
@@ -523,9 +523,9 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
          * Note that when OOB is disabled, we queue at most one command,
          * for backward compatibility.
          */
-        if (!qmp_oob_enabled(mon) ||
-            mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
-            monitor_suspend(&mon->parent_obj);
+        if (!qmp_oob_enabled(qmon) ||
+            qmon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
+            monitor_suspend(&qmon->parent_obj);
         }
 
         /*
@@ -533,10 +533,10 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
          * handled in time order.  Ownership for req_obj, req,
          * etc. will be delivered to the handler side.
          */
-        trace_monitor_qmp_in_band_enqueue(req_obj, mon,
-                                          mon->qmp_requests->length);
-        assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
-        g_queue_push_tail(mon->qmp_requests, req_obj);
+        trace_monitor_qmp_in_band_enqueue(req_obj, qmon,
+                                          qmon->qmp_requests->length);
+        assert(qmon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
+        g_queue_push_tail(qmon->qmp_requests, req_obj);
     }
 
     /* Kick the dispatcher routine */
@@ -545,12 +545,12 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 
 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
 {
-    MonitorQMP *mon = opaque;
+    MonitorQMP *qmon = opaque;
 
-    json_message_parser_feed(&mon->parser, (const char *) buf, size);
+    json_message_parser_feed(&qmon->parser, (const char *) buf, size);
 }
 
-static QDict *qmp_greeting(MonitorQMP *mon)
+static QDict *qmp_greeting(MonitorQMP *qmon)
 {
     QList *cap_list = qlist_new();
     QObject *ver = NULL;
@@ -562,7 +562,7 @@ static QDict *qmp_greeting(MonitorQMP *mon)
     qobject_unref(args);
 
     for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
-        if (mon->capab_offered[cap]) {
+        if (qmon->capab_offered[cap]) {
             qlist_append_str(cap_list, QMPCapability_str(cap));
         }
     }
@@ -574,10 +574,10 @@ static QDict *qmp_greeting(MonitorQMP *mon)
 
 static void monitor_qmp_self_delete_bh(void *opaque)
 {
-    MonitorQMP *mon = opaque;
+    MonitorQMP *qmon = opaque;
     const char *mon_id = object_get_canonical_path_component(
-        OBJECT(mon));
-    g_autofree char *chardev_id = g_strdup(mon->parent_obj.chardev_id);
+        OBJECT(qmon));
+    g_autofree char *chardev_id = g_strdup(qmon->parent_obj.chardev_id);
     Error *local_error = NULL;
 
     if (!mon_id) {
@@ -587,13 +587,13 @@ static void monitor_qmp_self_delete_bh(void *opaque)
          * mon from monitor_qmp_event but it is already
          * unparented.
          */
-        object_unref(mon);
+        object_unref(qmon);
         return;
     }
 
     user_creatable_del(mon_id, &local_error);
     /* Pairs with ref from monitor_qmp_event */
-    object_unref(mon);
+    object_unref(qmon);
     if (local_error != NULL) {
         error_report_err(local_error);
     } else {
@@ -604,25 +604,25 @@ static void monitor_qmp_self_delete_bh(void *opaque)
 static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
 {
     QDict *data;
-    MonitorQMP *mon = opaque;
+    MonitorQMP *qmon = opaque;
 
     /*
      * Protect against race if a client drops & quickly
      * reconnects - we'll have the delete BH scheduled
      * so must not honour a new open request
      */
-    if (mon->delete_pending) {
+    if (qmon->delete_pending) {
         return;
     }
 
     switch (event) {
     case CHR_EVENT_OPENED:
-        WITH_QEMU_LOCK_GUARD(&mon->parent_obj.mon_lock) {
-            mon->commands = &qmp_cap_negotiation_commands;
-            monitor_qmp_caps_reset(mon);
+        WITH_QEMU_LOCK_GUARD(&qmon->parent_obj.mon_lock) {
+            qmon->commands = &qmp_cap_negotiation_commands;
+            monitor_qmp_caps_reset(qmon);
         }
-        data = qmp_greeting(mon);
-        qmp_send_response(mon, data);
+        data = qmp_greeting(qmon);
+        qmp_send_response(qmon, data);
         qobject_unref(data);
         break;
     case CHR_EVENT_CLOSED:
@@ -632,16 +632,16 @@ static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
          * stdio, it's possible that stdout is still open when stdin
          * is closed.
          */
-        monitor_qmp_cleanup_queue_and_resume(mon);
-        json_message_parser_destroy(&mon->parser);
-        json_message_parser_init(&mon->parser, handle_qmp_command,
-                                 mon, NULL);
+        monitor_qmp_cleanup_queue_and_resume(qmon);
+        json_message_parser_destroy(&qmon->parser);
+        json_message_parser_init(&qmon->parser, handle_qmp_command,
+                                 qmon, NULL);
         monitor_fdsets_cleanup();
-        switch (mon->close_action) {
+        switch (qmon->close_action) {
         case MONITOR_QMP_CLOSE_ACTION_NONE:
             break;
         case MONITOR_QMP_CLOSE_ACTION_DELETE:
-            mon->delete_pending = true;
+            qmon->delete_pending = true;
             /*
              * Do NOT run in the AIO context associated with the
              * monitor. We need to run in the default AIO context
@@ -652,9 +652,9 @@ static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
              * with the BH by processing an explicit 'object-del'.
              * Will be released by monitor_qmp_self_delete_bh
              */
-            object_ref(mon);
+            object_ref(qmon);
             aio_bh_schedule_oneshot(qemu_get_aio_context(),
-                                    monitor_qmp_self_delete_bh, mon);
+                                    monitor_qmp_self_delete_bh, qmon);
             break;
         default:
             g_assert_not_reached();
@@ -668,24 +668,24 @@ static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
     }
 }
 
-static bool monitor_qmp_dispatcher_is_servicing(MonitorQMP *mon)
+static bool monitor_qmp_dispatcher_is_servicing(MonitorQMP *qmon)
 {
-    return qmp_dispatcher_current_mon == mon;
+    return qmp_dispatcher_current_mon == qmon;
 }
 
 static void monitor_qmp_setup_handlers_bh(void *opaque)
 {
-    MonitorQMP *mon = opaque;
+    MonitorQMP *qmon = opaque;
     GMainContext *context;
 
-    assert(monitor_requires_iothread(MONITOR(mon)));
+    assert(monitor_requires_iothread(MONITOR(qmon)));
     context = iothread_get_g_main_context(mon_iothread);
     assert(context);
-    qemu_chr_fe_set_handlers(&mon->parent_obj.chr, monitor_can_read,
+    qemu_chr_fe_set_handlers(&qmon->parent_obj.chr, monitor_can_read,
                              monitor_qmp_read, monitor_qmp_event,
-                             NULL, &mon->parent_obj, context, true);
-    monitor_list_append(&mon->parent_obj);
-    qatomic_set(&mon->setup_pending, false);
+                             NULL, &qmon->parent_obj, context, true);
+    monitor_list_append(&qmon->parent_obj);
+    qatomic_set(&qmon->setup_pending, false);
 }
 
 void monitor_new_qmp(const char *id, const char *chardev_id,
@@ -703,11 +703,11 @@ void monitor_new_qmp(const char *id, const char *chardev_id,
 
 static void monitor_qmp_complete(UserCreatable *uc, Error **errp)
 {
-    MonitorQMP *mon = MONITOR_QMP(uc);
+    MonitorQMP *qmon = MONITOR_QMP(uc);
     UserCreatableClass *ucc_parent =
         USER_CREATABLE_CLASS(
             object_class_get_parent(
-                OBJECT_CLASS(MONITOR_QMP_GET_CLASS(mon))));
+                OBJECT_CLASS(MONITOR_QMP_GET_CLASS(qmon))));
     ERRP_GUARD();
 
     ucc_parent->complete(uc, errp);
@@ -715,33 +715,33 @@ static void monitor_qmp_complete(UserCreatable *uc, Error **errp)
         return;
     }
 
-    qemu_chr_fe_set_echo(&mon->parent_obj.chr, true);
+    qemu_chr_fe_set_echo(&qmon->parent_obj.chr, true);
 
-    if (monitor_requires_iothread(MONITOR(mon))) {
+    if (monitor_requires_iothread(MONITOR(qmon))) {
         /*
          * Make sure the old iowatch is gone.  It's possible when
          * e.g. the chardev is in client mode, with wait=on.
          */
-        remove_fd_in_watch(mon->parent_obj.chr.chr);
+        remove_fd_in_watch(qmon->parent_obj.chr.chr);
         /*
          * Clean up listener IO sources early to prevent racy fd
          * handling between the main thread and the I/O thread.
          */
-        remove_listener_fd_in_watch(mon->parent_obj.chr.chr);
+        remove_listener_fd_in_watch(qmon->parent_obj.chr.chr);
         /*
          * We can't call qemu_chr_fe_set_handlers() directly here
          * since chardev might be running in the monitor I/O
          * thread.  Schedule a bottom half.
          */
-        mon->setup_pending = true;
+        qmon->setup_pending = true;
         aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
-                                monitor_qmp_setup_handlers_bh, mon);
+                                monitor_qmp_setup_handlers_bh, qmon);
         /* The bottom half will add @mon to @mon_list */
     } else {
-        qemu_chr_fe_set_handlers(&mon->parent_obj.chr, monitor_can_read,
+        qemu_chr_fe_set_handlers(&qmon->parent_obj.chr, monitor_can_read,
                                  monitor_qmp_read, monitor_qmp_event,
-                                 NULL, &mon->parent_obj, NULL, true);
-        monitor_list_append(&mon->parent_obj);
+                                 NULL, &qmon->parent_obj, NULL, true);
+        monitor_list_append(&qmon->parent_obj);
     }
 }
 
@@ -753,14 +753,14 @@ static void monitor_qmp_iothread_quiesce(void *opaque)
 static bool monitor_qmp_prepare_delete(UserCreatable *uc, Error **errp)
 {
     Monitor *mon = MONITOR(uc);
-    MonitorQMP *qmp = MONITOR_QMP(uc);
+    MonitorQMP *qmon = MONITOR_QMP(uc);
 
-    if (monitor_qmp_dispatcher_is_servicing(qmp)) {
+    if (monitor_qmp_dispatcher_is_servicing(qmon)) {
         error_setg(errp, "Cannot delete the current QMP monitor");
         return false;
     }
 
-    if (qatomic_read(&qmp->setup_pending)) {
+    if (qatomic_read(&qmon->setup_pending)) {
         error_setg(errp, "monitor is still initializing");
         return false;
     }
@@ -779,7 +779,7 @@ static bool monitor_qmp_prepare_delete(UserCreatable *uc, Error **errp)
                              NULL, NULL, true);
 
     /* Drain requests from any in-flight monitor_qmp_read(). */
-    monitor_qmp_drain_queue(qmp);
+    monitor_qmp_drain_queue(qmon);
 
     WITH_QEMU_LOCK_GUARD(&mon->mon_lock) {
         /* Disable flushes before cancel -- gcontext is already wrong. */
@@ -794,7 +794,7 @@ static bool monitor_qmp_prepare_delete(UserCreatable *uc, Error **errp)
     }
 
     /* Catch requests from a racing monitor_qmp_read(). */
-    monitor_qmp_drain_queue(qmp);
+    monitor_qmp_drain_queue(qmon);
     monitor_fdsets_cleanup();
 
     return true;
-- 
2.53.0