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