#include "qapi/qmp/qnum.h"
#include "qapi/qmp/qstring.h"
#include "qapi/qmp/qjson.h"
-#include "qapi/qmp/json-streamer.h"
#include "qapi/qmp/json-parser.h"
#include "qapi/qmp/qlist.h"
#include "qom/object_interfaces.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"
JSONMessageParser parser;
/*
* When a client connects, we're in capabilities negotiation mode.
- * When command qmp_capabilities succeeds, we go into command
- * mode.
+ * @commands is &qmp_cap_negotiation_commands then. When command
+ * qmp_capabilities succeeds, we go into command mode, and
+ * @command becomes &qmp_commands.
*/
QmpCommandList *commands;
- bool qmp_caps[QMP_CAPABILITY__MAX];
+ bool capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
+ bool capab[QMP_CAPABILITY__MAX]; /* offered and accepted */
/*
- * Protects qmp request/response queue. Please take monitor_lock
- * first when used together.
+ * Protects qmp request/response queue.
+ * Take monitor_lock first when you need both.
*/
QemuMutex qmp_queue_lock;
/* Input queue that holds all the parsed QMP requests */
GQueue *qmp_requests;
- /* Output queue contains all the QMP responses in order */
- GQueue *qmp_responses;
} MonitorQMP;
/*
int flags;
int suspend_cnt; /* Needs to be accessed atomically */
bool skip_flush;
- bool use_io_thr;
+ bool use_io_thread;
/*
* State used only in the thread "owning" the monitor.
- * If @use_io_thr, this is mon_global.mon_iothread.
+ * If @use_io_thread, this is @mon_iothread.
* Else, it's the main thread.
* These members can be safely accessed without locks.
*/
QemuMutex mon_lock;
/*
- * Fields that are protected by the per-monitor lock.
+ * Members that are protected by the per-monitor lock
*/
QLIST_HEAD(, mon_fd_t) fds;
QString *outbuf;
int mux_out;
};
-/* Let's add monitor global variables to this struct. */
-static struct {
- IOThread *mon_iothread;
- /* Bottom half to dispatch the requests received from IO thread */
- QEMUBH *qmp_dispatcher_bh;
- /* Bottom half to deliver the responses back to clients */
- QEMUBH *qmp_respond_bh;
-} mon_global;
+/* Shared monitor I/O thread */
+IOThread *mon_iothread;
+
+/* Bottom half to dispatch the requests received from I/O thread */
+QEMUBH *qmp_dispatcher_bh;
struct QMPRequest {
/* Owner of the request */
Monitor *mon;
/* "id" field of the request */
QObject *id;
- /* Request object to be handled */
- QObject *req;
/*
- * Whether we need to resume the monitor afterward. This flag is
- * used to emulate the old QMP server behavior that the current
- * command must be completed before execution of the next one.
+ * Request object to be handled or Error to be reported
+ * (exactly one of them is non-null)
*/
- bool need_resume;
+ QObject *req;
+ Error *err;
};
typedef struct QMPRequest QMPRequest;
QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
-Monitor *cur_mon;
+__thread Monitor *cur_mon;
static void monitor_command_cb(void *opaque, const char *cmdline,
void *readline_opaque);
}
/**
- * Whether @mon is using readline? Note: not all HMP monitors use
- * readline, e.g., gdbserver has a non-interactive HMP monitor, so
- * readline is not used there.
+ * Is @mon is using readline?
+ * Note: not all HMP monitors use readline, e.g., gdbserver has a
+ * non-interactive HMP monitor, so readline is not used there.
*/
static inline bool monitor_uses_readline(const Monitor *mon)
{
/*
* Return the clock to use for recording an event's time.
+ * It's QEMU_CLOCK_REALTIME, except for qtests it's
+ * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
* Beware: result is invalid before configure_accelerator().
*/
static inline QEMUClockType monitor_get_event_clock(void)
{
- /*
- * This allows us to perform tests on the monitor queues to verify
- * that the rate limits are enforced.
- */
return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
}
{
qobject_unref(req->id);
qobject_unref(req->req);
+ error_free(req->err);
g_free(req);
}
-/* Must with the mon->qmp.qmp_queue_lock held */
+/* Caller must hold mon->qmp.qmp_queue_lock */
static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
{
while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
}
}
-/* Must with the mon->qmp.qmp_queue_lock held */
-static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
-{
- while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
- qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
- }
-}
-
static void monitor_qmp_cleanup_queues(Monitor *mon)
{
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon);
- monitor_qmp_cleanup_resp_queue_locked(mon);
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
}
return FALSE;
}
-/* Called with mon->mon_lock held. */
+/* Caller must hold mon->mon_lock */
static void monitor_flush_locked(Monitor *mon)
{
int rc;
return 0;
}
-static void monitor_json_emitter_raw(Monitor *mon,
- QObject *data)
+static void qmp_send_response(Monitor *mon, const QDict *rsp)
{
+ const QObject *data = QOBJECT(rsp);
QString *json;
json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
qobject_unref(json);
}
-static void monitor_json_emitter(Monitor *mon, QObject *data)
-{
- if (mon->use_io_thr) {
- /*
- * If using IO thread, we need to queue the item so that IO
- * thread will do the rest for us. Take refcount so that
- * caller won't free the data (which will be finally freed in
- * responder thread).
- */
- qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
- g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
- qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
- qemu_bh_schedule(mon_global.qmp_respond_bh);
- } else {
- /*
- * If not using monitor IO thread, then we are in main thread.
- * Do the emission right away.
- */
- monitor_json_emitter_raw(mon, data);
- }
-}
-
-struct QMPResponse {
- Monitor *mon;
- QObject *data;
-};
-typedef struct QMPResponse QMPResponse;
-
-static QObject *monitor_qmp_response_pop_one(Monitor *mon)
-{
- QObject *data;
-
- qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
- data = g_queue_pop_head(mon->qmp.qmp_responses);
- qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
-
- return data;
-}
-
-static void monitor_qmp_response_flush(Monitor *mon)
-{
- QObject *data;
-
- while ((data = monitor_qmp_response_pop_one(mon))) {
- monitor_json_emitter_raw(mon, data);
- qobject_unref(data);
- }
-}
-
-/*
- * Pop a QMPResponse from any monitor's response queue into @response.
- * Return false if all the queues are empty; else true.
- */
-static bool monitor_qmp_response_pop_any(QMPResponse *response)
-{
- Monitor *mon;
- QObject *data = NULL;
-
- qemu_mutex_lock(&monitor_lock);
- QTAILQ_FOREACH(mon, &mon_list, entry) {
- data = monitor_qmp_response_pop_one(mon);
- if (data) {
- response->mon = mon;
- response->data = data;
- break;
- }
- }
- qemu_mutex_unlock(&monitor_lock);
- return data != NULL;
-}
-
-static void monitor_qmp_bh_responder(void *opaque)
-{
- QMPResponse response;
-
- while (monitor_qmp_response_pop_any(&response)) {
- monitor_json_emitter_raw(response.mon, response.data);
- qobject_unref(response.data);
- }
-}
-
static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
/* Limit guest-triggerable events to 1 per second */
[QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
};
/*
- * Emits the event to every monitor instance, @event is only used for trace
- * Called with monitor_lock held.
+ * Broadcast an event to all monitors.
+ * @qdict is the event object. Its member "event" must match @event.
+ * Caller must hold monitor_lock.
*/
static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
{
QTAILQ_FOREACH(mon, &mon_list, entry) {
if (monitor_is_qmp(mon)
&& mon->qmp.commands != &qmp_cap_negotiation_commands) {
- monitor_json_emitter(mon, QOBJECT(qdict));
+ qmp_send_response(mon, qdict);
}
}
}
* applying any rate limiting if required.
*/
static void
-monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
+monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
{
MonitorQAPIEventConf *evconf;
MonitorQAPIEventState *evstate;
qemu_mutex_unlock(&monitor_lock);
}
+static void
+monitor_qapi_event_queue(QAPIEvent event, QDict *qdict)
+{
+ /*
+ * monitor_qapi_event_queue_no_reenter() is not reentrant: it
+ * would deadlock on monitor_lock. Work around by queueing
+ * events in thread-local storage.
+ * TODO: remove this, make it re-enter safe.
+ */
+ typedef struct MonitorQapiEvent {
+ QAPIEvent event;
+ QDict *qdict;
+ QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
+ } MonitorQapiEvent;
+ static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
+ static __thread bool reentered;
+ MonitorQapiEvent *ev;
+
+ if (!reentered) {
+ QSIMPLEQ_INIT(&event_queue);
+ }
+
+ ev = g_new(MonitorQapiEvent, 1);
+ ev->qdict = qobject_ref(qdict);
+ ev->event = event;
+ QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
+ if (reentered) {
+ return;
+ }
+
+ reentered = true;
+
+ while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
+ QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
+ monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
+ qobject_unref(ev->qdict);
+ g_free(ev);
+ }
+
+ reentered = false;
+}
+
/*
* This function runs evconf->rate ns after sending a throttled
* event.
static void handle_hmp_command(Monitor *mon, const char *cmdline);
static void monitor_data_init(Monitor *mon, bool skip_flush,
- bool use_io_thr)
+ bool use_io_thread)
{
memset(mon, 0, sizeof(Monitor));
qemu_mutex_init(&mon->mon_lock);
/* Use *mon_cmds by default. */
mon->cmd_table = mon_cmds;
mon->skip_flush = skip_flush;
- mon->use_io_thr = use_io_thr;
+ mon->use_io_thread = use_io_thread;
mon->qmp.qmp_requests = g_queue_new();
- mon->qmp.qmp_responses = g_queue_new();
}
static void monitor_data_destroy(Monitor *mon)
qemu_mutex_destroy(&mon->mon_lock);
qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon);
- monitor_qmp_cleanup_resp_queue_locked(mon);
g_queue_free(mon->qmp.qmp_requests);
- g_queue_free(mon->qmp.qmp_responses);
}
char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
}
/*
- * Returns true if the command can be executed in preconfig mode
- * i.e. it has the 'p' flag.
+ * Can command @cmd be executed in preconfig state?
*/
static bool cmd_can_preconfig(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) {
} 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 qmp_unregister_commands_hack(void)
{
-#ifndef CONFIG_SPICE
- qmp_unregister_command(&qmp_commands, "query-spice");
-#endif
#ifndef CONFIG_REPLICATION
qmp_unregister_command(&qmp_commands, "xen-set-replication");
qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
}
-static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
-{
- return mon->qmp.qmp_caps[cap];
-}
-
static bool qmp_oob_enabled(Monitor *mon)
{
- return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
-}
-
-static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
- Error **errp)
-{
- for (; list; list = list->next) {
- assert(list->value < QMP_CAPABILITY__MAX);
- switch (list->value) {
- case QMP_CAPABILITY_OOB:
- if (!mon->use_io_thr) {
- /*
- * Out-Of-Band only works with monitors that are
- * running on dedicated IOThread.
- */
- error_setg(errp, "This monitor does not support "
- "Out-Of-Band (OOB)");
- return;
- }
- break;
- default:
- break;
- }
- }
+ return mon->qmp.capab[QMP_CAPABILITY_OOB];
}
-/* This function should only be called after capabilities are checked. */
-static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
+static void monitor_qmp_caps_reset(Monitor *mon)
{
- for (; list; list = list->next) {
- mon->qmp.qmp_caps[list->value] = true;
- }
+ memset(mon->qmp.capab_offered, 0, sizeof(mon->qmp.capab_offered));
+ memset(mon->qmp.capab, 0, sizeof(mon->qmp.capab));
+ mon->qmp.capab_offered[QMP_CAPABILITY_OOB] = mon->use_io_thread;
}
/*
- * Return true if check successful, or false otherwise. When false is
- * returned, detailed error will be in errp if provided.
+ * Accept QMP capabilities in @list for @mon.
+ * On success, set mon->qmp.capab[], and return true.
+ * On error, set @errp, and return false.
*/
-static bool qmp_cmd_oob_check(Monitor *mon, QDict *req, Error **errp)
+static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
+ Error **errp)
{
- const char *command;
- QmpCommand *cmd;
+ GString *unavailable = NULL;
+ bool capab[QMP_CAPABILITY__MAX];
- command = qdict_get_try_str(req, "execute");
- if (!command) {
- error_setg(errp, "Command field 'execute' missing");
- return false;
- }
+ memset(capab, 0, sizeof(capab));
- cmd = qmp_find_command(mon->qmp.commands, command);
- if (!cmd) {
- if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
- error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
- "Expecting capabilities negotiation "
- "with 'qmp_capabilities'");
- } else {
- error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
- "The command %s has not been found", command);
+ for (; list; list = list->next) {
+ if (!mon->qmp.capab_offered[list->value]) {
+ if (!unavailable) {
+ unavailable = g_string_new(QMPCapability_str(list->value));
+ } else {
+ g_string_append_printf(unavailable, ", %s",
+ QMPCapability_str(list->value));
+ }
}
- return false;
+ capab[list->value] = true;
}
- if (qmp_is_oob(req)) {
- if (!qmp_oob_enabled(mon)) {
- error_setg(errp, "Please enable Out-Of-Band first "
- "for the session during capabilities negotiation");
- return false;
- }
- if (!(cmd->options & QCO_ALLOW_OOB)) {
- error_setg(errp, "The command %s does not support OOB",
- command);
- return false;
- }
+ if (unavailable) {
+ error_setg(errp, "Capability %s not available", unavailable->str);
+ g_string_free(unavailable, true);
+ return false;
}
+ memcpy(mon->qmp.capab, capab, sizeof(capab));
return true;
}
void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
Error **errp)
{
- Error *local_err = NULL;
-
if (cur_mon->qmp.commands == &qmp_commands) {
error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
"Capabilities negotiation is already complete, command "
return;
}
- /* Enable QMP capabilities provided by the client if applicable. */
- if (has_enable) {
- qmp_caps_check(cur_mon, enable, &local_err);
- if (local_err) {
- /*
- * Failed check on any of the capabilities will fail the
- * entire command (and thus not apply any of the other
- * capabilities that were also requested).
- */
- error_propagate(errp, local_err);
- return;
- }
- qmp_caps_apply(cur_mon, enable);
+ if (!qmp_caps_accept(cur_mon, enable, errp)) {
+ return;
}
cur_mon->qmp.commands = &qmp_commands;
}
#endif
+static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
+{
+ int64_t max = qdict_get_try_int(qdict, "max", 10);
+ bool mean = qdict_get_try_bool(qdict, "mean", false);
+ bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
+ enum QSPSortBy sort_by;
+
+ sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
+ qsp_report((FILE *)mon, monitor_fprintf, max, sort_by, coalesce);
+}
+
static void hmp_info_history(Monitor *mon, const QDict *qdict)
{
int i;
#ifdef CONFIG_PROFILER
-int64_t tcg_time;
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",
- 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
tmp_fd = monfd->fd;
monfd->fd = fd;
qemu_mutex_unlock(&cur_mon->mon_lock);
- /* Make sure close() is out of critical section */
+ /* Make sure close() is outside critical section */
close(tmp_fd);
return;
}
g_free(monfd->name);
g_free(monfd);
qemu_mutex_unlock(&cur_mon->mon_lock);
- /* Make sure close() is out of critical section */
+ /* Make sure close() is outside critical section */
close(tmp_fd);
return;
}
}
/*
- * 1. This function takes ownership of rsp, err, and id.
- * 2. rsp, err, and id may be NULL.
- * 3. If err != NULL then rsp must be NULL.
+ * 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(Monitor *mon, QObject *rsp,
- Error *err, QObject *id)
+static void monitor_qmp_respond(Monitor *mon, QDict *rsp, QObject *id)
{
- QDict *qdict = NULL;
-
- if (err) {
- assert(!rsp);
- qdict = qdict_new();
- qdict_put_obj(qdict, "error", qmp_build_error_object(err));
- error_free(err);
- rsp = QOBJECT(qdict);
- }
-
if (rsp) {
if (id) {
- qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
+ qdict_put_obj(rsp, "id", qobject_ref(id));
}
- monitor_json_emitter(mon, rsp);
+ qmp_send_response(mon, rsp);
}
-
- qobject_unref(id);
- qobject_unref(rsp);
}
-/*
- * Dispatch one single QMP request. The function will free the req_obj
- * and objects inside it before return.
- */
-static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
+static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
{
- Monitor *mon, *old_mon;
- QObject *req, *rsp = NULL, *id;
- bool need_resume;
-
- req = req_obj->req;
- mon = req_obj->mon;
- id = req_obj->id;
- need_resume = req_obj->need_resume;
-
- g_free(req_obj);
-
- if (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);
- }
+ Monitor *old_mon;
+ QDict *rsp;
+ QDict *error;
old_mon = cur_mon;
cur_mon = mon;
- rsp = qmp_dispatch(mon->qmp.commands, req);
+ rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
cur_mon = old_mon;
- /* Respond if necessary */
- monitor_qmp_respond(mon, rsp, NULL, id);
-
- /* This pairs with the monitor_suspend() in handle_qmp_command(). */
- if (need_resume) {
- monitor_resume(mon);
+ if (mon->qmp.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'");
+ }
}
- qobject_unref(req);
+ monitor_qmp_respond(mon, rsp, id);
+ qobject_unref(rsp);
}
/*
- * Pop one QMP request from monitor queues, return NULL if not found.
+ * 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
static void monitor_qmp_bh_dispatcher(void *data)
{
QMPRequest *req_obj = monitor_qmp_requests_pop_any();
+ QDict *rsp;
+ bool need_resume;
- if (req_obj) {
+ if (!req_obj) {
+ return;
+ }
+
+ /* qmp_oob_enabled() might change after "qmp_capabilities" */
+ need_resume = !qmp_oob_enabled(req_obj->mon);
+ if (req_obj->req) {
trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
- monitor_qmp_dispatch_one(req_obj);
- /* Reschedule instead of looping so the main loop stays responsive */
- qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
+ monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
+ } else {
+ assert(req_obj->err);
+ rsp = qmp_error_response(req_obj->err);
+ req_obj->err = NULL;
+ monitor_qmp_respond(req_obj->mon, rsp, NULL);
+ qobject_unref(rsp);
+ }
+
+ if (need_resume) {
+ /* Pairs with the monitor_suspend() in handle_qmp_command() */
+ monitor_resume(req_obj->mon);
}
+ qmp_request_free(req_obj);
+
+ /* Reschedule instead of looping so the main loop stays responsive */
+ qemu_bh_schedule(qmp_dispatcher_bh);
}
#define QMP_REQ_QUEUE_LEN_MAX (8)
-static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
+static void handle_qmp_command(void *opaque, QObject *req, Error *err)
{
- QObject *req, *id = NULL;
- QDict *qdict = NULL;
- MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
- Monitor *mon = container_of(mon_qmp, Monitor, qmp);
- Error *err = NULL;
+ Monitor *mon = opaque;
+ QObject *id = NULL;
+ QDict *qdict;
QMPRequest *req_obj;
- req = json_parser_parse_err(tokens, NULL, &err);
- if (!req && !err) {
- /* json_parser_parse_err() sucks: can fail without setting @err */
- error_setg(&err, QERR_JSON_PARSING);
- }
- if (err) {
- goto err;
- }
+ assert(!req != !err);
- /* Check against the request in general layout */
- qdict = qmp_dispatch_check_obj(req, &err);
- if (!qdict) {
- goto err;
- }
+ qdict = qobject_to(QDict, req);
+ if (qdict) {
+ id = qobject_ref(qdict_get(qdict, "id"));
+ qdict_del(qdict, "id");
+ } /* else will fail qmp_dispatch() */
- /* Check against OOB specific */
- if (!qmp_cmd_oob_check(mon, qdict, &err)) {
- goto err;
+ 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);
}
- id = qdict_get(qdict, "id");
-
- /* When OOB is enabled, the "id" field is mandatory. */
- if (qmp_oob_enabled(mon) && !id) {
- error_setg(&err, "Out-Of-Band capability requires that "
- "every command contains an 'id' field");
- goto err;
+ 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, id);
+ qobject_unref(req);
+ qobject_unref(id);
+ return;
}
req_obj = g_new0(QMPRequest, 1);
req_obj->mon = mon;
- req_obj->id = qobject_ref(id);
+ req_obj->id = id;
req_obj->req = req;
- req_obj->need_resume = false;
-
- qdict_del(qdict, "id");
-
- if (qmp_is_oob(qdict)) {
- /* Out-Of-Band (OOB) requests are executed directly in parser. */
- trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
- ?: "");
- monitor_qmp_dispatch_one(req_obj);
- return;
- }
+ req_obj->err = err;
/* Protect qmp_requests and fetching its length. */
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
*/
if (!qmp_oob_enabled(mon)) {
monitor_suspend(mon);
- req_obj->need_resume = true;
} 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,
- &error_abort);
+ COMMAND_DROP_REASON_QUEUE_FULL);
qmp_request_free(req_obj);
return;
}
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
/* Kick the dispatcher routine */
- qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
- return;
-
-err:
- monitor_qmp_respond(mon, NULL, err, NULL);
- qobject_unref(req);
+ qemu_bh_schedule(qmp_dispatcher_bh);
}
static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
if (monitor_is_qmp(mon)) {
/*
- * Kick iothread to make sure this takes effect. It'll be
+ * Kick I/O thread to make sure this takes effect. It'll be
* evaluated again in prepare() of the watch object.
*/
- aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
+ aio_notify(iothread_get_aio_context(mon_iothread));
}
trace_monitor_suspend(mon, 1);
if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
if (monitor_is_qmp(mon)) {
/*
- * For QMP monitors that are running in IOThread, let's
- * kick the thread in case it's sleeping.
+ * 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_thr) {
- aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
+ if (mon->use_io_thread) {
+ aio_notify(iothread_get_aio_context(mon_iothread));
}
} else {
assert(mon->rs);
readline_show_prompt(mon->rs);
}
+ qemu_chr_fe_accept_input(&mon->chr);
}
trace_monitor_suspend(mon, -1);
}
-static QObject *get_qmp_greeting(Monitor *mon)
+static QDict *qmp_greeting(Monitor *mon)
{
QList *cap_list = qlist_new();
QObject *ver = NULL;
qmp_marshal_query_version(NULL, &ver, NULL);
for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
- if (!mon->use_io_thr && cap == QMP_CAPABILITY_OOB) {
- /* Monitors that are not using IOThread won't support OOB */
- continue;
+ if (mon->qmp.capab_offered[cap]) {
+ qlist_append_str(cap_list, QMPCapability_str(cap));
}
- qlist_append_str(cap_list, QMPCapability_str(cap));
}
- return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
- ver, cap_list);
-}
-
-static void monitor_qmp_caps_reset(Monitor *mon)
-{
- memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
+ return qdict_from_jsonf_nofail(
+ "{'QMP': {'version': %p, 'capabilities': %p}}",
+ ver, cap_list);
}
static void monitor_qmp_event(void *opaque, int event)
{
- QObject *data;
+ QDict *data;
Monitor *mon = opaque;
switch (event) {
case CHR_EVENT_OPENED:
mon->qmp.commands = &qmp_cap_negotiation_commands;
monitor_qmp_caps_reset(mon);
- data = get_qmp_greeting(mon);
- monitor_json_emitter(mon, data);
+ data = qmp_greeting(mon);
+ qmp_send_response(mon, data);
qobject_unref(data);
mon_refcount++;
break;
* stdio, it's possible that stdout is still open when stdin
* is closed.
*/
- monitor_qmp_response_flush(mon);
monitor_qmp_cleanup_queues(mon);
json_message_parser_destroy(&mon->qmp.parser);
- json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
+ json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
+ mon, NULL);
mon_refcount--;
monitor_fdsets_cleanup();
break;
static GMainContext *monitor_get_io_context(void)
{
- return iothread_get_g_main_context(mon_global.mon_iothread);
+ return iothread_get_g_main_context(mon_iothread);
}
static AioContext *monitor_get_aio_context(void)
{
- return iothread_get_aio_context(mon_global.mon_iothread);
+ return iothread_get_aio_context(mon_iothread);
}
static void monitor_iothread_init(void)
{
- mon_global.mon_iothread = iothread_create("mon_iothread",
- &error_abort);
-
- /*
- * This MUST be on main loop thread since we have commands that
- * have assumption to be run on main loop thread. It would be
- * nice that one day we can remove this assumption in the future.
- */
- mon_global.qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
- monitor_qmp_bh_dispatcher,
- NULL);
+ mon_iothread = iothread_create("mon_iothread", &error_abort);
/*
- * Unlike the dispatcher BH, this must be run on the monitor IO
- * thread, so that monitors that are using IO thread will make
- * sure read/write operations are all done on the IO thread.
+ * The dispatcher BH must run in the main loop thread, since we
+ * have commands assuming that context. It would be nice to get
+ * rid of those assumptions.
*/
- mon_global.qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
- monitor_qmp_bh_responder,
- NULL);
+ qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
+ monitor_qmp_bh_dispatcher,
+ NULL);
}
void monitor_init_globals(void)
}
/*
- * 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.
*/
-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 {
- 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()) {
Monitor *mon = opaque;
GMainContext *context;
- if (mon->use_io_thr) {
- /*
- * When use_io_thr is set, we use the global shared dedicated
- * IO thread for this monitor to handle input/output.
- */
- context = monitor_get_io_context();
- /* We should have inited globals before reaching here. */
- assert(context);
- } else {
- /* The default main loop, which is the main thread */
- context = NULL;
- }
-
+ assert(mon->use_io_thread);
+ context = monitor_get_io_context();
+ assert(context);
qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
monitor_qmp_event, NULL, mon, context, true);
monitor_list_append(mon);
if (use_oob) {
if (CHARDEV_IS_MUX(chr)) {
- error_report("Monitor Out-Of-Band is not supported with "
+ 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");
+ error_report("Monitor out-of-band is only supported by QMP");
exit(1);
}
}
if (monitor_is_qmp(mon)) {
qemu_chr_fe_set_echo(&mon->chr, true);
- json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
- if (mon->use_io_thr) {
+ json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
+ mon, NULL);
+ if (mon->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 during the procedure the chardev will be active
- * and running in monitor iothread, while we'll still do
- * something before returning from it, which is a possible
- * race too. To avoid that, we just create a BH to setup
- * the handlers.
+ * since chardev might be running in the monitor I/O
+ * thread. Schedule a bottom half.
*/
aio_bh_schedule_oneshot(monitor_get_aio_context(),
monitor_qmp_setup_handlers_bh, mon);
- /* We'll add this to mon_list in the BH when setup done */
+ /* The bottom half will add @mon to @mon_list */
return;
} else {
qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
Monitor *mon, *next;
/*
- * We need to explicitly stop the iothread (but not destroy it),
- * cleanup the monitor resources, then destroy the iothread since
+ * 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_global.mon_iothread);
-
- /*
- * After we have IOThread to send responses, it's possible that
- * when we stop the IOThread there are still replies queued in the
- * responder queue. Flush all of them. Note that even after this
- * flush it's still possible that out buffer is not flushed.
- * It'll be done in below monitor_flush() as the last resort.
- */
- monitor_qmp_bh_responder(NULL);
+ iothread_stop(mon_iothread);
+ /* Flush output buffers and destroy monitors */
qemu_mutex_lock(&monitor_lock);
QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
QTAILQ_REMOVE(&mon_list, mon, entry);
}
qemu_mutex_unlock(&monitor_lock);
- /* QEMUBHs needs to be deleted before destroying the IOThread. */
- qemu_bh_delete(mon_global.qmp_dispatcher_bh);
- mon_global.qmp_dispatcher_bh = NULL;
- qemu_bh_delete(mon_global.qmp_respond_bh);
- mon_global.qmp_respond_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_global.mon_iothread);
- mon_global.mon_iothread = NULL;
+ iothread_destroy(mon_iothread);
+ mon_iothread = NULL;
}
QemuOptsList qemu_mon_opts = {
projects / mirror_qemu.git / blobdiff