1 /*
2 * Core Definitions for QAPI/QMP Dispatch
3 *
4 * Copyright IBM, Corp. 2011
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15
16 #include "block/aio.h"
17 #include "qapi/compat-policy.h"
18 #include "qapi/error.h"
19 #include "qapi/qmp/dispatch.h"
20 #include "qapi/qmp/qdict.h"
21 #include "qapi/qmp/qjson.h"
22 #include "qapi/qobject-input-visitor.h"
23 #include "qapi/qobject-output-visitor.h"
24 #include "qapi/qmp/qbool.h"
25 #include "qemu/coroutine.h"
26 #include "qemu/main-loop.h"
27
qobject_input_visitor_new_qmp(QObject * obj)28 Visitor *qobject_input_visitor_new_qmp(QObject *obj)
29 {
30 Visitor *v = qobject_input_visitor_new(obj);
31
32 visit_set_policy(v, &compat_policy);
33 return v;
34 }
35
qobject_output_visitor_new_qmp(QObject ** result)36 Visitor *qobject_output_visitor_new_qmp(QObject **result)
37 {
38 Visitor *v = qobject_output_visitor_new(result);
39
40 visit_set_policy(v, &compat_policy);
41 return v;
42 }
43
qmp_dispatch_check_obj(QDict * dict,bool allow_oob,Error ** errp)44 static QDict *qmp_dispatch_check_obj(QDict *dict, bool allow_oob,
45 Error **errp)
46 {
47 const char *exec_key = NULL;
48 const QDictEntry *ent;
49 const char *arg_name;
50 const QObject *arg_obj;
51
52 for (ent = qdict_first(dict); ent;
53 ent = qdict_next(dict, ent)) {
54 arg_name = qdict_entry_key(ent);
55 arg_obj = qdict_entry_value(ent);
56
57 if (!strcmp(arg_name, "execute")
58 || (!strcmp(arg_name, "exec-oob") && allow_oob)) {
59 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
60 error_setg(errp, "QMP input member '%s' must be a string",
61 arg_name);
62 return NULL;
63 }
64 if (exec_key) {
65 error_setg(errp, "QMP input member '%s' clashes with '%s'",
66 arg_name, exec_key);
67 return NULL;
68 }
69 exec_key = arg_name;
70 } else if (!strcmp(arg_name, "arguments")) {
71 if (qobject_type(arg_obj) != QTYPE_QDICT) {
72 error_setg(errp,
73 "QMP input member 'arguments' must be an object");
74 return NULL;
75 }
76 } else if (!strcmp(arg_name, "id")) {
77 continue;
78 } else {
79 error_setg(errp, "QMP input member '%s' is unexpected",
80 arg_name);
81 return NULL;
82 }
83 }
84
85 if (!exec_key) {
86 error_setg(errp, "QMP input lacks member 'execute'");
87 return NULL;
88 }
89
90 return dict;
91 }
92
qmp_error_response(Error * err)93 QDict *qmp_error_response(Error *err)
94 {
95 QDict *rsp;
96
97 rsp = qdict_from_jsonf_nofail("{ 'error': { 'class': %s, 'desc': %s } }",
98 QapiErrorClass_str(error_get_class(err)),
99 error_get_pretty(err));
100 error_free(err);
101 return rsp;
102 }
103
104 /*
105 * Does @qdict look like a command to be run out-of-band?
106 */
qmp_is_oob(const QDict * dict)107 bool qmp_is_oob(const QDict *dict)
108 {
109 return qdict_haskey(dict, "exec-oob")
110 && !qdict_haskey(dict, "execute");
111 }
112
113 typedef struct QmpDispatchBH {
114 const QmpCommand *cmd;
115 Monitor *cur_mon;
116 QDict *args;
117 QObject **ret;
118 Error **errp;
119 Coroutine *co;
120 } QmpDispatchBH;
121
do_qmp_dispatch_bh(void * opaque)122 static void do_qmp_dispatch_bh(void *opaque)
123 {
124 QmpDispatchBH *data = opaque;
125
126 assert(monitor_cur() == NULL);
127 monitor_set_cur(qemu_coroutine_self(), data->cur_mon);
128 data->cmd->fn(data->args, data->ret, data->errp);
129 monitor_set_cur(qemu_coroutine_self(), NULL);
130 aio_co_wake(data->co);
131 }
132
133 /*
134 * Runs outside of coroutine context for OOB commands, but in coroutine
135 * context for everything else.
136 */
qmp_dispatch(const QmpCommandList * cmds,QObject * request,bool allow_oob,Monitor * cur_mon)137 QDict *coroutine_mixed_fn qmp_dispatch(const QmpCommandList *cmds, QObject *request,
138 bool allow_oob, Monitor *cur_mon)
139 {
140 Error *err = NULL;
141 bool oob;
142 const char *command;
143 QDict *args;
144 const QmpCommand *cmd;
145 QDict *dict;
146 QObject *id;
147 QObject *ret = NULL;
148 QDict *rsp = NULL;
149
150 dict = qobject_to(QDict, request);
151 if (!dict) {
152 id = NULL;
153 error_setg(&err, "QMP input must be a JSON object");
154 goto out;
155 }
156
157 id = qdict_get(dict, "id");
158
159 if (!qmp_dispatch_check_obj(dict, allow_oob, &err)) {
160 goto out;
161 }
162
163 command = qdict_get_try_str(dict, "execute");
164 oob = false;
165 if (!command) {
166 assert(allow_oob);
167 command = qdict_get_str(dict, "exec-oob");
168 oob = true;
169 }
170 cmd = qmp_find_command(cmds, command);
171 if (cmd == NULL) {
172 error_set(&err, ERROR_CLASS_COMMAND_NOT_FOUND,
173 "The command %s has not been found", command);
174 goto out;
175 }
176 if (!compat_policy_input_ok(cmd->special_features, &compat_policy,
177 ERROR_CLASS_COMMAND_NOT_FOUND,
178 "command", command, &err)) {
179 goto out;
180 }
181 if (!cmd->enabled) {
182 error_set(&err, ERROR_CLASS_COMMAND_NOT_FOUND,
183 "Command %s has been disabled%s%s",
184 command,
185 cmd->disable_reason ? ": " : "",
186 cmd->disable_reason ?: "");
187 goto out;
188 }
189 if (oob && !(cmd->options & QCO_ALLOW_OOB)) {
190 error_setg(&err, "The command %s does not support OOB",
191 command);
192 goto out;
193 }
194
195 if (!qmp_command_available(cmd, &err)) {
196 goto out;
197 }
198
199 if (!qdict_haskey(dict, "arguments")) {
200 args = qdict_new();
201 } else {
202 args = qdict_get_qdict(dict, "arguments");
203 qobject_ref(args);
204 }
205
206 assert(!(oob && qemu_in_coroutine()));
207 assert(monitor_cur() == NULL);
208 if (!!(cmd->options & QCO_COROUTINE) == qemu_in_coroutine()) {
209 if (qemu_in_coroutine()) {
210 /*
211 * Move the coroutine from iohandler_ctx to qemu_aio_context for
212 * executing the command handler so that it can make progress if it
213 * involves an AIO_WAIT_WHILE().
214 */
215 aio_co_schedule(qemu_get_aio_context(), qemu_coroutine_self());
216 qemu_coroutine_yield();
217 }
218
219 monitor_set_cur(qemu_coroutine_self(), cur_mon);
220 cmd->fn(args, &ret, &err);
221 monitor_set_cur(qemu_coroutine_self(), NULL);
222
223 if (qemu_in_coroutine()) {
224 /*
225 * Yield and reschedule so the main loop stays responsive.
226 *
227 * Move back to iohandler_ctx so that nested event loops for
228 * qemu_aio_context don't start new monitor commands.
229 */
230 aio_co_schedule(iohandler_get_aio_context(),
231 qemu_coroutine_self());
232 qemu_coroutine_yield();
233 }
234 } else {
235 /*
236 * Actual context doesn't match the one the command needs.
237 *
238 * Case 1: we are in coroutine context, but command does not
239 * have QCO_COROUTINE. We need to drop out of coroutine
240 * context for executing it.
241 *
242 * Case 2: we are outside coroutine context, but command has
243 * QCO_COROUTINE. Can't actually happen, because we get here
244 * outside coroutine context only when executing a command
245 * out of band, and OOB commands never have QCO_COROUTINE.
246 */
247 assert(!oob && qemu_in_coroutine() && !(cmd->options & QCO_COROUTINE));
248
249 QmpDispatchBH data = {
250 .cur_mon = cur_mon,
251 .cmd = cmd,
252 .args = args,
253 .ret = &ret,
254 .errp = &err,
255 .co = qemu_coroutine_self(),
256 };
257 aio_bh_schedule_oneshot(iohandler_get_aio_context(), do_qmp_dispatch_bh,
258 &data);
259 qemu_coroutine_yield();
260 }
261 qobject_unref(args);
262 if (err) {
263 /* or assert(!ret) after reviewing all handlers: */
264 qobject_unref(ret);
265 goto out;
266 }
267
268 if (cmd->options & QCO_NO_SUCCESS_RESP) {
269 g_assert(!ret);
270 return NULL;
271 } else if (!ret) {
272 /*
273 * When the command's schema has no 'returns', cmd->fn()
274 * leaves @ret null. The QMP spec calls for an empty object
275 * then; supply it.
276 */
277 ret = QOBJECT(qdict_new());
278 }
279
280 rsp = qdict_new();
281 qdict_put_obj(rsp, "return", ret);
282
283 out:
284 if (err) {
285 assert(!rsp);
286 rsp = qmp_error_response(err);
287 }
288
289 assert(rsp);
290
291 if (id) {
292 qdict_put_obj(rsp, "id", qobject_ref(id));
293 }
294
295 return rsp;
296 }
297