Move QMP infrastructure from monitor/misc.c to monitor/qmp.c. This is
code that can be shared for all targets, so compile it only once.
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 QMP
and the monitor core can be cleaned up later.
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
include/monitor/monitor.h | 1 +
monitor/monitor_int.h | 30 ++-
monitor/misc.c | 394 +------------------------------------
monitor/qmp.c | 404 ++++++++++++++++++++++++++++++++++++++
Makefile.objs | 1 +
monitor/Makefile.objs | 1 +
6 files changed, 445 insertions(+), 386 deletions(-)
create mode 100644 monitor/qmp.c
diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h
index 1ba354f811..7bbab05320 100644
--- a/include/monitor/monitor.h
+++ b/include/monitor/monitor.h
@@ -21,6 +21,7 @@ bool monitor_cur_is_qmp(void);
void monitor_init_globals(void);
void monitor_init(Chardev *chr, int flags);
+void monitor_init_qmp(Chardev *chr, int flags);
void monitor_cleanup(void);
int monitor_suspend(Monitor *mon);
diff --git a/monitor/monitor_int.h b/monitor/monitor_int.h
index ab87013b6f..487618392f 100644
--- a/monitor/monitor_int.h
+++ b/monitor/monitor_int.h
@@ -30,10 +30,11 @@
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/json-parser.h"
-#include "qapi/qapi-commands.h"
+#include "qapi/qmp/dispatch.h"
#include "qemu/readline.h"
#include "chardev/char-fe.h"
+#include "sysemu/iothread.h"
/*
* Supported types:
@@ -144,4 +145,31 @@ typedef struct {
GQueue *qmp_requests;
} MonitorQMP;
+/**
+ * Is @mon a QMP monitor?
+ */
+static inline bool monitor_is_qmp(const Monitor *mon)
+{
+ return (mon->flags & MONITOR_USE_CONTROL);
+}
+
+typedef QTAILQ_HEAD(MonitorList, Monitor) MonitorList;
+extern IOThread *mon_iothread;
+extern QEMUBH *qmp_dispatcher_bh;
+extern QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
+extern QemuMutex monitor_lock;
+extern MonitorList mon_list;
+extern int mon_refcount;
+
+int monitor_puts(Monitor *mon, const char *str);
+void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
+ bool use_io_thread);
+int monitor_can_read(void *opaque);
+void monitor_list_append(Monitor *mon);
+void monitor_fdsets_cleanup(void);
+
+void qmp_send_response(MonitorQMP *mon, const QDict *rsp);
+void monitor_data_destroy_qmp(MonitorQMP *mon);
+void monitor_qmp_bh_dispatcher(void *data);
+
#endif
diff --git a/monitor/misc.c b/monitor/misc.c
index 6ae7561105..6c67f0978c 100644
--- a/monitor/misc.c
+++ b/monitor/misc.c
@@ -140,51 +140,29 @@ IOThread *mon_iothread;
/* Bottom half to dispatch the requests received from I/O thread */
QEMUBH *qmp_dispatcher_bh;
-struct QMPRequest {
- /* Owner of the request */
- MonitorQMP *mon;
- /*
- * Request object to be handled or Error to be reported
- * (exactly one of them is non-null)
- */
- QObject *req;
- Error *err;
-};
-typedef struct QMPRequest QMPRequest;
-
/* QMP checker flags */
#define QMP_ACCEPT_UNKNOWNS 1
/* Protects mon_list, monitor_qapi_event_state, monitor_destroyed. */
-static QemuMutex monitor_lock;
+QemuMutex monitor_lock;
static GHashTable *monitor_qapi_event_state;
-static QTAILQ_HEAD(, Monitor) mon_list;
+MonitorList mon_list;
static bool monitor_destroyed;
/* Protects mon_fdsets */
static QemuMutex mon_fdsets_lock;
static QLIST_HEAD(, MonFdset) mon_fdsets;
-static int mon_refcount;
+int mon_refcount;
static mon_cmd_t mon_cmds[];
static mon_cmd_t info_cmds[];
-QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
-
__thread Monitor *cur_mon;
static void monitor_command_cb(void *opaque, const char *cmdline,
void *readline_opaque);
-/**
- * Is @mon a QMP monitor?
- */
-static inline bool monitor_is_qmp(const Monitor *mon)
-{
- return (mon->flags & MONITOR_USE_CONTROL);
-}
-
/**
* Is @mon is using readline?
* Note: not all HMP monitors use readline, e.g., gdbserver has a
@@ -243,28 +221,6 @@ int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
}
}
-static void qmp_request_free(QMPRequest *req)
-{
- qobject_unref(req->req);
- error_free(req->err);
- g_free(req);
-}
-
-/* Caller must hold mon->qmp.qmp_queue_lock */
-static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
-{
- while (!g_queue_is_empty(mon->qmp_requests)) {
- qmp_request_free(g_queue_pop_head(mon->qmp_requests));
- }
-}
-
-static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
-{
- qemu_mutex_lock(&mon->qmp_queue_lock);
- monitor_qmp_cleanup_req_queue_locked(mon);
- qemu_mutex_unlock(&mon->qmp_queue_lock);
-}
-
static void monitor_flush_locked(Monitor *mon);
@@ -324,7 +280,7 @@ void monitor_flush(Monitor *mon)
}
/* flush at every end of line */
-static int monitor_puts(Monitor *mon, const char *str)
+int monitor_puts(Monitor *mon, const char *str)
{
int i;
char c;
@@ -374,21 +330,6 @@ int monitor_printf(Monitor *mon, const char *fmt, ...)
return ret;
}
-static void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
-{
- const QObject *data = QOBJECT(rsp);
- QString *json;
-
- json = mon->common.flags & MONITOR_USE_PRETTY ?
- qobject_to_json_pretty(data) : qobject_to_json(data);
- assert(json != NULL);
-
- qstring_append_chr(json, '\n');
- monitor_puts(&mon->common, qstring_get_str(json));
-
- qobject_unref(json);
-}
-
static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
/* Limit guest-triggerable events to 1 per second */
[QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
@@ -603,8 +544,8 @@ static void handle_hmp_command(MonitorHMP *mon, const char *cmdline);
static void monitor_iothread_init(void);
-static void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
- bool use_io_thread)
+void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
+ bool use_io_thread)
{
if (use_io_thread && !mon_iothread) {
monitor_iothread_init();
@@ -625,14 +566,6 @@ static void monitor_data_init_hmp(MonitorHMP *mon, int flags, bool skip_flush)
mon->cmd_table = mon_cmds;
}
-static void monitor_data_destroy_qmp(MonitorQMP *mon)
-{
- 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);
-}
-
static void monitor_data_destroy(Monitor *mon)
{
g_free(mon->mon_cpu_path);
@@ -1069,18 +1002,6 @@ static void monitor_init_qmp_commands(void)
qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
}
-static bool qmp_oob_enabled(MonitorQMP *mon)
-{
- return mon->capab[QMP_CAPABILITY_OOB];
-}
-
-static void monitor_qmp_caps_reset(MonitorQMP *mon)
-{
- memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
- memset(mon->capab, 0, sizeof(mon->capab));
- mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
-}
-
/*
* Accept QMP capabilities in @list for @mon.
* On success, set mon->qmp.capab[], and return true.
@@ -2251,7 +2172,7 @@ static void monitor_fdset_cleanup(MonFdset *mon_fdset)
}
}
-static void monitor_fdsets_cleanup(void)
+void monitor_fdsets_cleanup(void)
{
MonFdset *mon_fdset;
MonFdset *mon_fdset_next;
@@ -4029,209 +3950,13 @@ cleanup:
free_cmdline_args(args, nb_args);
}
-static int monitor_can_read(void *opaque)
+int monitor_can_read(void *opaque)
{
Monitor *mon = opaque;
return !atomic_mb_read(&mon->suspend_cnt);
}
-/*
- * Emit QMP response @rsp with ID @id to @mon.
- * 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)
-{
- if (rsp) {
- qmp_send_response(mon, rsp);
- }
-}
-
-static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
-{
- Monitor *old_mon;
- QDict *rsp;
- QDict *error;
-
- old_mon = cur_mon;
- cur_mon = &mon->common;
-
- rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
-
- cur_mon = old_mon;
-
- if (mon->commands == &qmp_cap_negotiation_commands) {
- error = qdict_get_qdict(rsp, "error");
- if (error
- && !g_strcmp0(qdict_get_try_str(error, "class"),
- QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
- /* Provide a more useful error message */
- qdict_del(error, "desc");
- qdict_put_str(error, "desc", "Expecting capabilities negotiation"
- " with 'qmp_capabilities'");
- }
- }
-
- monitor_qmp_respond(mon, rsp);
- qobject_unref(rsp);
-}
-
-/*
- * Pop a QMP request from a monitor request queue.
- * Return the request, or NULL all request queues are empty.
- * We are using round-robin fashion to pop the request, to avoid
- * 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 qmp_mon->qmp_queue_lock held, and the caller is responsible
- * to release it.
- */
-static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
-{
- QMPRequest *req_obj = NULL;
- Monitor *mon;
- MonitorQMP *qmp_mon;
-
- qemu_mutex_lock(&monitor_lock);
-
- QTAILQ_FOREACH(mon, &mon_list, entry) {
- if (!monitor_is_qmp(mon)) {
- continue;
- }
-
- qmp_mon = container_of(mon, MonitorQMP, common);
- qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
- req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
- if (req_obj) {
- /* With the lock of corresponding queue held */
- break;
- }
- qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
- }
-
- if (req_obj) {
- /*
- * We found one request on the monitor. Degrade this monitor's
- * priority to lowest by re-inserting it to end of queue.
- */
- QTAILQ_REMOVE(&mon_list, mon, entry);
- QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
- }
-
- qemu_mutex_unlock(&monitor_lock);
-
- return req_obj;
-}
-
-static void monitor_qmp_bh_dispatcher(void *data)
-{
- QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
- QDict *rsp;
- bool need_resume;
- MonitorQMP *mon;
-
- if (!req_obj) {
- return;
- }
-
- mon = req_obj->mon;
- /* qmp_oob_enabled() might change after "qmp_capabilities" */
- need_resume = !qmp_oob_enabled(mon) ||
- mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
- qemu_mutex_unlock(&mon->qmp_queue_lock);
- if (req_obj->req) {
- QDict *qdict = qobject_to(QDict, req_obj->req);
- QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
- trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
- monitor_qmp_dispatch(mon, req_obj->req);
- } else {
- assert(req_obj->err);
- rsp = qmp_error_response(req_obj->err);
- req_obj->err = NULL;
- monitor_qmp_respond(mon, rsp);
- qobject_unref(rsp);
- }
-
- if (need_resume) {
- /* Pairs with the monitor_suspend() in handle_qmp_command() */
- monitor_resume(&mon->common);
- }
- qmp_request_free(req_obj);
-
- /* Reschedule instead of looping so the main loop stays responsive */
- qemu_bh_schedule(qmp_dispatcher_bh);
-}
-
-static void handle_qmp_command(void *opaque, QObject *req, Error *err)
-{
- MonitorQMP *mon = opaque;
- QObject *id = NULL;
- QDict *qdict;
- QMPRequest *req_obj;
-
- assert(!req != !err);
-
- qdict = qobject_to(QDict, req);
- if (qdict) {
- id = qdict_get(qdict, "id");
- } /* else will fail qmp_dispatch() */
-
- if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
- QString *req_json = qobject_to_json(req);
- trace_handle_qmp_command(mon, qstring_get_str(req_json));
- qobject_unref(req_json);
- }
-
- if (qdict && qmp_is_oob(qdict)) {
- /* OOB commands are executed immediately */
- trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
- monitor_qmp_dispatch(mon, req);
- qobject_unref(req);
- return;
- }
-
- req_obj = g_new0(QMPRequest, 1);
- req_obj->mon = mon;
- req_obj->req = req;
- req_obj->err = err;
-
- /* Protect qmp_requests and fetching its length. */
- qemu_mutex_lock(&mon->qmp_queue_lock);
-
- /*
- * 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) ||
- mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
- monitor_suspend(&mon->common);
- }
-
- /*
- * Put the request to the end of queue so that requests will be
- * handled in time order. Ownership for req_obj, req,
- * etc. will be delivered to the handler side.
- */
- assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
- g_queue_push_tail(mon->qmp_requests, req_obj);
- qemu_mutex_unlock(&mon->qmp_queue_lock);
-
- /* Kick the dispatcher routine */
- qemu_bh_schedule(qmp_dispatcher_bh);
-}
-
-static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
-{
- MonitorQMP *mon = opaque;
-
- json_message_parser_feed(&mon->parser, (const char *) buf, size);
-}
-
static void monitor_read(void *opaque, const uint8_t *buf, int size)
{
MonitorHMP *mon;
@@ -4318,56 +4043,6 @@ void monitor_resume(Monitor *mon)
trace_monitor_suspend(mon, -1);
}
-static QDict *qmp_greeting(MonitorQMP *mon)
-{
- QList *cap_list = qlist_new();
- QObject *ver = NULL;
- QMPCapability cap;
-
- qmp_marshal_query_version(NULL, &ver, NULL);
-
- for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
- if (mon->capab_offered[cap]) {
- qlist_append_str(cap_list, QMPCapability_str(cap));
- }
- }
-
- return qdict_from_jsonf_nofail(
- "{'QMP': {'version': %p, 'capabilities': %p}}",
- ver, cap_list);
-}
-
-static void monitor_qmp_event(void *opaque, int event)
-{
- QDict *data;
- MonitorQMP *mon = opaque;
-
- switch (event) {
- case CHR_EVENT_OPENED:
- mon->commands = &qmp_cap_negotiation_commands;
- monitor_qmp_caps_reset(mon);
- data = qmp_greeting(mon);
- qmp_send_response(mon, data);
- qobject_unref(data);
- mon_refcount++;
- break;
- case CHR_EVENT_CLOSED:
- /*
- * Note: this is only useful when the output of the chardev
- * backend is still open. For example, when the backend is
- * stdio, it's possible that stdout is still open when stdin
- * is closed.
- */
- monitor_qmp_cleanup_queues(mon);
- json_message_parser_destroy(&mon->parser);
- json_message_parser_init(&mon->parser, handle_qmp_command,
- mon, NULL);
- mon_refcount--;
- monitor_fdsets_cleanup();
- break;
- }
-}
-
static void monitor_event(void *opaque, int event)
{
Monitor *mon = opaque;
@@ -4503,7 +4178,7 @@ int error_vprintf_unless_qmp(const char *fmt, va_list ap)
return -1;
}
-static void monitor_list_append(Monitor *mon)
+void monitor_list_append(Monitor *mon)
{
qemu_mutex_lock(&monitor_lock);
/*
@@ -4523,57 +4198,6 @@ static void monitor_list_append(Monitor *mon)
}
}
-static void monitor_qmp_setup_handlers_bh(void *opaque)
-{
- MonitorQMP *mon = opaque;
- GMainContext *context;
-
- assert(mon->common.use_io_thread);
- context = iothread_get_g_main_context(mon_iothread);
- assert(context);
- qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
- monitor_qmp_read, monitor_qmp_event,
- NULL, &mon->common, context, true);
- monitor_list_append(&mon->common);
-}
-
-static void monitor_init_qmp(Chardev *chr, int flags)
-{
- MonitorQMP *mon = g_malloc0(sizeof(*mon));
-
- /* Note: we run QMP monitor in I/O thread when @chr supports that */
- monitor_data_init(&mon->common, flags, false,
- qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
-
- qemu_mutex_init(&mon->qmp_queue_lock);
- mon->qmp_requests = g_queue_new();
-
- qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
- qemu_chr_fe_set_echo(&mon->common.chr, true);
-
- json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
- if (mon->common.use_io_thread) {
- /*
- * 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(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.
- */
- 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 */
- } else {
- qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
- monitor_qmp_read, monitor_qmp_event,
- NULL, &mon->common, NULL, true);
- monitor_list_append(&mon->common);
- }
-}
-
static void monitor_init_hmp(Chardev *chr, int flags)
{
MonitorHMP *mon = g_malloc0(sizeof(*mon));
diff --git a/monitor/qmp.c b/monitor/qmp.c
new file mode 100644
index 0000000000..74e72cf5b8
--- /dev/null
+++ b/monitor/qmp.c
@@ -0,0 +1,404 @@
+/*
+ * 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 "chardev/char-io.h"
+
+#include "qapi/error.h"
+#include "qapi/qmp/qjson.h"
+#include "qapi/qmp/qstring.h"
+#include "qapi/qmp/qlist.h"
+#include "qapi/qapi-commands-misc.h"
+
+#include "trace-root.h"
+
+struct QMPRequest {
+ /* Owner of the request */
+ MonitorQMP *mon;
+ /*
+ * Request object to be handled or Error to be reported
+ * (exactly one of them is non-null)
+ */
+ QObject *req;
+ Error *err;
+};
+typedef struct QMPRequest QMPRequest;
+
+QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
+
+static bool qmp_oob_enabled(MonitorQMP *mon)
+{
+ return mon->capab[QMP_CAPABILITY_OOB];
+}
+
+static void monitor_qmp_caps_reset(MonitorQMP *mon)
+{
+ memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
+ memset(mon->capab, 0, sizeof(mon->capab));
+ mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
+}
+
+static void qmp_request_free(QMPRequest *req)
+{
+ qobject_unref(req->req);
+ error_free(req->err);
+ g_free(req);
+}
+
+/* Caller must hold mon->qmp.qmp_queue_lock */
+static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
+{
+ while (!g_queue_is_empty(mon->qmp_requests)) {
+ qmp_request_free(g_queue_pop_head(mon->qmp_requests));
+ }
+}
+
+static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
+{
+ qemu_mutex_lock(&mon->qmp_queue_lock);
+ monitor_qmp_cleanup_req_queue_locked(mon);
+ qemu_mutex_unlock(&mon->qmp_queue_lock);
+}
+
+void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
+{
+ const QObject *data = QOBJECT(rsp);
+ QString *json;
+
+ json = mon->common.flags & MONITOR_USE_PRETTY ?
+ qobject_to_json_pretty(data) : qobject_to_json(data);
+ assert(json != NULL);
+
+ qstring_append_chr(json, '\n');
+ monitor_puts(&mon->common, qstring_get_str(json));
+
+ qobject_unref(json);
+}
+
+/*
+ * Emit QMP response @rsp with ID @id to @mon.
+ * 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)
+{
+ if (rsp) {
+ qmp_send_response(mon, rsp);
+ }
+}
+
+static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
+{
+ Monitor *old_mon;
+ QDict *rsp;
+ QDict *error;
+
+ old_mon = cur_mon;
+ cur_mon = &mon->common;
+
+ rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
+
+ cur_mon = old_mon;
+
+ if (mon->commands == &qmp_cap_negotiation_commands) {
+ error = qdict_get_qdict(rsp, "error");
+ if (error
+ && !g_strcmp0(qdict_get_try_str(error, "class"),
+ QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
+ /* Provide a more useful error message */
+ qdict_del(error, "desc");
+ qdict_put_str(error, "desc", "Expecting capabilities negotiation"
+ " with 'qmp_capabilities'");
+ }
+ }
+
+ monitor_qmp_respond(mon, rsp);
+ qobject_unref(rsp);
+}
+
+/*
+ * Pop a QMP request from a monitor request queue.
+ * Return the request, or NULL all request queues are empty.
+ * We are using round-robin fashion to pop the request, to avoid
+ * 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 qmp_mon->qmp_queue_lock held, and the caller is responsible
+ * to release it.
+ */
+static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
+{
+ QMPRequest *req_obj = NULL;
+ Monitor *mon;
+ MonitorQMP *qmp_mon;
+
+ qemu_mutex_lock(&monitor_lock);
+
+ QTAILQ_FOREACH(mon, &mon_list, entry) {
+ if (!monitor_is_qmp(mon)) {
+ continue;
+ }
+
+ qmp_mon = container_of(mon, MonitorQMP, common);
+ qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
+ req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
+ if (req_obj) {
+ /* With the lock of corresponding queue held */
+ break;
+ }
+ qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
+ }
+
+ if (req_obj) {
+ /*
+ * We found one request on the monitor. Degrade this monitor's
+ * priority to lowest by re-inserting it to end of queue.
+ */
+ QTAILQ_REMOVE(&mon_list, mon, entry);
+ QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
+ }
+
+ qemu_mutex_unlock(&monitor_lock);
+
+ return req_obj;
+}
+
+void monitor_qmp_bh_dispatcher(void *data)
+{
+ QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
+ QDict *rsp;
+ bool need_resume;
+ MonitorQMP *mon;
+
+ if (!req_obj) {
+ return;
+ }
+
+ mon = req_obj->mon;
+ /* qmp_oob_enabled() might change after "qmp_capabilities" */
+ need_resume = !qmp_oob_enabled(mon) ||
+ mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
+ qemu_mutex_unlock(&mon->qmp_queue_lock);
+ if (req_obj->req) {
+ QDict *qdict = qobject_to(QDict, req_obj->req);
+ QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
+ trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
+ monitor_qmp_dispatch(mon, req_obj->req);
+ } else {
+ assert(req_obj->err);
+ rsp = qmp_error_response(req_obj->err);
+ req_obj->err = NULL;
+ monitor_qmp_respond(mon, rsp);
+ qobject_unref(rsp);
+ }
+
+ if (need_resume) {
+ /* Pairs with the monitor_suspend() in handle_qmp_command() */
+ monitor_resume(&mon->common);
+ }
+ qmp_request_free(req_obj);
+
+ /* Reschedule instead of looping so the main loop stays responsive */
+ qemu_bh_schedule(qmp_dispatcher_bh);
+}
+
+static void handle_qmp_command(void *opaque, QObject *req, Error *err)
+{
+ MonitorQMP *mon = opaque;
+ QObject *id = NULL;
+ QDict *qdict;
+ QMPRequest *req_obj;
+
+ assert(!req != !err);
+
+ qdict = qobject_to(QDict, req);
+ if (qdict) {
+ id = qdict_get(qdict, "id");
+ } /* else will fail qmp_dispatch() */
+
+ if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
+ QString *req_json = qobject_to_json(req);
+ trace_handle_qmp_command(mon, qstring_get_str(req_json));
+ qobject_unref(req_json);
+ }
+
+ if (qdict && qmp_is_oob(qdict)) {
+ /* OOB commands are executed immediately */
+ trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
+ monitor_qmp_dispatch(mon, req);
+ qobject_unref(req);
+ return;
+ }
+
+ req_obj = g_new0(QMPRequest, 1);
+ req_obj->mon = mon;
+ req_obj->req = req;
+ req_obj->err = err;
+
+ /* Protect qmp_requests and fetching its length. */
+ qemu_mutex_lock(&mon->qmp_queue_lock);
+
+ /*
+ * 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) ||
+ mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
+ monitor_suspend(&mon->common);
+ }
+
+ /*
+ * Put the request to the end of queue so that requests will be
+ * handled in time order. Ownership for req_obj, req,
+ * etc. will be delivered to the handler side.
+ */
+ assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
+ g_queue_push_tail(mon->qmp_requests, req_obj);
+ qemu_mutex_unlock(&mon->qmp_queue_lock);
+
+ /* Kick the dispatcher routine */
+ qemu_bh_schedule(qmp_dispatcher_bh);
+}
+
+static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
+{
+ MonitorQMP *mon = opaque;
+
+ json_message_parser_feed(&mon->parser, (const char *) buf, size);
+}
+
+static QDict *qmp_greeting(MonitorQMP *mon)
+{
+ QList *cap_list = qlist_new();
+ QObject *ver = NULL;
+ QMPCapability cap;
+
+ qmp_marshal_query_version(NULL, &ver, NULL);
+
+ for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
+ if (mon->capab_offered[cap]) {
+ qlist_append_str(cap_list, QMPCapability_str(cap));
+ }
+ }
+
+ return qdict_from_jsonf_nofail(
+ "{'QMP': {'version': %p, 'capabilities': %p}}",
+ ver, cap_list);
+}
+
+static void monitor_qmp_event(void *opaque, int event)
+{
+ QDict *data;
+ MonitorQMP *mon = opaque;
+
+ switch (event) {
+ case CHR_EVENT_OPENED:
+ mon->commands = &qmp_cap_negotiation_commands;
+ monitor_qmp_caps_reset(mon);
+ data = qmp_greeting(mon);
+ qmp_send_response(mon, data);
+ qobject_unref(data);
+ mon_refcount++;
+ break;
+ case CHR_EVENT_CLOSED:
+ /*
+ * Note: this is only useful when the output of the chardev
+ * backend is still open. For example, when the backend is
+ * stdio, it's possible that stdout is still open when stdin
+ * is closed.
+ */
+ monitor_qmp_cleanup_queues(mon);
+ json_message_parser_destroy(&mon->parser);
+ json_message_parser_init(&mon->parser, handle_qmp_command,
+ mon, NULL);
+ mon_refcount--;
+ monitor_fdsets_cleanup();
+ break;
+ }
+}
+
+void monitor_data_destroy_qmp(MonitorQMP *mon)
+{
+ 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);
+}
+
+static void monitor_qmp_setup_handlers_bh(void *opaque)
+{
+ MonitorQMP *mon = opaque;
+ GMainContext *context;
+
+ assert(mon->common.use_io_thread);
+ context = iothread_get_g_main_context(mon_iothread);
+ assert(context);
+ qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
+ monitor_qmp_read, monitor_qmp_event,
+ NULL, &mon->common, context, true);
+ monitor_list_append(&mon->common);
+}
+
+void monitor_init_qmp(Chardev *chr, int flags)
+{
+ MonitorQMP *mon = g_malloc0(sizeof(*mon));
+
+ /* Note: we run QMP monitor in I/O thread when @chr supports that */
+ monitor_data_init(&mon->common, flags, false,
+ qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
+
+ qemu_mutex_init(&mon->qmp_queue_lock);
+ mon->qmp_requests = g_queue_new();
+
+ qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
+ qemu_chr_fe_set_echo(&mon->common.chr, true);
+
+ json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
+ if (mon->common.use_io_thread) {
+ /*
+ * 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(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.
+ */
+ 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 */
+ } else {
+ qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
+ monitor_qmp_read, monitor_qmp_event,
+ NULL, &mon->common, NULL, true);
+ monitor_list_append(&mon->common);
+ }
+}
diff --git a/Makefile.objs b/Makefile.objs
index c8337fa34b..76c5b525f9 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -46,6 +46,7 @@ ifeq ($(CONFIG_SOFTMMU),y)
common-obj-y = blockdev.o blockdev-nbd.o block/
common-obj-y += bootdevice.o iothread.o
common-obj-y += job-qmp.o
+common-obj-y += monitor/
common-obj-y += net/
common-obj-y += qdev-monitor.o device-hotplug.o
common-obj-$(CONFIG_WIN32) += os-win32.o
diff --git a/monitor/Makefile.objs b/monitor/Makefile.objs
index e783b0616b..d04d58b583 100644
--- a/monitor/Makefile.objs
+++ b/monitor/Makefile.objs
@@ -1 +1,2 @@
obj-y += misc.o
+common-obj-y += qmp.o
--
2.20.1
* Kevin Wolf (kwolf@redhat.com) wrote:
> Move QMP infrastructure from monitor/misc.c to monitor/qmp.c. This is
> code that can be shared for all targets, so compile it only once.
>
> 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 QMP
> and the monitor core can be cleaned up later.
>
> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
> ---
> include/monitor/monitor.h | 1 +
> monitor/monitor_int.h | 30 ++-
> monitor/misc.c | 394 +------------------------------------
> monitor/qmp.c | 404 ++++++++++++++++++++++++++++++++++++++
> Makefile.objs | 1 +
> monitor/Makefile.objs | 1 +
> 6 files changed, 445 insertions(+), 386 deletions(-)
> create mode 100644 monitor/qmp.c
>
> diff --git a/include/monitor/monitor.h b/include/monitor/monitor.h
> index 1ba354f811..7bbab05320 100644
> --- a/include/monitor/monitor.h
> +++ b/include/monitor/monitor.h
> @@ -21,6 +21,7 @@ bool monitor_cur_is_qmp(void);
>
> void monitor_init_globals(void);
> void monitor_init(Chardev *chr, int flags);
> +void monitor_init_qmp(Chardev *chr, int flags);
> void monitor_cleanup(void);
>
> int monitor_suspend(Monitor *mon);
> diff --git a/monitor/monitor_int.h b/monitor/monitor_int.h
> index ab87013b6f..487618392f 100644
> --- a/monitor/monitor_int.h
> +++ b/monitor/monitor_int.h
> @@ -30,10 +30,11 @@
>
> #include "qapi/qmp/qdict.h"
> #include "qapi/qmp/json-parser.h"
> -#include "qapi/qapi-commands.h"
> +#include "qapi/qmp/dispatch.h"
>
> #include "qemu/readline.h"
> #include "chardev/char-fe.h"
> +#include "sysemu/iothread.h"
>
> /*
> * Supported types:
> @@ -144,4 +145,31 @@ typedef struct {
> GQueue *qmp_requests;
> } MonitorQMP;
>
> +/**
> + * Is @mon a QMP monitor?
> + */
> +static inline bool monitor_is_qmp(const Monitor *mon)
> +{
> + return (mon->flags & MONITOR_USE_CONTROL);
> +}
> +
> +typedef QTAILQ_HEAD(MonitorList, Monitor) MonitorList;
> +extern IOThread *mon_iothread;
> +extern QEMUBH *qmp_dispatcher_bh;
> +extern QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
> +extern QemuMutex monitor_lock;
> +extern MonitorList mon_list;
> +extern int mon_refcount;
> +
> +int monitor_puts(Monitor *mon, const char *str);
> +void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
> + bool use_io_thread);
> +int monitor_can_read(void *opaque);
> +void monitor_list_append(Monitor *mon);
> +void monitor_fdsets_cleanup(void);
> +
> +void qmp_send_response(MonitorQMP *mon, const QDict *rsp);
> +void monitor_data_destroy_qmp(MonitorQMP *mon);
> +void monitor_qmp_bh_dispatcher(void *data);
> +
> #endif
> diff --git a/monitor/misc.c b/monitor/misc.c
> index 6ae7561105..6c67f0978c 100644
> --- a/monitor/misc.c
> +++ b/monitor/misc.c
> @@ -140,51 +140,29 @@ IOThread *mon_iothread;
> /* Bottom half to dispatch the requests received from I/O thread */
> QEMUBH *qmp_dispatcher_bh;
>
> -struct QMPRequest {
> - /* Owner of the request */
> - MonitorQMP *mon;
> - /*
> - * Request object to be handled or Error to be reported
> - * (exactly one of them is non-null)
> - */
> - QObject *req;
> - Error *err;
> -};
> -typedef struct QMPRequest QMPRequest;
> -
> /* QMP checker flags */
> #define QMP_ACCEPT_UNKNOWNS 1
>
> /* Protects mon_list, monitor_qapi_event_state, monitor_destroyed. */
> -static QemuMutex monitor_lock;
> +QemuMutex monitor_lock;
> static GHashTable *monitor_qapi_event_state;
> -static QTAILQ_HEAD(, Monitor) mon_list;
> +MonitorList mon_list;
> static bool monitor_destroyed;
>
> /* Protects mon_fdsets */
> static QemuMutex mon_fdsets_lock;
> static QLIST_HEAD(, MonFdset) mon_fdsets;
>
> -static int mon_refcount;
> +int mon_refcount;
>
> static mon_cmd_t mon_cmds[];
> static mon_cmd_t info_cmds[];
>
> -QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
> -
> __thread Monitor *cur_mon;
>
> static void monitor_command_cb(void *opaque, const char *cmdline,
> void *readline_opaque);
>
> -/**
> - * Is @mon a QMP monitor?
> - */
> -static inline bool monitor_is_qmp(const Monitor *mon)
> -{
> - return (mon->flags & MONITOR_USE_CONTROL);
> -}
> -
> /**
> * Is @mon is using readline?
> * Note: not all HMP monitors use readline, e.g., gdbserver has a
> @@ -243,28 +221,6 @@ int monitor_read_password(MonitorHMP *mon, ReadLineFunc *readline_func,
> }
> }
>
> -static void qmp_request_free(QMPRequest *req)
> -{
> - qobject_unref(req->req);
> - error_free(req->err);
> - g_free(req);
> -}
> -
> -/* Caller must hold mon->qmp.qmp_queue_lock */
> -static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
> -{
> - while (!g_queue_is_empty(mon->qmp_requests)) {
> - qmp_request_free(g_queue_pop_head(mon->qmp_requests));
> - }
> -}
> -
> -static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
> -{
> - qemu_mutex_lock(&mon->qmp_queue_lock);
> - monitor_qmp_cleanup_req_queue_locked(mon);
> - qemu_mutex_unlock(&mon->qmp_queue_lock);
> -}
> -
>
> static void monitor_flush_locked(Monitor *mon);
>
> @@ -324,7 +280,7 @@ void monitor_flush(Monitor *mon)
> }
>
> /* flush at every end of line */
> -static int monitor_puts(Monitor *mon, const char *str)
> +int monitor_puts(Monitor *mon, const char *str)
> {
> int i;
> char c;
> @@ -374,21 +330,6 @@ int monitor_printf(Monitor *mon, const char *fmt, ...)
> return ret;
> }
>
> -static void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
> -{
> - const QObject *data = QOBJECT(rsp);
> - QString *json;
> -
> - json = mon->common.flags & MONITOR_USE_PRETTY ?
> - qobject_to_json_pretty(data) : qobject_to_json(data);
> - assert(json != NULL);
> -
> - qstring_append_chr(json, '\n');
> - monitor_puts(&mon->common, qstring_get_str(json));
> -
> - qobject_unref(json);
> -}
> -
> static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
> /* Limit guest-triggerable events to 1 per second */
> [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
> @@ -603,8 +544,8 @@ static void handle_hmp_command(MonitorHMP *mon, const char *cmdline);
>
> static void monitor_iothread_init(void);
>
> -static void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
> - bool use_io_thread)
> +void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
> + bool use_io_thread)
> {
> if (use_io_thread && !mon_iothread) {
> monitor_iothread_init();
> @@ -625,14 +566,6 @@ static void monitor_data_init_hmp(MonitorHMP *mon, int flags, bool skip_flush)
> mon->cmd_table = mon_cmds;
> }
>
> -static void monitor_data_destroy_qmp(MonitorQMP *mon)
> -{
> - 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);
> -}
> -
> static void monitor_data_destroy(Monitor *mon)
> {
> g_free(mon->mon_cpu_path);
> @@ -1069,18 +1002,6 @@ static void monitor_init_qmp_commands(void)
> qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
> }
>
> -static bool qmp_oob_enabled(MonitorQMP *mon)
> -{
> - return mon->capab[QMP_CAPABILITY_OOB];
> -}
> -
> -static void monitor_qmp_caps_reset(MonitorQMP *mon)
> -{
> - memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
> - memset(mon->capab, 0, sizeof(mon->capab));
> - mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
> -}
> -
> /*
> * Accept QMP capabilities in @list for @mon.
> * On success, set mon->qmp.capab[], and return true.
> @@ -2251,7 +2172,7 @@ static void monitor_fdset_cleanup(MonFdset *mon_fdset)
> }
> }
>
> -static void monitor_fdsets_cleanup(void)
> +void monitor_fdsets_cleanup(void)
> {
> MonFdset *mon_fdset;
> MonFdset *mon_fdset_next;
> @@ -4029,209 +3950,13 @@ cleanup:
> free_cmdline_args(args, nb_args);
> }
>
> -static int monitor_can_read(void *opaque)
> +int monitor_can_read(void *opaque)
> {
> Monitor *mon = opaque;
>
> return !atomic_mb_read(&mon->suspend_cnt);
> }
>
> -/*
> - * Emit QMP response @rsp with ID @id to @mon.
> - * 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)
> -{
> - if (rsp) {
> - qmp_send_response(mon, rsp);
> - }
> -}
> -
> -static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
> -{
> - Monitor *old_mon;
> - QDict *rsp;
> - QDict *error;
> -
> - old_mon = cur_mon;
> - cur_mon = &mon->common;
> -
> - rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
> -
> - cur_mon = old_mon;
> -
> - if (mon->commands == &qmp_cap_negotiation_commands) {
> - error = qdict_get_qdict(rsp, "error");
> - if (error
> - && !g_strcmp0(qdict_get_try_str(error, "class"),
> - QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
> - /* Provide a more useful error message */
> - qdict_del(error, "desc");
> - qdict_put_str(error, "desc", "Expecting capabilities negotiation"
> - " with 'qmp_capabilities'");
> - }
> - }
> -
> - monitor_qmp_respond(mon, rsp);
> - qobject_unref(rsp);
> -}
> -
> -/*
> - * Pop a QMP request from a monitor request queue.
> - * Return the request, or NULL all request queues are empty.
> - * We are using round-robin fashion to pop the request, to avoid
> - * 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 qmp_mon->qmp_queue_lock held, and the caller is responsible
> - * to release it.
> - */
> -static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
> -{
> - QMPRequest *req_obj = NULL;
> - Monitor *mon;
> - MonitorQMP *qmp_mon;
> -
> - qemu_mutex_lock(&monitor_lock);
> -
> - QTAILQ_FOREACH(mon, &mon_list, entry) {
> - if (!monitor_is_qmp(mon)) {
> - continue;
> - }
> -
> - qmp_mon = container_of(mon, MonitorQMP, common);
> - qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
> - req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
> - if (req_obj) {
> - /* With the lock of corresponding queue held */
> - break;
> - }
> - qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
> - }
> -
> - if (req_obj) {
> - /*
> - * We found one request on the monitor. Degrade this monitor's
> - * priority to lowest by re-inserting it to end of queue.
> - */
> - QTAILQ_REMOVE(&mon_list, mon, entry);
> - QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
> - }
> -
> - qemu_mutex_unlock(&monitor_lock);
> -
> - return req_obj;
> -}
> -
> -static void monitor_qmp_bh_dispatcher(void *data)
> -{
> - QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
> - QDict *rsp;
> - bool need_resume;
> - MonitorQMP *mon;
> -
> - if (!req_obj) {
> - return;
> - }
> -
> - mon = req_obj->mon;
> - /* qmp_oob_enabled() might change after "qmp_capabilities" */
> - need_resume = !qmp_oob_enabled(mon) ||
> - mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
> - qemu_mutex_unlock(&mon->qmp_queue_lock);
> - if (req_obj->req) {
> - QDict *qdict = qobject_to(QDict, req_obj->req);
> - QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
> - trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
> - monitor_qmp_dispatch(mon, req_obj->req);
> - } else {
> - assert(req_obj->err);
> - rsp = qmp_error_response(req_obj->err);
> - req_obj->err = NULL;
> - monitor_qmp_respond(mon, rsp);
> - qobject_unref(rsp);
> - }
> -
> - if (need_resume) {
> - /* Pairs with the monitor_suspend() in handle_qmp_command() */
> - monitor_resume(&mon->common);
> - }
> - qmp_request_free(req_obj);
> -
> - /* Reschedule instead of looping so the main loop stays responsive */
> - qemu_bh_schedule(qmp_dispatcher_bh);
> -}
> -
> -static void handle_qmp_command(void *opaque, QObject *req, Error *err)
> -{
> - MonitorQMP *mon = opaque;
> - QObject *id = NULL;
> - QDict *qdict;
> - QMPRequest *req_obj;
> -
> - assert(!req != !err);
> -
> - qdict = qobject_to(QDict, req);
> - if (qdict) {
> - id = qdict_get(qdict, "id");
> - } /* else will fail qmp_dispatch() */
> -
> - if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
> - QString *req_json = qobject_to_json(req);
> - trace_handle_qmp_command(mon, qstring_get_str(req_json));
> - qobject_unref(req_json);
> - }
> -
> - if (qdict && qmp_is_oob(qdict)) {
> - /* OOB commands are executed immediately */
> - trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
> - monitor_qmp_dispatch(mon, req);
> - qobject_unref(req);
> - return;
> - }
> -
> - req_obj = g_new0(QMPRequest, 1);
> - req_obj->mon = mon;
> - req_obj->req = req;
> - req_obj->err = err;
> -
> - /* Protect qmp_requests and fetching its length. */
> - qemu_mutex_lock(&mon->qmp_queue_lock);
> -
> - /*
> - * 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) ||
> - mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
> - monitor_suspend(&mon->common);
> - }
> -
> - /*
> - * Put the request to the end of queue so that requests will be
> - * handled in time order. Ownership for req_obj, req,
> - * etc. will be delivered to the handler side.
> - */
> - assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
> - g_queue_push_tail(mon->qmp_requests, req_obj);
> - qemu_mutex_unlock(&mon->qmp_queue_lock);
> -
> - /* Kick the dispatcher routine */
> - qemu_bh_schedule(qmp_dispatcher_bh);
> -}
> -
> -static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
> -{
> - MonitorQMP *mon = opaque;
> -
> - json_message_parser_feed(&mon->parser, (const char *) buf, size);
> -}
> -
> static void monitor_read(void *opaque, const uint8_t *buf, int size)
> {
> MonitorHMP *mon;
> @@ -4318,56 +4043,6 @@ void monitor_resume(Monitor *mon)
> trace_monitor_suspend(mon, -1);
> }
>
> -static QDict *qmp_greeting(MonitorQMP *mon)
> -{
> - QList *cap_list = qlist_new();
> - QObject *ver = NULL;
> - QMPCapability cap;
> -
> - qmp_marshal_query_version(NULL, &ver, NULL);
> -
> - for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
> - if (mon->capab_offered[cap]) {
> - qlist_append_str(cap_list, QMPCapability_str(cap));
> - }
> - }
> -
> - return qdict_from_jsonf_nofail(
> - "{'QMP': {'version': %p, 'capabilities': %p}}",
> - ver, cap_list);
> -}
> -
> -static void monitor_qmp_event(void *opaque, int event)
> -{
> - QDict *data;
> - MonitorQMP *mon = opaque;
> -
> - switch (event) {
> - case CHR_EVENT_OPENED:
> - mon->commands = &qmp_cap_negotiation_commands;
> - monitor_qmp_caps_reset(mon);
> - data = qmp_greeting(mon);
> - qmp_send_response(mon, data);
> - qobject_unref(data);
> - mon_refcount++;
> - break;
> - case CHR_EVENT_CLOSED:
> - /*
> - * Note: this is only useful when the output of the chardev
> - * backend is still open. For example, when the backend is
> - * stdio, it's possible that stdout is still open when stdin
> - * is closed.
> - */
> - monitor_qmp_cleanup_queues(mon);
> - json_message_parser_destroy(&mon->parser);
> - json_message_parser_init(&mon->parser, handle_qmp_command,
> - mon, NULL);
> - mon_refcount--;
> - monitor_fdsets_cleanup();
> - break;
> - }
> -}
> -
> static void monitor_event(void *opaque, int event)
> {
> Monitor *mon = opaque;
> @@ -4503,7 +4178,7 @@ int error_vprintf_unless_qmp(const char *fmt, va_list ap)
> return -1;
> }
>
> -static void monitor_list_append(Monitor *mon)
> +void monitor_list_append(Monitor *mon)
> {
> qemu_mutex_lock(&monitor_lock);
> /*
> @@ -4523,57 +4198,6 @@ static void monitor_list_append(Monitor *mon)
> }
> }
>
> -static void monitor_qmp_setup_handlers_bh(void *opaque)
> -{
> - MonitorQMP *mon = opaque;
> - GMainContext *context;
> -
> - assert(mon->common.use_io_thread);
> - context = iothread_get_g_main_context(mon_iothread);
> - assert(context);
> - qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
> - monitor_qmp_read, monitor_qmp_event,
> - NULL, &mon->common, context, true);
> - monitor_list_append(&mon->common);
> -}
> -
> -static void monitor_init_qmp(Chardev *chr, int flags)
> -{
> - MonitorQMP *mon = g_malloc0(sizeof(*mon));
> -
> - /* Note: we run QMP monitor in I/O thread when @chr supports that */
> - monitor_data_init(&mon->common, flags, false,
> - qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
> -
> - qemu_mutex_init(&mon->qmp_queue_lock);
> - mon->qmp_requests = g_queue_new();
> -
> - qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
> - qemu_chr_fe_set_echo(&mon->common.chr, true);
> -
> - json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
> - if (mon->common.use_io_thread) {
> - /*
> - * 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(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.
> - */
> - 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 */
> - } else {
> - qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
> - monitor_qmp_read, monitor_qmp_event,
> - NULL, &mon->common, NULL, true);
> - monitor_list_append(&mon->common);
> - }
> -}
> -
> static void monitor_init_hmp(Chardev *chr, int flags)
> {
> MonitorHMP *mon = g_malloc0(sizeof(*mon));
> diff --git a/monitor/qmp.c b/monitor/qmp.c
> new file mode 100644
> index 0000000000..74e72cf5b8
> --- /dev/null
> +++ b/monitor/qmp.c
> @@ -0,0 +1,404 @@
> +/*
> + * 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 "chardev/char-io.h"
> +
> +#include "qapi/error.h"
> +#include "qapi/qmp/qjson.h"
> +#include "qapi/qmp/qstring.h"
> +#include "qapi/qmp/qlist.h"
> +#include "qapi/qapi-commands-misc.h"
> +
> +#include "trace-root.h"
> +
> +struct QMPRequest {
> + /* Owner of the request */
> + MonitorQMP *mon;
> + /*
> + * Request object to be handled or Error to be reported
> + * (exactly one of them is non-null)
> + */
> + QObject *req;
> + Error *err;
> +};
> +typedef struct QMPRequest QMPRequest;
> +
> +QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
> +
> +static bool qmp_oob_enabled(MonitorQMP *mon)
> +{
> + return mon->capab[QMP_CAPABILITY_OOB];
> +}
> +
> +static void monitor_qmp_caps_reset(MonitorQMP *mon)
> +{
> + memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
> + memset(mon->capab, 0, sizeof(mon->capab));
> + mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
> +}
> +
> +static void qmp_request_free(QMPRequest *req)
> +{
> + qobject_unref(req->req);
> + error_free(req->err);
> + g_free(req);
> +}
> +
> +/* Caller must hold mon->qmp.qmp_queue_lock */
> +static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
> +{
> + while (!g_queue_is_empty(mon->qmp_requests)) {
> + qmp_request_free(g_queue_pop_head(mon->qmp_requests));
> + }
> +}
> +
> +static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
> +{
> + qemu_mutex_lock(&mon->qmp_queue_lock);
> + monitor_qmp_cleanup_req_queue_locked(mon);
> + qemu_mutex_unlock(&mon->qmp_queue_lock);
> +}
> +
> +void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
> +{
> + const QObject *data = QOBJECT(rsp);
> + QString *json;
> +
> + json = mon->common.flags & MONITOR_USE_PRETTY ?
> + qobject_to_json_pretty(data) : qobject_to_json(data);
> + assert(json != NULL);
> +
> + qstring_append_chr(json, '\n');
> + monitor_puts(&mon->common, qstring_get_str(json));
> +
> + qobject_unref(json);
> +}
> +
> +/*
> + * Emit QMP response @rsp with ID @id to @mon.
> + * 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)
> +{
> + if (rsp) {
> + qmp_send_response(mon, rsp);
> + }
> +}
> +
> +static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
> +{
> + Monitor *old_mon;
> + QDict *rsp;
> + QDict *error;
> +
> + old_mon = cur_mon;
> + cur_mon = &mon->common;
> +
> + rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
> +
> + cur_mon = old_mon;
> +
> + if (mon->commands == &qmp_cap_negotiation_commands) {
> + error = qdict_get_qdict(rsp, "error");
> + if (error
> + && !g_strcmp0(qdict_get_try_str(error, "class"),
> + QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
> + /* Provide a more useful error message */
> + qdict_del(error, "desc");
> + qdict_put_str(error, "desc", "Expecting capabilities negotiation"
> + " with 'qmp_capabilities'");
> + }
> + }
> +
> + monitor_qmp_respond(mon, rsp);
> + qobject_unref(rsp);
> +}
> +
> +/*
> + * Pop a QMP request from a monitor request queue.
> + * Return the request, or NULL all request queues are empty.
> + * We are using round-robin fashion to pop the request, to avoid
> + * 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 qmp_mon->qmp_queue_lock held, and the caller is responsible
> + * to release it.
> + */
> +static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
> +{
> + QMPRequest *req_obj = NULL;
> + Monitor *mon;
> + MonitorQMP *qmp_mon;
> +
> + qemu_mutex_lock(&monitor_lock);
> +
> + QTAILQ_FOREACH(mon, &mon_list, entry) {
> + if (!monitor_is_qmp(mon)) {
> + continue;
> + }
> +
> + qmp_mon = container_of(mon, MonitorQMP, common);
> + qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
> + req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
> + if (req_obj) {
> + /* With the lock of corresponding queue held */
> + break;
> + }
> + qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
> + }
> +
> + if (req_obj) {
> + /*
> + * We found one request on the monitor. Degrade this monitor's
> + * priority to lowest by re-inserting it to end of queue.
> + */
> + QTAILQ_REMOVE(&mon_list, mon, entry);
> + QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
> + }
> +
> + qemu_mutex_unlock(&monitor_lock);
> +
> + return req_obj;
> +}
> +
> +void monitor_qmp_bh_dispatcher(void *data)
> +{
> + QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
> + QDict *rsp;
> + bool need_resume;
> + MonitorQMP *mon;
> +
> + if (!req_obj) {
> + return;
> + }
> +
> + mon = req_obj->mon;
> + /* qmp_oob_enabled() might change after "qmp_capabilities" */
> + need_resume = !qmp_oob_enabled(mon) ||
> + mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
> + qemu_mutex_unlock(&mon->qmp_queue_lock);
> + if (req_obj->req) {
> + QDict *qdict = qobject_to(QDict, req_obj->req);
> + QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
> + trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
> + monitor_qmp_dispatch(mon, req_obj->req);
> + } else {
> + assert(req_obj->err);
> + rsp = qmp_error_response(req_obj->err);
> + req_obj->err = NULL;
> + monitor_qmp_respond(mon, rsp);
> + qobject_unref(rsp);
> + }
> +
> + if (need_resume) {
> + /* Pairs with the monitor_suspend() in handle_qmp_command() */
> + monitor_resume(&mon->common);
> + }
> + qmp_request_free(req_obj);
> +
> + /* Reschedule instead of looping so the main loop stays responsive */
> + qemu_bh_schedule(qmp_dispatcher_bh);
> +}
> +
> +static void handle_qmp_command(void *opaque, QObject *req, Error *err)
> +{
> + MonitorQMP *mon = opaque;
> + QObject *id = NULL;
> + QDict *qdict;
> + QMPRequest *req_obj;
> +
> + assert(!req != !err);
> +
> + qdict = qobject_to(QDict, req);
> + if (qdict) {
> + id = qdict_get(qdict, "id");
> + } /* else will fail qmp_dispatch() */
> +
> + if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
> + QString *req_json = qobject_to_json(req);
> + trace_handle_qmp_command(mon, qstring_get_str(req_json));
> + qobject_unref(req_json);
> + }
> +
> + if (qdict && qmp_is_oob(qdict)) {
> + /* OOB commands are executed immediately */
> + trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
> + monitor_qmp_dispatch(mon, req);
> + qobject_unref(req);
> + return;
> + }
> +
> + req_obj = g_new0(QMPRequest, 1);
> + req_obj->mon = mon;
> + req_obj->req = req;
> + req_obj->err = err;
> +
> + /* Protect qmp_requests and fetching its length. */
> + qemu_mutex_lock(&mon->qmp_queue_lock);
> +
> + /*
> + * 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) ||
> + mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
> + monitor_suspend(&mon->common);
> + }
> +
> + /*
> + * Put the request to the end of queue so that requests will be
> + * handled in time order. Ownership for req_obj, req,
> + * etc. will be delivered to the handler side.
> + */
> + assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
> + g_queue_push_tail(mon->qmp_requests, req_obj);
> + qemu_mutex_unlock(&mon->qmp_queue_lock);
> +
> + /* Kick the dispatcher routine */
> + qemu_bh_schedule(qmp_dispatcher_bh);
> +}
> +
> +static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
> +{
> + MonitorQMP *mon = opaque;
> +
> + json_message_parser_feed(&mon->parser, (const char *) buf, size);
> +}
> +
> +static QDict *qmp_greeting(MonitorQMP *mon)
> +{
> + QList *cap_list = qlist_new();
> + QObject *ver = NULL;
> + QMPCapability cap;
> +
> + qmp_marshal_query_version(NULL, &ver, NULL);
> +
> + for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
> + if (mon->capab_offered[cap]) {
> + qlist_append_str(cap_list, QMPCapability_str(cap));
> + }
> + }
> +
> + return qdict_from_jsonf_nofail(
> + "{'QMP': {'version': %p, 'capabilities': %p}}",
> + ver, cap_list);
> +}
> +
> +static void monitor_qmp_event(void *opaque, int event)
> +{
> + QDict *data;
> + MonitorQMP *mon = opaque;
> +
> + switch (event) {
> + case CHR_EVENT_OPENED:
> + mon->commands = &qmp_cap_negotiation_commands;
> + monitor_qmp_caps_reset(mon);
> + data = qmp_greeting(mon);
> + qmp_send_response(mon, data);
> + qobject_unref(data);
> + mon_refcount++;
> + break;
> + case CHR_EVENT_CLOSED:
> + /*
> + * Note: this is only useful when the output of the chardev
> + * backend is still open. For example, when the backend is
> + * stdio, it's possible that stdout is still open when stdin
> + * is closed.
> + */
> + monitor_qmp_cleanup_queues(mon);
> + json_message_parser_destroy(&mon->parser);
> + json_message_parser_init(&mon->parser, handle_qmp_command,
> + mon, NULL);
> + mon_refcount--;
> + monitor_fdsets_cleanup();
> + break;
> + }
> +}
> +
> +void monitor_data_destroy_qmp(MonitorQMP *mon)
> +{
> + 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);
> +}
> +
> +static void monitor_qmp_setup_handlers_bh(void *opaque)
> +{
> + MonitorQMP *mon = opaque;
> + GMainContext *context;
> +
> + assert(mon->common.use_io_thread);
> + context = iothread_get_g_main_context(mon_iothread);
> + assert(context);
> + qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
> + monitor_qmp_read, monitor_qmp_event,
> + NULL, &mon->common, context, true);
> + monitor_list_append(&mon->common);
> +}
> +
> +void monitor_init_qmp(Chardev *chr, int flags)
> +{
> + MonitorQMP *mon = g_malloc0(sizeof(*mon));
> +
> + /* Note: we run QMP monitor in I/O thread when @chr supports that */
> + monitor_data_init(&mon->common, flags, false,
> + qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
> +
> + qemu_mutex_init(&mon->qmp_queue_lock);
> + mon->qmp_requests = g_queue_new();
> +
> + qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
> + qemu_chr_fe_set_echo(&mon->common.chr, true);
> +
> + json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
> + if (mon->common.use_io_thread) {
> + /*
> + * 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(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.
> + */
> + 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 */
> + } else {
> + qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
> + monitor_qmp_read, monitor_qmp_event,
> + NULL, &mon->common, NULL, true);
> + monitor_list_append(&mon->common);
> + }
> +}
> diff --git a/Makefile.objs b/Makefile.objs
> index c8337fa34b..76c5b525f9 100644
> --- a/Makefile.objs
> +++ b/Makefile.objs
> @@ -46,6 +46,7 @@ ifeq ($(CONFIG_SOFTMMU),y)
> common-obj-y = blockdev.o blockdev-nbd.o block/
> common-obj-y += bootdevice.o iothread.o
> common-obj-y += job-qmp.o
> +common-obj-y += monitor/
> common-obj-y += net/
> common-obj-y += qdev-monitor.o device-hotplug.o
> common-obj-$(CONFIG_WIN32) += os-win32.o
> diff --git a/monitor/Makefile.objs b/monitor/Makefile.objs
> index e783b0616b..d04d58b583 100644
> --- a/monitor/Makefile.objs
> +++ b/monitor/Makefile.objs
> @@ -1 +1,2 @@
> obj-y += misc.o
> +common-obj-y += qmp.o
> --
> 2.20.1
>
--
Dr. David Alan Gilbert / dgilbert@redhat.com / Manchester, UK
© 2016 - 2025 Red Hat, Inc.