1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
36struct QMPRequest {
37
38 MonitorQMP *mon;
39
40
41
42
43 QObject *req;
44 Error *err;
45};
46typedef struct QMPRequest QMPRequest;
47
48QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
49
50static bool qmp_oob_enabled(MonitorQMP *mon)
51{
52 return mon->capab[QMP_CAPABILITY_OOB];
53}
54
55static void monitor_qmp_caps_reset(MonitorQMP *mon)
56{
57 memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
58 memset(mon->capab, 0, sizeof(mon->capab));
59 mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
60}
61
62static void qmp_request_free(QMPRequest *req)
63{
64 qobject_unref(req->req);
65 error_free(req->err);
66 g_free(req);
67}
68
69
70static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
71{
72 while (!g_queue_is_empty(mon->qmp_requests)) {
73 qmp_request_free(g_queue_pop_head(mon->qmp_requests));
74 }
75}
76
77static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
78{
79 QEMU_LOCK_GUARD(&mon->qmp_queue_lock);
80
81
82
83
84
85
86
87 bool need_resume = (!qmp_oob_enabled(mon) ||
88 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
89 && !g_queue_is_empty(mon->qmp_requests);
90
91 monitor_qmp_cleanup_req_queue_locked(mon);
92
93 if (need_resume) {
94
95
96
97
98
99
100
101
102
103 monitor_resume(&mon->common);
104 }
105
106}
107
108void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
109{
110 const QObject *data = QOBJECT(rsp);
111 GString *json;
112
113 json = qobject_to_json_pretty(data, mon->pretty);
114 assert(json != NULL);
115 trace_monitor_qmp_respond(mon, json->str);
116
117 g_string_append_c(json, '\n');
118 monitor_puts(&mon->common, json->str);
119
120 g_string_free(json, true);
121}
122
123
124
125
126
127
128static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
129{
130 if (rsp) {
131 qmp_send_response(mon, rsp);
132 }
133}
134
135
136
137
138
139static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
140{
141 QDict *rsp;
142 QDict *error;
143
144 rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon),
145 &mon->common);
146
147 if (mon->commands == &qmp_cap_negotiation_commands) {
148 error = qdict_get_qdict(rsp, "error");
149 if (error
150 && !g_strcmp0(qdict_get_try_str(error, "class"),
151 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
152
153 qdict_del(error, "desc");
154 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
155 " with 'qmp_capabilities'");
156 }
157 }
158
159 monitor_qmp_respond(mon, rsp);
160 qobject_unref(rsp);
161}
162
163
164
165
166
167
168
169
170
171
172
173
174
175static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
176{
177 QMPRequest *req_obj = NULL;
178 Monitor *mon;
179 MonitorQMP *qmp_mon;
180
181 QEMU_LOCK_GUARD(&monitor_lock);
182
183 QTAILQ_FOREACH(mon, &mon_list, entry) {
184 if (!monitor_is_qmp(mon)) {
185 continue;
186 }
187
188 qmp_mon = container_of(mon, MonitorQMP, common);
189 qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
190 req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
191 if (req_obj) {
192
193 break;
194 }
195 qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
196 }
197
198 if (req_obj) {
199
200
201
202
203 QTAILQ_REMOVE(&mon_list, mon, entry);
204 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
205 }
206
207 return req_obj;
208}
209
210void coroutine_fn monitor_qmp_dispatcher_co(void *data)
211{
212 QMPRequest *req_obj = NULL;
213 QDict *rsp;
214 bool oob_enabled;
215 MonitorQMP *mon;
216
217 while (true) {
218 assert(qatomic_mb_read(&qmp_dispatcher_co_busy) == true);
219
220
221
222
223
224
225 qatomic_mb_set(&qmp_dispatcher_co_busy, false);
226
227
228 if (qmp_dispatcher_co_shutdown) {
229 return;
230 }
231
232 while (!(req_obj = monitor_qmp_requests_pop_any_with_lock())) {
233
234
235
236
237
238 if (!qmp_dispatcher_co_shutdown) {
239 qemu_coroutine_yield();
240
241
242
243
244
245 assert(qatomic_xchg(&qmp_dispatcher_co_busy, false) == true);
246 }
247
248
249
250
251
252 if (qmp_dispatcher_co_shutdown) {
253 return;
254 }
255 }
256
257 trace_monitor_qmp_in_band_dequeue(req_obj,
258 req_obj->mon->qmp_requests->length);
259
260 if (qatomic_xchg(&qmp_dispatcher_co_busy, true) == true) {
261
262
263
264
265
266
267 qemu_coroutine_yield();
268 }
269
270
271
272
273
274
275 aio_co_schedule(qemu_get_aio_context(), qmp_dispatcher_co);
276 qemu_coroutine_yield();
277
278
279
280
281
282 mon = req_obj->mon;
283
284
285
286
287
288
289
290
291
292
293
294
295 oob_enabled = qmp_oob_enabled(mon);
296 if (oob_enabled
297 && mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
298 monitor_resume(&mon->common);
299 }
300
301 qemu_mutex_unlock(&mon->qmp_queue_lock);
302
303
304 if (req_obj->req) {
305 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_IN_BAND)) {
306 QDict *qdict = qobject_to(QDict, req_obj->req);
307 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
308 GString *id_json;
309
310 id_json = id ? qobject_to_json(id) : g_string_new(NULL);
311 trace_monitor_qmp_cmd_in_band(id_json->str);
312 g_string_free(id_json, true);
313 }
314 monitor_qmp_dispatch(mon, req_obj->req);
315 } else {
316 assert(req_obj->err);
317 trace_monitor_qmp_err_in_band(error_get_pretty(req_obj->err));
318 rsp = qmp_error_response(req_obj->err);
319 req_obj->err = NULL;
320 monitor_qmp_respond(mon, rsp);
321 qobject_unref(rsp);
322 }
323
324 if (!oob_enabled) {
325 monitor_resume(&mon->common);
326 }
327
328 qmp_request_free(req_obj);
329
330
331
332
333
334
335
336 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co);
337 qemu_coroutine_yield();
338 }
339}
340
341static void handle_qmp_command(void *opaque, QObject *req, Error *err)
342{
343 MonitorQMP *mon = opaque;
344 QDict *qdict = qobject_to(QDict, req);
345 QMPRequest *req_obj;
346
347 assert(!req != !err);
348
349 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
350 GString *req_json = qobject_to_json(req);
351 trace_handle_qmp_command(mon, req_json->str);
352 g_string_free(req_json, true);
353 }
354
355 if (qdict && qmp_is_oob(qdict)) {
356
357 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_OUT_OF_BAND)) {
358 QObject *id = qdict_get(qdict, "id");
359 GString *id_json;
360
361 id_json = id ? qobject_to_json(id) : g_string_new(NULL);
362 trace_monitor_qmp_cmd_out_of_band(id_json->str);
363 g_string_free(id_json, true);
364 }
365 monitor_qmp_dispatch(mon, req);
366 qobject_unref(req);
367 return;
368 }
369
370 req_obj = g_new0(QMPRequest, 1);
371 req_obj->mon = mon;
372 req_obj->req = req;
373 req_obj->err = err;
374
375
376 WITH_QEMU_LOCK_GUARD(&mon->qmp_queue_lock) {
377
378
379
380
381
382
383
384
385 if (!qmp_oob_enabled(mon) ||
386 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
387 monitor_suspend(&mon->common);
388 }
389
390
391
392
393
394
395 trace_monitor_qmp_in_band_enqueue(req_obj, mon,
396 mon->qmp_requests->length);
397 assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
398 g_queue_push_tail(mon->qmp_requests, req_obj);
399 }
400
401
402 if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) {
403 aio_co_wake(qmp_dispatcher_co);
404 }
405}
406
407static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
408{
409 MonitorQMP *mon = opaque;
410
411 json_message_parser_feed(&mon->parser, (const char *) buf, size);
412}
413
414static QDict *qmp_greeting(MonitorQMP *mon)
415{
416 QList *cap_list = qlist_new();
417 QObject *ver = NULL;
418 QDict *args;
419 QMPCapability cap;
420
421 args = qdict_new();
422 qmp_marshal_query_version(args, &ver, NULL);
423 qobject_unref(args);
424
425 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
426 if (mon->capab_offered[cap]) {
427 qlist_append_str(cap_list, QMPCapability_str(cap));
428 }
429 }
430
431 return qdict_from_jsonf_nofail(
432 "{'QMP': {'version': %p, 'capabilities': %p}}",
433 ver, cap_list);
434}
435
436static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
437{
438 QDict *data;
439 MonitorQMP *mon = opaque;
440
441 switch (event) {
442 case CHR_EVENT_OPENED:
443 mon->commands = &qmp_cap_negotiation_commands;
444 monitor_qmp_caps_reset(mon);
445 data = qmp_greeting(mon);
446 qmp_send_response(mon, data);
447 qobject_unref(data);
448 mon_refcount++;
449 break;
450 case CHR_EVENT_CLOSED:
451
452
453
454
455
456
457 monitor_qmp_cleanup_queue_and_resume(mon);
458 json_message_parser_destroy(&mon->parser);
459 json_message_parser_init(&mon->parser, handle_qmp_command,
460 mon, NULL);
461 mon_refcount--;
462 monitor_fdsets_cleanup();
463 break;
464 case CHR_EVENT_BREAK:
465 case CHR_EVENT_MUX_IN:
466 case CHR_EVENT_MUX_OUT:
467
468 break;
469 }
470}
471
472void monitor_data_destroy_qmp(MonitorQMP *mon)
473{
474 json_message_parser_destroy(&mon->parser);
475 qemu_mutex_destroy(&mon->qmp_queue_lock);
476 monitor_qmp_cleanup_req_queue_locked(mon);
477 g_queue_free(mon->qmp_requests);
478}
479
480static void monitor_qmp_setup_handlers_bh(void *opaque)
481{
482 MonitorQMP *mon = opaque;
483 GMainContext *context;
484
485 assert(mon->common.use_io_thread);
486 context = iothread_get_g_main_context(mon_iothread);
487 assert(context);
488 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
489 monitor_qmp_read, monitor_qmp_event,
490 NULL, &mon->common, context, true);
491 monitor_list_append(&mon->common);
492}
493
494void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp)
495{
496 MonitorQMP *mon = g_new0(MonitorQMP, 1);
497
498 if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
499 g_free(mon);
500 return;
501 }
502 qemu_chr_fe_set_echo(&mon->common.chr, true);
503
504
505 monitor_data_init(&mon->common, true, false,
506 qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
507
508 mon->pretty = pretty;
509
510 qemu_mutex_init(&mon->qmp_queue_lock);
511 mon->qmp_requests = g_queue_new();
512
513 json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
514 if (mon->common.use_io_thread) {
515
516
517
518
519 remove_fd_in_watch(chr);
520
521
522
523
524
525 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
526 monitor_qmp_setup_handlers_bh, mon);
527
528 } else {
529 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
530 monitor_qmp_read, monitor_qmp_event,
531 NULL, &mon->common, NULL, true);
532 monitor_list_append(&mon->common);
533 }
534}
535