OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

monitor: Make MonitorQMP a child class of Monitor 

Currently, struct Monitor mixes state that is only relevant for HMP,
state that is only relevant for QMP, and some actually shared state.
In particular, a MonitorQMP field is present in the state of any
monitor, even if it's not a QMP monitor and therefore doesn't use the
state.

As a first step towards a clean separation between QMP and HMP, let
MonitorQMP extend Monitor and create a MonitorQMP object only when the
monitor is actually a QMP monitor.

Some places accessed Monitor.qmp unconditionally, even for HMP monitors.
They can't keep doing this now, so during the conversion, they are
either changed to become conditional on monitor_is_qmp() or to assert()
that they always get a QMP monitor.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190613153405.24769-4-kwolf@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
[Superfluous variable in monitor_data_destroy() eliminated]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Kevin Wolf 2019-06-13 17:33:53 +02:00 committed by Markus Armbruster
parent b6c7c2e4a3
commit b8e31d6ccc
1 changed files with 123 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
monitor.c
View File

@ -168,26 +168,6 @@ struct MonFdset {
QLIST_ENTRY(MonFdset) next;
};
typedef struct {
JSONMessageParser parser;
/*
* When a client connects, we're in capabilities negotiation 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 capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
bool capab[QMP_CAPABILITY__MAX]; /* offered and accepted */
/*
* 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;
} MonitorQMP;
/*
* To prevent flooding clients, events can be throttled. The
* throttling is calculated globally, rather than per-Monitor
@ -220,7 +200,6 @@ struct Monitor {
*/
ReadLineState *rs;
MonitorQMP qmp;
gchar *mon_cpu_path;
mon_cmd_t *cmd_table;
QTAILQ_ENTRY(Monitor) entry;
@ -241,6 +220,27 @@ struct Monitor {
int mux_out;
};
typedef struct {
Monitor common;
JSONMessageParser parser;
/*
* When a client connects, we're in capabilities negotiation 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 capab_offered[QMP_CAPABILITY__MAX]; /* capabilities offered */
bool capab[QMP_CAPABILITY__MAX]; /* offered and accepted */
/*
* 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;
} MonitorQMP;
/* Shared monitor I/O thread */
IOThread *mon_iothread;
@ -249,7 +249,7 @@ QEMUBH *qmp_dispatcher_bh;
struct QMPRequest {
/* Owner of the request */
Monitor *mon;
MonitorQMP *mon;
/*
* Request object to be handled or Error to be reported
* (exactly one of them is non-null)
@ -357,18 +357,18 @@ static void qmp_request_free(QMPRequest *req)
}
/* Caller must hold mon->qmp.qmp_queue_lock */
static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
{
while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
while (!g_queue_is_empty(mon->qmp_requests)) {
qmp_request_free(g_queue_pop_head(mon->qmp_requests));
}
}
static void monitor_qmp_cleanup_queues(Monitor *mon)
static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
{
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
qemu_mutex_lock(&mon->qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon);
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
qemu_mutex_unlock(&mon->qmp_queue_lock);
}
@ -480,17 +480,17 @@ int monitor_printf(Monitor *mon, const char *fmt, ...)
return ret;
}
static void qmp_send_response(Monitor *mon, const QDict *rsp)
static void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
{
const QObject *data = QOBJECT(rsp);
QString *json;
json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
qobject_to_json(data);
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, qstring_get_str(json));
monitor_puts(&mon->common, qstring_get_str(json));
qobject_unref(json);
}
@ -513,12 +513,17 @@ static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
{
Monitor *mon;
MonitorQMP *qmp_mon;
trace_monitor_protocol_event_emit(event, qdict);
QTAILQ_FOREACH(mon, &mon_list, entry) {
if (monitor_is_qmp(mon)
&& mon->qmp.commands != &qmp_cap_negotiation_commands) {
qmp_send_response(mon, qdict);
if (!monitor_is_qmp(mon)) {
continue;
}
qmp_mon = container_of(mon, MonitorQMP, common);
if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
qmp_send_response(qmp_mon, qdict);
}
}
}
@ -711,29 +716,32 @@ static void monitor_data_init(Monitor *mon, int flags, bool skip_flush,
monitor_iothread_init();
}
qemu_mutex_init(&mon->mon_lock);
qemu_mutex_init(&mon->qmp.qmp_queue_lock);
mon->outbuf = qstring_new();
/* Use *mon_cmds by default. */
mon->cmd_table = mon_cmds;
mon->skip_flush = skip_flush;
mon->use_io_thread = use_io_thread;
mon->qmp.qmp_requests = g_queue_new();
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);
qemu_chr_fe_deinit(&mon->chr, false);
if (monitor_is_qmp(mon)) {
json_message_parser_destroy(&mon->qmp.parser);
monitor_data_destroy_qmp(container_of(mon, MonitorQMP, common));
}
readline_free(mon->rs);
qobject_unref(mon->outbuf);
qemu_mutex_destroy(&mon->mon_lock);
qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
monitor_qmp_cleanup_req_queue_locked(mon);
g_queue_free(mon->qmp.qmp_requests);
}
char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
@ -1087,8 +1095,12 @@ static void query_commands_cb(QmpCommand *cmd, void *opaque)
CommandInfoList *qmp_query_commands(Error **errp)
{
CommandInfoList *list = NULL;
MonitorQMP *mon;
qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
assert(monitor_is_qmp(cur_mon));
mon = container_of(cur_mon, MonitorQMP, common);
qmp_for_each_command(mon->commands, query_commands_cb, &list);
return list;
}
@ -1155,16 +1167,16 @@ static void monitor_init_qmp_commands(void)
qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
}
static bool qmp_oob_enabled(Monitor *mon)
static bool qmp_oob_enabled(MonitorQMP *mon)
{
return mon->qmp.capab[QMP_CAPABILITY_OOB];
return mon->capab[QMP_CAPABILITY_OOB];
}
static void monitor_qmp_caps_reset(Monitor *mon)
static void monitor_qmp_caps_reset(MonitorQMP *mon)
{
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;
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;
}
/*
@ -1172,7 +1184,7 @@ static void monitor_qmp_caps_reset(Monitor *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,
static bool qmp_caps_accept(MonitorQMP *mon, QMPCapabilityList *list,
Error **errp)
{
GString *unavailable = NULL;
@ -1181,7 +1193,7 @@ static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
memset(capab, 0, sizeof(capab));
for (; list; list = list->next) {
if (!mon->qmp.capab_offered[list->value]) {
if (!mon->capab_offered[list->value]) {
if (!unavailable) {
unavailable = g_string_new(QMPCapability_str(list->value));
} else {
@ -1198,25 +1210,30 @@ static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
return false;
}
memcpy(mon->qmp.capab, capab, sizeof(capab));
memcpy(mon->capab, capab, sizeof(capab));
return true;
}
void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
Error **errp)
{
if (cur_mon->qmp.commands == &qmp_commands) {
MonitorQMP *mon;
assert(monitor_is_qmp(cur_mon));
mon = container_of(cur_mon, MonitorQMP, common);
if (mon->commands == &qmp_commands) {
error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
"Capabilities negotiation is already complete, command "
"ignored");
return;
}
if (!qmp_caps_accept(cur_mon, enable, errp)) {
if (!qmp_caps_accept(mon, enable, errp)) {
return;
}
cur_mon->qmp.commands = &qmp_commands;
mon->commands = &qmp_commands;
}
/* Set the current CPU defined by the user. Callers must hold BQL. */
@ -4123,27 +4140,27 @@ static int monitor_can_read(void *opaque)
* 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)
static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
{
if (rsp) {
qmp_send_response(mon, rsp);
}
}
static void monitor_qmp_dispatch(Monitor *mon, QObject *req)
static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
{
Monitor *old_mon;
QDict *rsp;
QDict *error;
old_mon = cur_mon;
cur_mon = mon;
cur_mon = &mon->common;
rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
cur_mon = old_mon;
if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
if (mon->commands == &qmp_cap_negotiation_commands) {
error = qdict_get_qdict(rsp, "error");
if (error
&& !g_strcmp0(qdict_get_try_str(error, "class"),
@ -4168,24 +4185,30 @@ static void monitor_qmp_dispatch(Monitor *mon, QObject *req)
* monitor to the end of mon_list queue.
*
* Note: if the function returned with non-NULL, then the caller will
* be with mon->qmp.qmp_queue_lock held, and the caller is responsible
* 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) {
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
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(&mon->qmp.qmp_queue_lock);
qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
}
if (req_obj) {
@ -4207,7 +4230,7 @@ static void monitor_qmp_bh_dispatcher(void *data)
QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
QDict *rsp;
bool need_resume;
Monitor *mon;
MonitorQMP *mon;
if (!req_obj) {
return;
@ -4216,8 +4239,8 @@ static void monitor_qmp_bh_dispatcher(void *data)
mon = req_obj->mon;
/* qmp_oob_enabled() might change after "qmp_capabilities" */
need_resume = !qmp_oob_enabled(mon) ||
mon->qmp.qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
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;
@ -4233,7 +4256,7 @@ static void monitor_qmp_bh_dispatcher(void *data)
if (need_resume) {
/* Pairs with the monitor_suspend() in handle_qmp_command() */
monitor_resume(mon);
monitor_resume(&mon->common);
}
qmp_request_free(req_obj);
@ -4243,7 +4266,7 @@ static void monitor_qmp_bh_dispatcher(void *data)
static void handle_qmp_command(void *opaque, QObject *req, Error *err)
{
Monitor *mon = opaque;
MonitorQMP *mon = opaque;
QObject *id = NULL;
QDict *qdict;
QMPRequest *req_obj;
@ -4275,7 +4298,7 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
req_obj->err = err;
/* Protect qmp_requests and fetching its length. */
qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
qemu_mutex_lock(&mon->qmp_queue_lock);
/*
* Suspend the monitor when we can't queue more requests after
@ -4284,8 +4307,8 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
* command, for backward compatibility.
*/
if (!qmp_oob_enabled(mon) ||
mon->qmp.qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
monitor_suspend(mon);
mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
monitor_suspend(&mon->common);
}
/*
@ -4293,9 +4316,9 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
* handled in time order. Ownership for req_obj, req,
* etc. will be delivered to the handler side.
*/
assert(mon->qmp.qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
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);
@ -4303,9 +4326,9 @@ static void handle_qmp_command(void *opaque, QObject *req, Error *err)
static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
{
Monitor *mon = opaque;
MonitorQMP *mon = opaque;
json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
json_message_parser_feed(&mon->parser, (const char *) buf, size);
}
static void monitor_read(void *opaque, const uint8_t *buf, int size)
@ -4391,7 +4414,7 @@ void monitor_resume(Monitor *mon)
trace_monitor_suspend(mon, -1);
}
static QDict *qmp_greeting(Monitor *mon)
static QDict *qmp_greeting(MonitorQMP *mon)
{
QList *cap_list = qlist_new();
QObject *ver = NULL;
@ -4400,7 +4423,7 @@ static QDict *qmp_greeting(Monitor *mon)
qmp_marshal_query_version(NULL, &ver, NULL);
for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
if (mon->qmp.capab_offered[cap]) {
if (mon->capab_offered[cap]) {
qlist_append_str(cap_list, QMPCapability_str(cap));
}
}
@ -4413,11 +4436,11 @@ static QDict *qmp_greeting(Monitor *mon)
static void monitor_qmp_event(void *opaque, int event)
{
QDict *data;
Monitor *mon = opaque;
MonitorQMP *mon = opaque;
switch (event) {
case CHR_EVENT_OPENED:
mon->qmp.commands = &qmp_cap_negotiation_commands;
mon->commands = &qmp_cap_negotiation_commands;
monitor_qmp_caps_reset(mon);
data = qmp_greeting(mon);
qmp_send_response(mon, data);
@ -4432,8 +4455,8 @@ static void monitor_qmp_event(void *opaque, int event)
* is closed.
*/
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_destroy(&mon->parser);
json_message_parser_init(&mon->parser, handle_qmp_command,
mon, NULL);
mon_refcount--;
monitor_fdsets_cleanup();
@ -4595,33 +4618,37 @@ static void monitor_list_append(Monitor *mon)
static void monitor_qmp_setup_handlers_bh(void *opaque)
{
Monitor *mon = opaque;
MonitorQMP *mon = opaque;
GMainContext *context;
assert(mon->use_io_thread);
assert(mon->common.use_io_thread);
context = iothread_get_g_main_context(mon_iothread);
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);
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)
{
Monitor *mon = g_new0(Monitor, 1);
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, flags, false,
monitor_data_init(&mon->common, flags, false,
qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
qemu_chr_fe_init(&mon->chr, chr, &error_abort);
qemu_chr_fe_set_echo(&mon->chr, true);
qemu_mutex_init(&mon->qmp_queue_lock);
mon->qmp_requests = g_queue_new();
json_message_parser_init(&mon->qmp.parser, handle_qmp_command, mon, NULL);
if (mon->use_io_thread) {
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.
@ -4636,10 +4663,10 @@ static void monitor_init_qmp(Chardev *chr, int flags)
monitor_qmp_setup_handlers_bh, mon);
/* The bottom half will add @mon to @mon_list */
} else {
qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
monitor_qmp_read, monitor_qmp_event,
NULL, mon, NULL, true);
monitor_list_append(mon);
NULL, &mon->common, NULL, true);
monitor_list_append(&mon->common);
}
}