monitor: Split out monitor/qmp.c (7e3c0dea) · Commits · SUMMER2020 / students / proj-2021291

Makefile.objs

+1 −0

Original line number	Diff line number	Diff line
		@@ -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

monitor/Makefile.objs

+1 −0

Original line number	Diff line number	Diff line
		obj-y += misc.o
		common-obj-y += qmp.o
		common-obj-y += qmp-cmds.o hmp-cmds.o

monitor/misc.c

+9 −392

Original line number	Diff line number	Diff line
		@@ -36,7 +36,6 @@
		#include "exec/gdbstub.h"
		#include "net/net.h"
		#include "net/slirp.h"
		#include "chardev/char-io.h"
		#include "chardev/char-mux.h"
		#include "ui/qemu-spice.h"
		#include "sysemu/numa.h"
		@@ -58,8 +57,6 @@
		#include "qapi/qmp/qerror.h"
		#include "qapi/qmp/qnum.h"
		#include "qapi/qmp/qstring.h"
		#include "qapi/qmp/qjson.h"
		#include "qapi/qmp/qlist.h"
		#include "qom/object_interfaces.h"
		#include "trace.h"
		#include "trace/control.h"
		@@ -81,7 +78,6 @@
		#include "qapi/qapi-introspect.h"
		#include "sysemu/qtest.h"
		#include "sysemu/cpus.h"
		#include "sysemu/iothread.h"
		#include "qemu/cutils.h"
		#include "tcg/tcg.h"

		@@ -138,51 +134,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 HMPCommand hmp_cmds[];
		static HMPCommand hmp_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
		@@ -241,28 +215,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);

		@@ -322,7 +274,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;
		@@ -372,21 +324,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 },
		@@ -601,7 +538,7 @@ 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,
		void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
		bool use_io_thread)
		{
		if (use_io_thread && !mon_iothread) {
		@@ -614,14 +551,6 @@ static void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
		mon->flags = flags;
		}

		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);
		@@ -1058,18 +987,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.
		@@ -2245,7 +2162,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;
		@@ -4023,209 +3940,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;
		@@ -4312,56 +4033,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;
		@@ -4495,7 +4166,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);
		/*
		@@ -4515,60 +4186,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_new0(MonitorQMP, 1);

		/* Only HMP supports readline */
		assert(!(flags & MONITOR_USE_READLINE));

		/* 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_new0(MonitorHMP, 1);

monitor/monitor-internal.h

+30 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@
		#include "qapi/qmp/dispatch.h"
		#include "qapi/qmp/json-parser.h"
		#include "qemu/readline.h"
		#include "sysemu/iothread.h"

		/*
		* Supported types:
		@@ -142,4 +143,33 @@ 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;

		void monitor_init_qmp(Chardev *chr, int flags);

		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

monitor/qmp.c

0 → 100644

+406 −0

File added.

Preview size limit exceeded, changes collapsed.