monitor: Split Monitor.flags into separate bools
[qemu.git] / monitor / qmp.c
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26
27 #include "chardev/char-io.h"
28 #include "monitor-internal.h"
29 #include "qapi/error.h"
30 #include "qapi/qapi-commands-misc.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qapi/qmp/qjson.h"
33 #include "qapi/qmp/qlist.h"
34 #include "qapi/qmp/qstring.h"
35 #include "trace.h"
36
37 struct QMPRequest {
38 /* Owner of the request */
39 MonitorQMP *mon;
40 /*
41 * Request object to be handled or Error to be reported
42 * (exactly one of them is non-null)
43 */
44 QObject *req;
45 Error *err;
46 };
47 typedef struct QMPRequest QMPRequest;
48
49 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
50
51 static bool qmp_oob_enabled(MonitorQMP *mon)
52 {
53 return mon->capab[QMP_CAPABILITY_OOB];
54 }
55
56 static void monitor_qmp_caps_reset(MonitorQMP *mon)
57 {
58 memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
59 memset(mon->capab, 0, sizeof(mon->capab));
60 mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
61 }
62
63 static void qmp_request_free(QMPRequest *req)
64 {
65 qobject_unref(req->req);
66 error_free(req->err);
67 g_free(req);
68 }
69
70 /* Caller must hold mon->qmp.qmp_queue_lock */
71 static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
72 {
73 while (!g_queue_is_empty(mon->qmp_requests)) {
74 qmp_request_free(g_queue_pop_head(mon->qmp_requests));
75 }
76 }
77
78 static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
79 {
80 qemu_mutex_lock(&mon->qmp_queue_lock);
81 monitor_qmp_cleanup_req_queue_locked(mon);
82 qemu_mutex_unlock(&mon->qmp_queue_lock);
83 }
84
85 void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
86 {
87 const QObject *data = QOBJECT(rsp);
88 QString *json;
89
90 json = mon->pretty ? qobject_to_json_pretty(data) : qobject_to_json(data);
91 assert(json != NULL);
92
93 qstring_append_chr(json, '\n');
94 monitor_puts(&mon->common, qstring_get_str(json));
95
96 qobject_unref(json);
97 }
98
99 /*
100 * Emit QMP response @rsp with ID @id to @mon.
101 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
102 * Nothing is emitted then.
103 */
104 static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
105 {
106 if (rsp) {
107 qmp_send_response(mon, rsp);
108 }
109 }
110
111 static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
112 {
113 Monitor *old_mon;
114 QDict *rsp;
115 QDict *error;
116
117 old_mon = cur_mon;
118 cur_mon = &mon->common;
119
120 rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
121
122 cur_mon = old_mon;
123
124 if (mon->commands == &qmp_cap_negotiation_commands) {
125 error = qdict_get_qdict(rsp, "error");
126 if (error
127 && !g_strcmp0(qdict_get_try_str(error, "class"),
128 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
129 /* Provide a more useful error message */
130 qdict_del(error, "desc");
131 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
132 " with 'qmp_capabilities'");
133 }
134 }
135
136 monitor_qmp_respond(mon, rsp);
137 qobject_unref(rsp);
138 }
139
140 /*
141 * Pop a QMP request from a monitor request queue.
142 * Return the request, or NULL all request queues are empty.
143 * We are using round-robin fashion to pop the request, to avoid
144 * processing commands only on a very busy monitor. To achieve that,
145 * when we process one request on a specific monitor, we put that
146 * monitor to the end of mon_list queue.
147 *
148 * Note: if the function returned with non-NULL, then the caller will
149 * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
150 * to release it.
151 */
152 static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
153 {
154 QMPRequest *req_obj = NULL;
155 Monitor *mon;
156 MonitorQMP *qmp_mon;
157
158 qemu_mutex_lock(&monitor_lock);
159
160 QTAILQ_FOREACH(mon, &mon_list, entry) {
161 if (!monitor_is_qmp(mon)) {
162 continue;
163 }
164
165 qmp_mon = container_of(mon, MonitorQMP, common);
166 qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
167 req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
168 if (req_obj) {
169 /* With the lock of corresponding queue held */
170 break;
171 }
172 qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
173 }
174
175 if (req_obj) {
176 /*
177 * We found one request on the monitor. Degrade this monitor's
178 * priority to lowest by re-inserting it to end of queue.
179 */
180 QTAILQ_REMOVE(&mon_list, mon, entry);
181 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
182 }
183
184 qemu_mutex_unlock(&monitor_lock);
185
186 return req_obj;
187 }
188
189 void monitor_qmp_bh_dispatcher(void *data)
190 {
191 QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
192 QDict *rsp;
193 bool need_resume;
194 MonitorQMP *mon;
195
196 if (!req_obj) {
197 return;
198 }
199
200 mon = req_obj->mon;
201 /* qmp_oob_enabled() might change after "qmp_capabilities" */
202 need_resume = !qmp_oob_enabled(mon) ||
203 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
204 qemu_mutex_unlock(&mon->qmp_queue_lock);
205 if (req_obj->req) {
206 QDict *qdict = qobject_to(QDict, req_obj->req);
207 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
208 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
209 monitor_qmp_dispatch(mon, req_obj->req);
210 } else {
211 assert(req_obj->err);
212 rsp = qmp_error_response(req_obj->err);
213 req_obj->err = NULL;
214 monitor_qmp_respond(mon, rsp);
215 qobject_unref(rsp);
216 }
217
218 if (need_resume) {
219 /* Pairs with the monitor_suspend() in handle_qmp_command() */
220 monitor_resume(&mon->common);
221 }
222 qmp_request_free(req_obj);
223
224 /* Reschedule instead of looping so the main loop stays responsive */
225 qemu_bh_schedule(qmp_dispatcher_bh);
226 }
227
228 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
229 {
230 MonitorQMP *mon = opaque;
231 QObject *id = NULL;
232 QDict *qdict;
233 QMPRequest *req_obj;
234
235 assert(!req != !err);
236
237 qdict = qobject_to(QDict, req);
238 if (qdict) {
239 id = qdict_get(qdict, "id");
240 } /* else will fail qmp_dispatch() */
241
242 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
243 QString *req_json = qobject_to_json(req);
244 trace_handle_qmp_command(mon, qstring_get_str(req_json));
245 qobject_unref(req_json);
246 }
247
248 if (qdict && qmp_is_oob(qdict)) {
249 /* OOB commands are executed immediately */
250 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
251 monitor_qmp_dispatch(mon, req);
252 qobject_unref(req);
253 return;
254 }
255
256 req_obj = g_new0(QMPRequest, 1);
257 req_obj->mon = mon;
258 req_obj->req = req;
259 req_obj->err = err;
260
261 /* Protect qmp_requests and fetching its length. */
262 qemu_mutex_lock(&mon->qmp_queue_lock);
263
264 /*
265 * Suspend the monitor when we can't queue more requests after
266 * this one. Dequeuing in monitor_qmp_bh_dispatcher() will resume
267 * it. Note that when OOB is disabled, we queue at most one
268 * command, for backward compatibility.
269 */
270 if (!qmp_oob_enabled(mon) ||
271 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
272 monitor_suspend(&mon->common);
273 }
274
275 /*
276 * Put the request to the end of queue so that requests will be
277 * handled in time order. Ownership for req_obj, req,
278 * etc. will be delivered to the handler side.
279 */
280 assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
281 g_queue_push_tail(mon->qmp_requests, req_obj);
282 qemu_mutex_unlock(&mon->qmp_queue_lock);
283
284 /* Kick the dispatcher routine */
285 qemu_bh_schedule(qmp_dispatcher_bh);
286 }
287
288 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
289 {
290 MonitorQMP *mon = opaque;
291
292 json_message_parser_feed(&mon->parser, (const char *) buf, size);
293 }
294
295 static QDict *qmp_greeting(MonitorQMP *mon)
296 {
297 QList *cap_list = qlist_new();
298 QObject *ver = NULL;
299 QMPCapability cap;
300
301 qmp_marshal_query_version(NULL, &ver, NULL);
302
303 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
304 if (mon->capab_offered[cap]) {
305 qlist_append_str(cap_list, QMPCapability_str(cap));
306 }
307 }
308
309 return qdict_from_jsonf_nofail(
310 "{'QMP': {'version': %p, 'capabilities': %p}}",
311 ver, cap_list);
312 }
313
314 static void monitor_qmp_event(void *opaque, int event)
315 {
316 QDict *data;
317 MonitorQMP *mon = opaque;
318
319 switch (event) {
320 case CHR_EVENT_OPENED:
321 mon->commands = &qmp_cap_negotiation_commands;
322 monitor_qmp_caps_reset(mon);
323 data = qmp_greeting(mon);
324 qmp_send_response(mon, data);
325 qobject_unref(data);
326 mon_refcount++;
327 break;
328 case CHR_EVENT_CLOSED:
329 /*
330 * Note: this is only useful when the output of the chardev
331 * backend is still open. For example, when the backend is
332 * stdio, it's possible that stdout is still open when stdin
333 * is closed.
334 */
335 monitor_qmp_cleanup_queues(mon);
336 json_message_parser_destroy(&mon->parser);
337 json_message_parser_init(&mon->parser, handle_qmp_command,
338 mon, NULL);
339 mon_refcount--;
340 monitor_fdsets_cleanup();
341 break;
342 }
343 }
344
345 void monitor_data_destroy_qmp(MonitorQMP *mon)
346 {
347 json_message_parser_destroy(&mon->parser);
348 qemu_mutex_destroy(&mon->qmp_queue_lock);
349 monitor_qmp_cleanup_req_queue_locked(mon);
350 g_queue_free(mon->qmp_requests);
351 }
352
353 static void monitor_qmp_setup_handlers_bh(void *opaque)
354 {
355 MonitorQMP *mon = opaque;
356 GMainContext *context;
357
358 assert(mon->common.use_io_thread);
359 context = iothread_get_g_main_context(mon_iothread);
360 assert(context);
361 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
362 monitor_qmp_read, monitor_qmp_event,
363 NULL, &mon->common, context, true);
364 monitor_list_append(&mon->common);
365 }
366
367 void monitor_init_qmp(Chardev *chr, int flags)
368 {
369 MonitorQMP *mon = g_new0(MonitorQMP, 1);
370
371 /* Only HMP supports readline */
372 assert(!(flags & MONITOR_USE_READLINE));
373
374 /* Note: we run QMP monitor in I/O thread when @chr supports that */
375 monitor_data_init(&mon->common, true, false,
376 qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
377
378 mon->pretty = flags & MONITOR_USE_PRETTY;
379
380 qemu_mutex_init(&mon->qmp_queue_lock);
381 mon->qmp_requests = g_queue_new();
382
383 qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
384 qemu_chr_fe_set_echo(&mon->common.chr, true);
385
386 json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
387 if (mon->common.use_io_thread) {
388 /*
389 * Make sure the old iowatch is gone. It's possible when
390 * e.g. the chardev is in client mode, with wait=on.
391 */
392 remove_fd_in_watch(chr);
393 /*
394 * We can't call qemu_chr_fe_set_handlers() directly here
395 * since chardev might be running in the monitor I/O
396 * thread. Schedule a bottom half.
397 */
398 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
399 monitor_qmp_setup_handlers_bh, mon);
400 /* The bottom half will add @mon to @mon_list */
401 } else {
402 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
403 monitor_qmp_read, monitor_qmp_event,
404 NULL, &mon->common, NULL, true);
405 monitor_list_append(&mon->common);
406 }
407 }