diff options
Diffstat (limited to 'qapi/qmp-dispatch.c')
| -rw-r--r-- | qapi/qmp-dispatch.c | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/qapi/qmp-dispatch.c b/qapi/qmp-dispatch.c new file mode 100644 index 000000000..d378bccac --- /dev/null +++ b/qapi/qmp-dispatch.c @@ -0,0 +1,275 @@ +/* + * Core Definitions for QAPI/QMP Dispatch + * + * Copyright IBM, Corp. 2011 + * + * Authors: + * Anthony Liguori <aliguori@us.ibm.com> + * + * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. + * See the COPYING.LIB file in the top-level directory. + * + */ + +#include "qemu/osdep.h" + +#include "block/aio.h" +#include "qapi/compat-policy.h" +#include "qapi/error.h" +#include "qapi/qmp/dispatch.h" +#include "qapi/qmp/qdict.h" +#include "qapi/qmp/qjson.h" +#include "qapi/qobject-input-visitor.h" +#include "qapi/qobject-output-visitor.h" +#include "sysemu/runstate.h" +#include "qapi/qmp/qbool.h" +#include "qemu/coroutine.h" +#include "qemu/main-loop.h" + +Visitor *qobject_input_visitor_new_qmp(QObject *obj) +{ + Visitor *v = qobject_input_visitor_new(obj); + + visit_set_policy(v, &compat_policy); + return v; +} + +Visitor *qobject_output_visitor_new_qmp(QObject **result) +{ + Visitor *v = qobject_output_visitor_new(result); + + visit_set_policy(v, &compat_policy); + return v; +} + +static QDict *qmp_dispatch_check_obj(QDict *dict, bool allow_oob, + Error **errp) +{ + const char *exec_key = NULL; + const QDictEntry *ent; + const char *arg_name; + const QObject *arg_obj; + + for (ent = qdict_first(dict); ent; + ent = qdict_next(dict, ent)) { + arg_name = qdict_entry_key(ent); + arg_obj = qdict_entry_value(ent); + + if (!strcmp(arg_name, "execute") + || (!strcmp(arg_name, "exec-oob") && allow_oob)) { + if (qobject_type(arg_obj) != QTYPE_QSTRING) { + error_setg(errp, "QMP input member '%s' must be a string", + arg_name); + return NULL; + } + if (exec_key) { + error_setg(errp, "QMP input member '%s' clashes with '%s'", + arg_name, exec_key); + return NULL; + } + exec_key = arg_name; + } else if (!strcmp(arg_name, "arguments")) { + if (qobject_type(arg_obj) != QTYPE_QDICT) { + error_setg(errp, + "QMP input member 'arguments' must be an object"); + return NULL; + } + } else if (!strcmp(arg_name, "id")) { + continue; + } else { + error_setg(errp, "QMP input member '%s' is unexpected", + arg_name); + return NULL; + } + } + + if (!exec_key) { + error_setg(errp, "QMP input lacks member 'execute'"); + return NULL; + } + + return dict; +} + +QDict *qmp_error_response(Error *err) +{ + QDict *rsp; + + rsp = qdict_from_jsonf_nofail("{ 'error': { 'class': %s, 'desc': %s } }", + QapiErrorClass_str(error_get_class(err)), + error_get_pretty(err)); + error_free(err); + return rsp; +} + +/* + * Does @qdict look like a command to be run out-of-band? + */ +bool qmp_is_oob(const QDict *dict) +{ + return qdict_haskey(dict, "exec-oob") + && !qdict_haskey(dict, "execute"); +} + +typedef struct QmpDispatchBH { + const QmpCommand *cmd; + Monitor *cur_mon; + QDict *args; + QObject **ret; + Error **errp; + Coroutine *co; +} QmpDispatchBH; + +static void do_qmp_dispatch_bh(void *opaque) +{ + QmpDispatchBH *data = opaque; + + assert(monitor_cur() == NULL); + monitor_set_cur(qemu_coroutine_self(), data->cur_mon); + data->cmd->fn(data->args, data->ret, data->errp); + monitor_set_cur(qemu_coroutine_self(), NULL); + aio_co_wake(data->co); +} + +/* + * Runs outside of coroutine context for OOB commands, but in coroutine + * context for everything else. + */ +QDict *qmp_dispatch(const QmpCommandList *cmds, QObject *request, + bool allow_oob, Monitor *cur_mon) +{ + Error *err = NULL; + bool oob; + const char *command; + QDict *args; + const QmpCommand *cmd; + QDict *dict; + QObject *id; + QObject *ret = NULL; + QDict *rsp = NULL; + + dict = qobject_to(QDict, request); + if (!dict) { + id = NULL; + error_setg(&err, "QMP input must be a JSON object"); + goto out; + } + + id = qdict_get(dict, "id"); + + if (!qmp_dispatch_check_obj(dict, allow_oob, &err)) { + goto out; + } + + command = qdict_get_try_str(dict, "execute"); + oob = false; + if (!command) { + assert(allow_oob); + command = qdict_get_str(dict, "exec-oob"); + oob = true; + } + cmd = qmp_find_command(cmds, command); + if (cmd == NULL) { + error_set(&err, ERROR_CLASS_COMMAND_NOT_FOUND, + "The command %s has not been found", command); + goto out; + } + if (!compat_policy_input_ok(cmd->special_features, &compat_policy, + ERROR_CLASS_COMMAND_NOT_FOUND, + "command", command, &err)) { + goto out; + } + if (!cmd->enabled) { + error_set(&err, ERROR_CLASS_COMMAND_NOT_FOUND, + "Command %s has been disabled%s%s", + command, + cmd->disable_reason ? ": " : "", + cmd->disable_reason ?: ""); + goto out; + } + if (oob && !(cmd->options & QCO_ALLOW_OOB)) { + error_setg(&err, "The command %s does not support OOB", + command); + goto out; + } + + if (!qmp_command_available(cmd, &err)) { + goto out; + } + + if (!qdict_haskey(dict, "arguments")) { + args = qdict_new(); + } else { + args = qdict_get_qdict(dict, "arguments"); + qobject_ref(args); + } + + assert(!(oob && qemu_in_coroutine())); + assert(monitor_cur() == NULL); + if (!!(cmd->options & QCO_COROUTINE) == qemu_in_coroutine()) { + monitor_set_cur(qemu_coroutine_self(), cur_mon); + cmd->fn(args, &ret, &err); + monitor_set_cur(qemu_coroutine_self(), NULL); + } else { + /* + * Actual context doesn't match the one the command needs. + * + * Case 1: we are in coroutine context, but command does not + * have QCO_COROUTINE. We need to drop out of coroutine + * context for executing it. + * + * Case 2: we are outside coroutine context, but command has + * QCO_COROUTINE. Can't actually happen, because we get here + * outside coroutine context only when executing a command + * out of band, and OOB commands never have QCO_COROUTINE. + */ + assert(!oob && qemu_in_coroutine() && !(cmd->options & QCO_COROUTINE)); + + QmpDispatchBH data = { + .cur_mon = cur_mon, + .cmd = cmd, + .args = args, + .ret = &ret, + .errp = &err, + .co = qemu_coroutine_self(), + }; + aio_bh_schedule_oneshot(qemu_get_aio_context(), do_qmp_dispatch_bh, + &data); + qemu_coroutine_yield(); + } + qobject_unref(args); + if (err) { + /* or assert(!ret) after reviewing all handlers: */ + qobject_unref(ret); + goto out; + } + + if (cmd->options & QCO_NO_SUCCESS_RESP) { + g_assert(!ret); + return NULL; + } else if (!ret) { + /* + * When the command's schema has no 'returns', cmd->fn() + * leaves @ret null. The QMP spec calls for an empty object + * then; supply it. + */ + ret = QOBJECT(qdict_new()); + } + + rsp = qdict_new(); + qdict_put_obj(rsp, "return", ret); + +out: + if (err) { + assert(!rsp); + rsp = qmp_error_response(err); + } + + assert(rsp); + + if (id) { + qdict_put_obj(rsp, "id", qobject_ref(id)); + } + + return rsp; +} |