xref: /openbmc/qemu/monitor/qmp.c (revision 3e964275)
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-control.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qapi/qmp/qjson.h"
33 #include "qapi/qmp/qlist.h"
34 #include "trace.h"
35 
36 /*
37  * qmp_dispatcher_co_busy is used for synchronisation between the
38  * monitor thread and the main thread to ensure that the dispatcher
39  * coroutine never gets scheduled a second time when it's already
40  * scheduled (scheduling the same coroutine twice is forbidden).
41  *
42  * It is true if the coroutine will process at least one more request
43  * before going to sleep.  Either it has been kicked already, or it
44  * is active and processing requests.  Additional requests may therefore
45  * be pushed onto mon->qmp_requests, and @qmp_dispatcher_co_shutdown may
46  * be set without further ado.  @qmp_dispatcher_co must not be woken up
47  * in this case.
48  *
49  * If false, you have to wake up @qmp_dispatcher_co after pushing new
50  * requests. You also have to set @qmp_dispatcher_co_busy to true
51  * before waking up the coroutine.
52  *
53  * The coroutine will automatically change this variable back to false
54  * before it yields.  Nobody else may set the variable to false.
55  *
56  * Access must be atomic for thread safety.
57  */
58 static bool qmp_dispatcher_co_busy = true;
59 
60 struct QMPRequest {
61     /* Owner of the request */
62     MonitorQMP *mon;
63     /*
64      * Request object to be handled or Error to be reported
65      * (exactly one of them is non-null)
66      */
67     QObject *req;
68     Error *err;
69 };
70 typedef struct QMPRequest QMPRequest;
71 
72 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
73 
74 static bool qmp_oob_enabled(MonitorQMP *mon)
75 {
76     return mon->capab[QMP_CAPABILITY_OOB];
77 }
78 
79 static void monitor_qmp_caps_reset(MonitorQMP *mon)
80 {
81     memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
82     memset(mon->capab, 0, sizeof(mon->capab));
83     mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
84 }
85 
86 static void qmp_request_free(QMPRequest *req)
87 {
88     qobject_unref(req->req);
89     error_free(req->err);
90     g_free(req);
91 }
92 
93 /* Caller must hold mon->qmp.qmp_queue_lock */
94 static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
95 {
96     while (!g_queue_is_empty(mon->qmp_requests)) {
97         qmp_request_free(g_queue_pop_head(mon->qmp_requests));
98     }
99 }
100 
101 static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
102 {
103     QEMU_LOCK_GUARD(&mon->qmp_queue_lock);
104 
105     /*
106      * Same condition as in monitor_qmp_dispatcher_co(), but before
107      * removing an element from the queue (hence no `- 1`).
108      * Also, the queue should not be empty either, otherwise the
109      * monitor hasn't been suspended yet (or was already resumed).
110      */
111     bool need_resume = (!qmp_oob_enabled(mon) ||
112         mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
113         && !g_queue_is_empty(mon->qmp_requests);
114 
115     monitor_qmp_cleanup_req_queue_locked(mon);
116 
117     if (need_resume) {
118         /*
119          * handle_qmp_command() suspended the monitor because the
120          * request queue filled up, to be resumed when the queue has
121          * space again.  We just emptied it; resume the monitor.
122          *
123          * Without this, the monitor would remain suspended forever
124          * when we get here while the monitor is suspended.  An
125          * unfortunately timed CHR_EVENT_CLOSED can do the trick.
126          */
127         monitor_resume(&mon->common);
128     }
129 
130 }
131 
132 void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
133 {
134     const QObject *data = QOBJECT(rsp);
135     GString *json;
136 
137     json = qobject_to_json_pretty(data, mon->pretty);
138     assert(json != NULL);
139     trace_monitor_qmp_respond(mon, json->str);
140 
141     g_string_append_c(json, '\n');
142     monitor_puts(&mon->common, json->str);
143 
144     g_string_free(json, true);
145 }
146 
147 /*
148  * Emit QMP response @rsp to @mon.
149  * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
150  * Nothing is emitted then.
151  */
152 static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
153 {
154     if (rsp) {
155         qmp_send_response(mon, rsp);
156     }
157 }
158 
159 /*
160  * Runs outside of coroutine context for OOB commands, but in
161  * coroutine context for everything else.
162  */
163 static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
164 {
165     QDict *rsp;
166     QDict *error;
167 
168     rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon),
169                        &mon->common);
170 
171     if (mon->commands == &qmp_cap_negotiation_commands) {
172         error = qdict_get_qdict(rsp, "error");
173         if (error
174             && !g_strcmp0(qdict_get_try_str(error, "class"),
175                     QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
176             /* Provide a more useful error message */
177             qdict_del(error, "desc");
178             qdict_put_str(error, "desc", "Expecting capabilities negotiation"
179                           " with 'qmp_capabilities'");
180         }
181     }
182 
183     monitor_qmp_respond(mon, rsp);
184     qobject_unref(rsp);
185 }
186 
187 /*
188  * Pop a QMP request from a monitor request queue.
189  * Return the request, or NULL all request queues are empty.
190  * We are using round-robin fashion to pop the request, to avoid
191  * processing commands only on a very busy monitor.  To achieve that,
192  * when we process one request on a specific monitor, we put that
193  * monitor to the end of mon_list queue.
194  *
195  * Note: if the function returned with non-NULL, then the caller will
196  * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
197  * to release it.
198  */
199 static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
200 {
201     QMPRequest *req_obj = NULL;
202     Monitor *mon;
203     MonitorQMP *qmp_mon;
204 
205     QTAILQ_FOREACH(mon, &mon_list, entry) {
206         if (!monitor_is_qmp(mon)) {
207             continue;
208         }
209 
210         qmp_mon = container_of(mon, MonitorQMP, common);
211         qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
212         req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
213         if (req_obj) {
214             /* With the lock of corresponding queue held */
215             break;
216         }
217         qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
218     }
219 
220     if (req_obj) {
221         /*
222          * We found one request on the monitor. Degrade this monitor's
223          * priority to lowest by re-inserting it to end of queue.
224          */
225         QTAILQ_REMOVE(&mon_list, mon, entry);
226         QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
227     }
228 
229     return req_obj;
230 }
231 
232 static QMPRequest *monitor_qmp_dispatcher_pop_any(void)
233 {
234     while (true) {
235         /*
236          * To avoid double scheduling, busy is true on entry to
237          * monitor_qmp_dispatcher_co(), and must be set again before
238          * aio_co_wake()-ing it.
239          */
240         assert(qatomic_read(&qmp_dispatcher_co_busy) == true);
241 
242         /*
243          * Mark the dispatcher as not busy already here so that we
244          * don't miss any new requests coming in the middle of our
245          * processing.
246          *
247          * Clear qmp_dispatcher_co_busy before reading request.
248          */
249         qatomic_set_mb(&qmp_dispatcher_co_busy, false);
250 
251         WITH_QEMU_LOCK_GUARD(&monitor_lock) {
252             QMPRequest *req_obj;
253 
254             /* On shutdown, don't take any more requests from the queue */
255             if (qmp_dispatcher_co_shutdown) {
256                 return NULL;
257             }
258 
259             req_obj = monitor_qmp_requests_pop_any_with_lock();
260             if (req_obj) {
261                 return req_obj;
262             }
263         }
264 
265         /*
266          * No more requests to process.  Wait to be reentered from
267          * handle_qmp_command() when it pushes more requests, or
268          * from monitor_cleanup() when it requests shutdown.
269          */
270         qemu_coroutine_yield();
271     }
272 }
273 
274 void coroutine_fn monitor_qmp_dispatcher_co(void *data)
275 {
276     QMPRequest *req_obj;
277     QDict *rsp;
278     bool oob_enabled;
279     MonitorQMP *mon;
280 
281     while ((req_obj = monitor_qmp_dispatcher_pop_any()) != NULL) {
282         trace_monitor_qmp_in_band_dequeue(req_obj,
283                                           req_obj->mon->qmp_requests->length);
284 
285         /*
286          * @req_obj has a request, we hold req_obj->mon->qmp_queue_lock
287          */
288 
289         mon = req_obj->mon;
290 
291         /*
292          * We need to resume the monitor if handle_qmp_command()
293          * suspended it.  Two cases:
294          * 1. OOB enabled: mon->qmp_requests has no more space
295          *    Resume right away, so that OOB commands can get executed while
296          *    this request is being processed.
297          * 2. OOB disabled: always
298          *    Resume only after we're done processing the request,
299          * We need to save qmp_oob_enabled() for later, because
300          * qmp_qmp_capabilities() can change it.
301          */
302         oob_enabled = qmp_oob_enabled(mon);
303         if (oob_enabled
304             && mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
305             monitor_resume(&mon->common);
306         }
307 
308         /*
309          * Drop the queue mutex now, before yielding, otherwise we might
310          * deadlock if the main thread tries to lock it.
311          */
312         qemu_mutex_unlock(&mon->qmp_queue_lock);
313 
314         if (qatomic_xchg(&qmp_dispatcher_co_busy, true) == true) {
315             /*
316              * Someone rescheduled us (probably because a new requests
317              * came in), but we didn't actually yield. Do that now,
318              * only to be immediately reentered and removed from the
319              * list of scheduled coroutines.
320              */
321             qemu_coroutine_yield();
322         }
323 
324         /* Process request */
325         if (req_obj->req) {
326             if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_IN_BAND)) {
327                 QDict *qdict = qobject_to(QDict, req_obj->req);
328                 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
329                 GString *id_json;
330 
331                 id_json = id ? qobject_to_json(id) : g_string_new(NULL);
332                 trace_monitor_qmp_cmd_in_band(id_json->str);
333                 g_string_free(id_json, true);
334             }
335             monitor_qmp_dispatch(mon, req_obj->req);
336         } else {
337             assert(req_obj->err);
338             trace_monitor_qmp_err_in_band(error_get_pretty(req_obj->err));
339             rsp = qmp_error_response(req_obj->err);
340             req_obj->err = NULL;
341             monitor_qmp_respond(mon, rsp);
342             qobject_unref(rsp);
343         }
344 
345         if (!oob_enabled) {
346             monitor_resume(&mon->common);
347         }
348 
349         qmp_request_free(req_obj);
350     }
351     qatomic_set(&qmp_dispatcher_co, NULL);
352 }
353 
354 void qmp_dispatcher_co_wake(void)
355 {
356     /* Write request before reading qmp_dispatcher_co_busy.  */
357     smp_mb__before_rmw();
358 
359     if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) {
360         aio_co_wake(qmp_dispatcher_co);
361     }
362 }
363 
364 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
365 {
366     MonitorQMP *mon = opaque;
367     QDict *qdict = qobject_to(QDict, req);
368     QMPRequest *req_obj;
369 
370     assert(!req != !err);
371 
372     if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
373         GString *req_json = qobject_to_json(req);
374         trace_handle_qmp_command(mon, req_json->str);
375         g_string_free(req_json, true);
376     }
377 
378     if (qdict && qmp_is_oob(qdict)) {
379         /* OOB commands are executed immediately */
380         if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_OUT_OF_BAND)) {
381             QObject *id = qdict_get(qdict, "id");
382             GString *id_json;
383 
384             id_json = id ? qobject_to_json(id) : g_string_new(NULL);
385             trace_monitor_qmp_cmd_out_of_band(id_json->str);
386             g_string_free(id_json, true);
387         }
388         monitor_qmp_dispatch(mon, req);
389         qobject_unref(req);
390         return;
391     }
392 
393     req_obj = g_new0(QMPRequest, 1);
394     req_obj->mon = mon;
395     req_obj->req = req;
396     req_obj->err = err;
397 
398     /* Protect qmp_requests and fetching its length. */
399     WITH_QEMU_LOCK_GUARD(&mon->qmp_queue_lock) {
400 
401         /*
402          * Suspend the monitor when we can't queue more requests after
403          * this one.  Dequeuing in monitor_qmp_dispatcher_co() or
404          * monitor_qmp_cleanup_queue_and_resume() will resume it.
405          * Note that when OOB is disabled, we queue at most one command,
406          * for backward compatibility.
407          */
408         if (!qmp_oob_enabled(mon) ||
409             mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
410             monitor_suspend(&mon->common);
411         }
412 
413         /*
414          * Put the request to the end of queue so that requests will be
415          * handled in time order.  Ownership for req_obj, req,
416          * etc. will be delivered to the handler side.
417          */
418         trace_monitor_qmp_in_band_enqueue(req_obj, mon,
419                                           mon->qmp_requests->length);
420         assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
421         g_queue_push_tail(mon->qmp_requests, req_obj);
422     }
423 
424     /* Kick the dispatcher routine */
425     qmp_dispatcher_co_wake();
426 }
427 
428 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
429 {
430     MonitorQMP *mon = opaque;
431 
432     json_message_parser_feed(&mon->parser, (const char *) buf, size);
433 }
434 
435 static QDict *qmp_greeting(MonitorQMP *mon)
436 {
437     QList *cap_list = qlist_new();
438     QObject *ver = NULL;
439     QDict *args;
440     QMPCapability cap;
441 
442     args = qdict_new();
443     qmp_marshal_query_version(args, &ver, NULL);
444     qobject_unref(args);
445 
446     for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
447         if (mon->capab_offered[cap]) {
448             qlist_append_str(cap_list, QMPCapability_str(cap));
449         }
450     }
451 
452     return qdict_from_jsonf_nofail(
453         "{'QMP': {'version': %p, 'capabilities': %p}}",
454         ver, cap_list);
455 }
456 
457 static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
458 {
459     QDict *data;
460     MonitorQMP *mon = opaque;
461 
462     switch (event) {
463     case CHR_EVENT_OPENED:
464         mon->commands = &qmp_cap_negotiation_commands;
465         monitor_qmp_caps_reset(mon);
466         data = qmp_greeting(mon);
467         qmp_send_response(mon, data);
468         qobject_unref(data);
469         mon_refcount++;
470         break;
471     case CHR_EVENT_CLOSED:
472         /*
473          * Note: this is only useful when the output of the chardev
474          * backend is still open.  For example, when the backend is
475          * stdio, it's possible that stdout is still open when stdin
476          * is closed.
477          */
478         monitor_qmp_cleanup_queue_and_resume(mon);
479         json_message_parser_destroy(&mon->parser);
480         json_message_parser_init(&mon->parser, handle_qmp_command,
481                                  mon, NULL);
482         mon_refcount--;
483         monitor_fdsets_cleanup();
484         break;
485     case CHR_EVENT_BREAK:
486     case CHR_EVENT_MUX_IN:
487     case CHR_EVENT_MUX_OUT:
488         /* Ignore */
489         break;
490     }
491 }
492 
493 void monitor_data_destroy_qmp(MonitorQMP *mon)
494 {
495     json_message_parser_destroy(&mon->parser);
496     qemu_mutex_destroy(&mon->qmp_queue_lock);
497     monitor_qmp_cleanup_req_queue_locked(mon);
498     g_queue_free(mon->qmp_requests);
499 }
500 
501 static void monitor_qmp_setup_handlers_bh(void *opaque)
502 {
503     MonitorQMP *mon = opaque;
504     GMainContext *context;
505 
506     assert(mon->common.use_io_thread);
507     context = iothread_get_g_main_context(mon_iothread);
508     assert(context);
509     qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
510                              monitor_qmp_read, monitor_qmp_event,
511                              NULL, &mon->common, context, true);
512     monitor_list_append(&mon->common);
513 }
514 
515 void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp)
516 {
517     MonitorQMP *mon = g_new0(MonitorQMP, 1);
518 
519     if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
520         g_free(mon);
521         return;
522     }
523     qemu_chr_fe_set_echo(&mon->common.chr, true);
524 
525     /* Note: we run QMP monitor in I/O thread when @chr supports that */
526     monitor_data_init(&mon->common, true, false,
527                       qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
528 
529     mon->pretty = pretty;
530 
531     qemu_mutex_init(&mon->qmp_queue_lock);
532     mon->qmp_requests = g_queue_new();
533 
534     json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
535     if (mon->common.use_io_thread) {
536         /*
537          * Make sure the old iowatch is gone.  It's possible when
538          * e.g. the chardev is in client mode, with wait=on.
539          */
540         remove_fd_in_watch(chr);
541         /*
542          * We can't call qemu_chr_fe_set_handlers() directly here
543          * since chardev might be running in the monitor I/O
544          * thread.  Schedule a bottom half.
545          */
546         aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
547                                 monitor_qmp_setup_handlers_bh, mon);
548         /* The bottom half will add @mon to @mon_list */
549     } else {
550         qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
551                                  monitor_qmp_read, monitor_qmp_event,
552                                  NULL, &mon->common, NULL, true);
553         monitor_list_append(&mon->common);
554     }
555 }
556