]>
Commit | Line | Data |
---|---|---|
7e3c0dea KW |
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" | |
fa4dcf57 | 30 | #include "qapi/qapi-commands-control.h" |
7e3c0dea KW |
31 | #include "qapi/qmp/qdict.h" |
32 | #include "qapi/qmp/qjson.h" | |
33 | #include "qapi/qmp/qlist.h" | |
7e3c0dea KW |
34 | #include "trace.h" |
35 | ||
9f2d5854 PB |
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 | * | |
eea7cd3f PB |
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. | |
9f2d5854 | 48 | * |
eea7cd3f PB |
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. | |
9f2d5854 PB |
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 | ||
7e3c0dea KW |
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 | ||
2895aaa1 | 101 | static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon) |
7e3c0dea | 102 | { |
a8e2ab5d | 103 | QEMU_LOCK_GUARD(&mon->qmp_queue_lock); |
2895aaa1 WB |
104 | |
105 | /* | |
395a9508 | 106 | * Same condition as in monitor_qmp_dispatcher_co(), but before |
2895aaa1 WB |
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 | ||
7e3c0dea | 115 | monitor_qmp_cleanup_req_queue_locked(mon); |
2895aaa1 WB |
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 | ||
7e3c0dea KW |
130 | } |
131 | ||
132 | void qmp_send_response(MonitorQMP *mon, const QDict *rsp) | |
133 | { | |
134 | const QObject *data = QOBJECT(rsp); | |
eab3a467 | 135 | GString *json; |
7e3c0dea | 136 | |
6589f459 | 137 | json = qobject_to_json_pretty(data, mon->pretty); |
7e3c0dea | 138 | assert(json != NULL); |
f680405f | 139 | trace_monitor_qmp_respond(mon, json->str); |
7e3c0dea | 140 | |
eab3a467 MA |
141 | g_string_append_c(json, '\n'); |
142 | monitor_puts(&mon->common, json->str); | |
7e3c0dea | 143 | |
eab3a467 | 144 | g_string_free(json, true); |
7e3c0dea KW |
145 | } |
146 | ||
147 | /* | |
eb707eac | 148 | * Emit QMP response @rsp to @mon. |
7e3c0dea KW |
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 | ||
9ce44e2c KW |
159 | /* |
160 | * Runs outside of coroutine context for OOB commands, but in | |
161 | * coroutine context for everything else. | |
162 | */ | |
7e3c0dea KW |
163 | static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req) |
164 | { | |
7e3c0dea KW |
165 | QDict *rsp; |
166 | QDict *error; | |
167 | ||
41725fa7 KW |
168 | rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon), |
169 | &mon->common); | |
7e3c0dea KW |
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 | ||
7e3c0dea KW |
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 | ||
7e3c0dea KW |
229 | return req_obj; |
230 | } | |
231 | ||
60f4f62e | 232 | static QMPRequest *monitor_qmp_dispatcher_pop_any(void) |
7e3c0dea | 233 | { |
9ce44e2c | 234 | while (true) { |
0ff25537 | 235 | /* |
eea7cd3f PB |
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. | |
0ff25537 | 239 | */ |
eea7cd3f | 240 | assert(qatomic_read(&qmp_dispatcher_co_busy) == true); |
7e3c0dea | 241 | |
9ce44e2c KW |
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. | |
eea7cd3f PB |
246 | * |
247 | * Clear qmp_dispatcher_co_busy before reading request. | |
9ce44e2c | 248 | */ |
06831001 | 249 | qatomic_set_mb(&qmp_dispatcher_co_busy, false); |
9ce44e2c | 250 | |
0ff25537 | 251 | WITH_QEMU_LOCK_GUARD(&monitor_lock) { |
60f4f62e PB |
252 | QMPRequest *req_obj; |
253 | ||
0ff25537 PB |
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(); | |
60f4f62e PB |
260 | if (req_obj) { |
261 | return req_obj; | |
262 | } | |
b248e616 KW |
263 | } |
264 | ||
60f4f62e PB |
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; | |
7e3c0dea | 280 | |
60f4f62e | 281 | while ((req_obj = monitor_qmp_dispatcher_pop_any()) != NULL) { |
f680405f MA |
282 | trace_monitor_qmp_in_band_dequeue(req_obj, |
283 | req_obj->mon->qmp_requests->length); | |
284 | ||
88daf099 MA |
285 | /* |
286 | * @req_obj has a request, we hold req_obj->mon->qmp_queue_lock | |
287 | */ | |
288 | ||
9ce44e2c | 289 | mon = req_obj->mon; |
88daf099 MA |
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 | ||
a67b996e SR |
308 | /* |
309 | * Drop the queue mutex now, before yielding, otherwise we might | |
310 | * deadlock if the main thread tries to lock it. | |
311 | */ | |
9ce44e2c | 312 | qemu_mutex_unlock(&mon->qmp_queue_lock); |
88daf099 | 313 | |
a67b996e SR |
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 | /* | |
325 | * Move the coroutine from iohandler_ctx to qemu_aio_context for | |
326 | * executing the command handler so that it can make progress if it | |
327 | * involves an AIO_WAIT_WHILE(). | |
328 | */ | |
329 | aio_co_schedule(qemu_get_aio_context(), qmp_dispatcher_co); | |
330 | qemu_coroutine_yield(); | |
331 | ||
88daf099 | 332 | /* Process request */ |
9ce44e2c | 333 | if (req_obj->req) { |
d403d92d MA |
334 | if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_IN_BAND)) { |
335 | QDict *qdict = qobject_to(QDict, req_obj->req); | |
336 | QObject *id = qdict ? qdict_get(qdict, "id") : NULL; | |
337 | GString *id_json; | |
338 | ||
339 | id_json = id ? qobject_to_json(id) : g_string_new(NULL); | |
340 | trace_monitor_qmp_cmd_in_band(id_json->str); | |
341 | g_string_free(id_json, true); | |
342 | } | |
9ce44e2c KW |
343 | monitor_qmp_dispatch(mon, req_obj->req); |
344 | } else { | |
345 | assert(req_obj->err); | |
f680405f | 346 | trace_monitor_qmp_err_in_band(error_get_pretty(req_obj->err)); |
9ce44e2c KW |
347 | rsp = qmp_error_response(req_obj->err); |
348 | req_obj->err = NULL; | |
349 | monitor_qmp_respond(mon, rsp); | |
350 | qobject_unref(rsp); | |
351 | } | |
352 | ||
88daf099 | 353 | if (!oob_enabled) { |
9ce44e2c KW |
354 | monitor_resume(&mon->common); |
355 | } | |
88daf099 | 356 | |
9ce44e2c | 357 | qmp_request_free(req_obj); |
7e3c0dea | 358 | |
9ce44e2c KW |
359 | /* |
360 | * Yield and reschedule so the main loop stays responsive. | |
361 | * | |
362 | * Move back to iohandler_ctx so that nested event loops for | |
363 | * qemu_aio_context don't start new monitor commands. | |
364 | */ | |
365 | aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co); | |
366 | qemu_coroutine_yield(); | |
367 | } | |
0ff25537 | 368 | qatomic_set(&qmp_dispatcher_co, NULL); |
7e3c0dea KW |
369 | } |
370 | ||
9f2d5854 PB |
371 | void qmp_dispatcher_co_wake(void) |
372 | { | |
eea7cd3f PB |
373 | /* Write request before reading qmp_dispatcher_co_busy. */ |
374 | smp_mb__before_rmw(); | |
375 | ||
9f2d5854 PB |
376 | if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) { |
377 | aio_co_wake(qmp_dispatcher_co); | |
378 | } | |
379 | } | |
380 | ||
7e3c0dea KW |
381 | static void handle_qmp_command(void *opaque, QObject *req, Error *err) |
382 | { | |
383 | MonitorQMP *mon = opaque; | |
d403d92d | 384 | QDict *qdict = qobject_to(QDict, req); |
7e3c0dea KW |
385 | QMPRequest *req_obj; |
386 | ||
387 | assert(!req != !err); | |
388 | ||
7e3c0dea | 389 | if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) { |
eab3a467 MA |
390 | GString *req_json = qobject_to_json(req); |
391 | trace_handle_qmp_command(mon, req_json->str); | |
392 | g_string_free(req_json, true); | |
7e3c0dea KW |
393 | } |
394 | ||
395 | if (qdict && qmp_is_oob(qdict)) { | |
396 | /* OOB commands are executed immediately */ | |
d403d92d MA |
397 | if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_OUT_OF_BAND)) { |
398 | QObject *id = qdict_get(qdict, "id"); | |
399 | GString *id_json; | |
400 | ||
401 | id_json = id ? qobject_to_json(id) : g_string_new(NULL); | |
402 | trace_monitor_qmp_cmd_out_of_band(id_json->str); | |
403 | g_string_free(id_json, true); | |
404 | } | |
7e3c0dea KW |
405 | monitor_qmp_dispatch(mon, req); |
406 | qobject_unref(req); | |
407 | return; | |
408 | } | |
409 | ||
410 | req_obj = g_new0(QMPRequest, 1); | |
411 | req_obj->mon = mon; | |
412 | req_obj->req = req; | |
413 | req_obj->err = err; | |
414 | ||
415 | /* Protect qmp_requests and fetching its length. */ | |
a8e2ab5d | 416 | WITH_QEMU_LOCK_GUARD(&mon->qmp_queue_lock) { |
7e3c0dea | 417 | |
a8e2ab5d MM |
418 | /* |
419 | * Suspend the monitor when we can't queue more requests after | |
420 | * this one. Dequeuing in monitor_qmp_dispatcher_co() or | |
421 | * monitor_qmp_cleanup_queue_and_resume() will resume it. | |
422 | * Note that when OOB is disabled, we queue at most one command, | |
423 | * for backward compatibility. | |
424 | */ | |
425 | if (!qmp_oob_enabled(mon) || | |
426 | mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) { | |
427 | monitor_suspend(&mon->common); | |
428 | } | |
7e3c0dea | 429 | |
a8e2ab5d MM |
430 | /* |
431 | * Put the request to the end of queue so that requests will be | |
432 | * handled in time order. Ownership for req_obj, req, | |
433 | * etc. will be delivered to the handler side. | |
434 | */ | |
435 | trace_monitor_qmp_in_band_enqueue(req_obj, mon, | |
436 | mon->qmp_requests->length); | |
437 | assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX); | |
438 | g_queue_push_tail(mon->qmp_requests, req_obj); | |
439 | } | |
7e3c0dea KW |
440 | |
441 | /* Kick the dispatcher routine */ | |
9f2d5854 | 442 | qmp_dispatcher_co_wake(); |
7e3c0dea KW |
443 | } |
444 | ||
445 | static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size) | |
446 | { | |
447 | MonitorQMP *mon = opaque; | |
448 | ||
449 | json_message_parser_feed(&mon->parser, (const char *) buf, size); | |
450 | } | |
451 | ||
452 | static QDict *qmp_greeting(MonitorQMP *mon) | |
453 | { | |
454 | QList *cap_list = qlist_new(); | |
455 | QObject *ver = NULL; | |
2061487b | 456 | QDict *args; |
7e3c0dea KW |
457 | QMPCapability cap; |
458 | ||
2061487b MA |
459 | args = qdict_new(); |
460 | qmp_marshal_query_version(args, &ver, NULL); | |
461 | qobject_unref(args); | |
7e3c0dea KW |
462 | |
463 | for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) { | |
464 | if (mon->capab_offered[cap]) { | |
465 | qlist_append_str(cap_list, QMPCapability_str(cap)); | |
466 | } | |
467 | } | |
468 | ||
469 | return qdict_from_jsonf_nofail( | |
470 | "{'QMP': {'version': %p, 'capabilities': %p}}", | |
471 | ver, cap_list); | |
472 | } | |
473 | ||
083b266f | 474 | static void monitor_qmp_event(void *opaque, QEMUChrEvent event) |
7e3c0dea KW |
475 | { |
476 | QDict *data; | |
477 | MonitorQMP *mon = opaque; | |
478 | ||
479 | switch (event) { | |
480 | case CHR_EVENT_OPENED: | |
481 | mon->commands = &qmp_cap_negotiation_commands; | |
482 | monitor_qmp_caps_reset(mon); | |
483 | data = qmp_greeting(mon); | |
484 | qmp_send_response(mon, data); | |
485 | qobject_unref(data); | |
486 | mon_refcount++; | |
487 | break; | |
488 | case CHR_EVENT_CLOSED: | |
489 | /* | |
490 | * Note: this is only useful when the output of the chardev | |
491 | * backend is still open. For example, when the backend is | |
492 | * stdio, it's possible that stdout is still open when stdin | |
493 | * is closed. | |
494 | */ | |
2895aaa1 | 495 | monitor_qmp_cleanup_queue_and_resume(mon); |
7e3c0dea KW |
496 | json_message_parser_destroy(&mon->parser); |
497 | json_message_parser_init(&mon->parser, handle_qmp_command, | |
498 | mon, NULL); | |
499 | mon_refcount--; | |
500 | monitor_fdsets_cleanup(); | |
501 | break; | |
ed7c5bb7 PMD |
502 | case CHR_EVENT_BREAK: |
503 | case CHR_EVENT_MUX_IN: | |
504 | case CHR_EVENT_MUX_OUT: | |
505 | /* Ignore */ | |
506 | break; | |
7e3c0dea KW |
507 | } |
508 | } | |
509 | ||
510 | void monitor_data_destroy_qmp(MonitorQMP *mon) | |
511 | { | |
512 | json_message_parser_destroy(&mon->parser); | |
513 | qemu_mutex_destroy(&mon->qmp_queue_lock); | |
514 | monitor_qmp_cleanup_req_queue_locked(mon); | |
515 | g_queue_free(mon->qmp_requests); | |
516 | } | |
517 | ||
518 | static void monitor_qmp_setup_handlers_bh(void *opaque) | |
519 | { | |
520 | MonitorQMP *mon = opaque; | |
521 | GMainContext *context; | |
522 | ||
523 | assert(mon->common.use_io_thread); | |
524 | context = iothread_get_g_main_context(mon_iothread); | |
525 | assert(context); | |
526 | qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, | |
527 | monitor_qmp_read, monitor_qmp_event, | |
528 | NULL, &mon->common, context, true); | |
529 | monitor_list_append(&mon->common); | |
530 | } | |
531 | ||
f27a9bb3 | 532 | void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp) |
7e3c0dea KW |
533 | { |
534 | MonitorQMP *mon = g_new0(MonitorQMP, 1); | |
535 | ||
f27a9bb3 KW |
536 | if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) { |
537 | g_free(mon); | |
538 | return; | |
539 | } | |
540 | qemu_chr_fe_set_echo(&mon->common.chr, true); | |
541 | ||
7e3c0dea | 542 | /* Note: we run QMP monitor in I/O thread when @chr supports that */ |
92082416 | 543 | monitor_data_init(&mon->common, true, false, |
7e3c0dea KW |
544 | qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT)); |
545 | ||
fbfc29e3 | 546 | mon->pretty = pretty; |
92082416 | 547 | |
7e3c0dea KW |
548 | qemu_mutex_init(&mon->qmp_queue_lock); |
549 | mon->qmp_requests = g_queue_new(); | |
550 | ||
7e3c0dea KW |
551 | json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL); |
552 | if (mon->common.use_io_thread) { | |
553 | /* | |
554 | * Make sure the old iowatch is gone. It's possible when | |
555 | * e.g. the chardev is in client mode, with wait=on. | |
556 | */ | |
557 | remove_fd_in_watch(chr); | |
558 | /* | |
559 | * We can't call qemu_chr_fe_set_handlers() directly here | |
560 | * since chardev might be running in the monitor I/O | |
561 | * thread. Schedule a bottom half. | |
562 | */ | |
563 | aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread), | |
564 | monitor_qmp_setup_handlers_bh, mon); | |
565 | /* The bottom half will add @mon to @mon_list */ | |
566 | } else { | |
567 | qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read, | |
568 | monitor_qmp_read, monitor_qmp_event, | |
569 | NULL, &mon->common, NULL, true); | |
570 | monitor_list_append(&mon->common); | |
571 | } | |
572 | } |