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 */
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;
};
+/* Shared monitor I/O thread */
IOThread *mon_iothread;
/* Bottom half to dispatch the requests received from I/O thread */
}
/**
- * 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;
}
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 */
+/* Caller must hold the mon->qmp.qmp_queue_lock */
static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
{
while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
return FALSE;
}
-/* Called with mon->mon_lock held. */
+/* Caller must hold mon->mon_lock */
static void monitor_flush_locked(Monitor *mon)
{
int rc;
{
if (mon->use_io_thread) {
/*
- * If using I/O thread, we need to queue the item so that I/O
- * 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).
+ * Push a reference to the response queue. The I/O thread
+ * drains that queue and emits.
*/
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(rsp));
qemu_bh_schedule(qmp_respond_bh);
} else {
/*
- * If not using monitor I/O thread, then we are in main thread.
- * Do the emission right away.
+ * Not using monitor I/O thread, i.e. we are in the main thread.
+ * Emit right away.
*/
qmp_send_response(mon, rsp);
}
};
/*
- * 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)
{
}
/*
- * 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)
{
*/
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)
+static bool qmp_oob_enabled(Monitor *mon)
{
- return mon->qmp.qmp_caps[cap];
+ return mon->qmp.capab[QMP_CAPABILITY_OOB];
}
-static bool qmp_oob_enabled(Monitor *mon)
+static void monitor_qmp_caps_reset(Monitor *mon)
{
- return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
+ 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;
}
-static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
- Error **errp)
+/*
+ * 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_caps_accept(Monitor *mon, QMPCapabilityList *list,
+ Error **errp)
{
+ GString *unavailable = NULL;
+ bool capab[QMP_CAPABILITY__MAX];
+
+ memset(capab, 0, sizeof(capab));
+
for (; list; list = list->next) {
- assert(list->value < QMP_CAPABILITY__MAX);
- switch (list->value) {
- case QMP_CAPABILITY_OOB:
- if (!mon->use_io_thread) {
- /*
- * Out-of-band only works with monitors that are
- * running on dedicated I/O thread.
- */
- error_setg(errp, "This monitor does not support "
- "out-of-band (OOB)");
- return;
+ 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));
}
- break;
- default:
- break;
}
+ capab[list->value] = true;
}
-}
-/* This function should only be called after capabilities are checked. */
-static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
-{
- for (; list; list = list->next) {
- mon->qmp.qmp_caps[list->value] = true;
+ 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;
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, QDict *rsp,
- Error *err, QObject *id)
+static void monitor_qmp_respond(Monitor *mon, QDict *rsp, QObject *id)
{
- if (err) {
- assert(!rsp);
- rsp = qmp_error_response(err);
- }
-
if (rsp) {
if (id) {
qdict_put_obj(rsp, "id", qobject_ref(id));
qmp_queue_response(mon, rsp);
}
-
- qobject_unref(id);
- qobject_unref(rsp);
}
static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
}
}
- /* Respond if necessary */
- monitor_qmp_respond(mon, rsp, NULL, qobject_ref(id));
+ 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;
if (!req_obj) {
return;
monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
} else {
assert(req_obj->err);
- monitor_qmp_respond(req_obj->mon, NULL, req_obj->err, NULL);
+ rsp = qmp_error_response(req_obj->err);
+ monitor_qmp_respond(req_obj->mon, rsp, NULL);
+ qobject_unref(rsp);
}
if (req_obj->need_resume) {
}
if (qdict && qmp_is_oob(qdict)) {
- /* Out-of-band (OOB) requests are executed directly in parser. */
+ /* OOB commands are executed immediately */
trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id)
?: "");
monitor_qmp_dispatch(mon, req, id);
if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
if (monitor_is_qmp(mon)) {
/*
- * For QMP monitors that are running in I/O thread, 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_thread) {
aio_notify(iothread_get_aio_context(mon_iothread));
qmp_marshal_query_version(NULL, &ver, NULL);
for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
- if (!mon->use_io_thread && cap == QMP_CAPABILITY_OOB) {
- /* Monitors that are not using I/O thread 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 qdict_from_jsonf_nofail(
ver, cap_list);
}
-static void monitor_qmp_caps_reset(Monitor *mon)
-{
- memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
-}
-
static void monitor_qmp_event(void *opaque, int event)
{
QDict *data;
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.
+ * The dispatcher BH must run in the main loop thread, since we
+ * have commands assuming that context. It would be nice to get
+ * rid of those assumptions.
*/
qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
monitor_qmp_bh_dispatcher,
NULL);
/*
- * Unlike the dispatcher BH, this must be run on the monitor I/O
- * thread, so that monitors that are using I/O thread will make
- * sure read/write operations are all done on the I/O thread.
+ * The responder BH must be run in the monitor I/O thread, so that
+ * monitors that are using the I/O thread have their output
+ * written by the I/O thread.
*/
qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
monitor_qmp_bh_responder,
GMainContext *context;
if (mon->use_io_thread) {
- /*
- * When @use_io_thread is set, we use the global shared dedicated
- * I/O thread for this monitor to handle input/output.
- */
+ /* Use @mon_iothread context */
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 */
+ /* Use default main loop context */
context = NULL;
}
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 I/O thread, 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,
/*
* We need to explicitly stop the I/O thread (but not destroy it),
- * cleanup the monitor resources, then destroy the I/O thread since
+ * clean up the monitor resources, then destroy the I/O thread since
* we need to unregister from chardev below in
* monitor_data_destroy(), and chardev is not thread-safe yet
*/
iothread_stop(mon_iothread);
/*
- * After we have I/O thread to send responses, it's possible that
- * when we stop the I/O thread 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.
+ * Flush all response queues. Note that even after this flush,
+ * data may remain in output buffers.
*/
monitor_qmp_bh_responder(NULL);
+ /* 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);
OSDN Git Service
