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-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
37struct QMPRequest {
38
39 MonitorQMP *mon;
40
41
42
43
44 QObject *req;
45 Error *err;
46};
47typedef struct QMPRequest QMPRequest;
48
49QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
50
51static bool qmp_oob_enabled(MonitorQMP *mon)
52{
53 return mon->capab[QMP_CAPABILITY_OOB];
54}
55
56static 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
63static void qmp_request_free(QMPRequest *req)
64{
65 qobject_unref(req->req);
66 error_free(req->err);
67 g_free(req);
68}
69
70
71static 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
78static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
79{
80 qemu_mutex_lock(&mon->qmp_queue_lock);
81
82
83
84
85
86
87
88 bool need_resume = (!qmp_oob_enabled(mon) ||
89 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
90 && !g_queue_is_empty(mon->qmp_requests);
91
92 monitor_qmp_cleanup_req_queue_locked(mon);
93
94 if (need_resume) {
95
96
97
98
99
100
101
102
103
104 monitor_resume(&mon->common);
105 }
106
107 qemu_mutex_unlock(&mon->qmp_queue_lock);
108}
109
110void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
111{
112 const QObject *data = QOBJECT(rsp);
113 QString *json;
114
115 json = mon->pretty ? qobject_to_json_pretty(data) : qobject_to_json(data);
116 assert(json != NULL);
117
118 qstring_append_chr(json, '\n');
119 monitor_puts(&mon->common, qstring_get_str(json));
120
121 qobject_unref(json);
122}
123
124
125
126
127
128
129static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
130{
131 if (rsp) {
132 qmp_send_response(mon, rsp);
133 }
134}
135
136static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
137{
138 Monitor *old_mon;
139 QDict *rsp;
140 QDict *error;
141
142 old_mon = cur_mon;
143 cur_mon = &mon->common;
144
145 rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
146
147 cur_mon = old_mon;
148
149 if (mon->commands == &qmp_cap_negotiation_commands) {
150 error = qdict_get_qdict(rsp, "error");
151 if (error
152 && !g_strcmp0(qdict_get_try_str(error, "class"),
153 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
154
155 qdict_del(error, "desc");
156 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
157 " with 'qmp_capabilities'");
158 }
159 }
160
161 monitor_qmp_respond(mon, rsp);
162 qobject_unref(rsp);
163}
164
165
166
167
168
169
170
171
172
173
174
175
176
177static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
178{
179 QMPRequest *req_obj = NULL;
180 Monitor *mon;
181 MonitorQMP *qmp_mon;
182
183 qemu_mutex_lock(&monitor_lock);
184
185 QTAILQ_FOREACH(mon, &mon_list, entry) {
186 if (!monitor_is_qmp(mon)) {
187 continue;
188 }
189
190 qmp_mon = container_of(mon, MonitorQMP, common);
191 qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
192 req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
193 if (req_obj) {
194
195 break;
196 }
197 qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
198 }
199
200 if (req_obj) {
201
202
203
204
205 QTAILQ_REMOVE(&mon_list, mon, entry);
206 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
207 }
208
209 qemu_mutex_unlock(&monitor_lock);
210
211 return req_obj;
212}
213
214void monitor_qmp_bh_dispatcher(void *data)
215{
216 QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
217 QDict *rsp;
218 bool need_resume;
219 MonitorQMP *mon;
220
221 if (!req_obj) {
222 return;
223 }
224
225 mon = req_obj->mon;
226
227 need_resume = !qmp_oob_enabled(mon) ||
228 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
229 qemu_mutex_unlock(&mon->qmp_queue_lock);
230 if (req_obj->req) {
231 QDict *qdict = qobject_to(QDict, req_obj->req);
232 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
233 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
234 monitor_qmp_dispatch(mon, req_obj->req);
235 } else {
236 assert(req_obj->err);
237 rsp = qmp_error_response(req_obj->err);
238 req_obj->err = NULL;
239 monitor_qmp_respond(mon, rsp);
240 qobject_unref(rsp);
241 }
242
243 if (need_resume) {
244
245 monitor_resume(&mon->common);
246 }
247 qmp_request_free(req_obj);
248
249
250 qemu_bh_schedule(qmp_dispatcher_bh);
251}
252
253static void handle_qmp_command(void *opaque, QObject *req, Error *err)
254{
255 MonitorQMP *mon = opaque;
256 QObject *id = NULL;
257 QDict *qdict;
258 QMPRequest *req_obj;
259
260 assert(!req != !err);
261
262 qdict = qobject_to(QDict, req);
263 if (qdict) {
264 id = qdict_get(qdict, "id");
265 }
266
267 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
268 QString *req_json = qobject_to_json(req);
269 trace_handle_qmp_command(mon, qstring_get_str(req_json));
270 qobject_unref(req_json);
271 }
272
273 if (qdict && qmp_is_oob(qdict)) {
274
275 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
276 monitor_qmp_dispatch(mon, req);
277 qobject_unref(req);
278 return;
279 }
280
281 req_obj = g_new0(QMPRequest, 1);
282 req_obj->mon = mon;
283 req_obj->req = req;
284 req_obj->err = err;
285
286
287 qemu_mutex_lock(&mon->qmp_queue_lock);
288
289
290
291
292
293
294
295
296 if (!qmp_oob_enabled(mon) ||
297 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
298 monitor_suspend(&mon->common);
299 }
300
301
302
303
304
305
306 assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
307 g_queue_push_tail(mon->qmp_requests, req_obj);
308 qemu_mutex_unlock(&mon->qmp_queue_lock);
309
310
311 qemu_bh_schedule(qmp_dispatcher_bh);
312}
313
314static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
315{
316 MonitorQMP *mon = opaque;
317
318 json_message_parser_feed(&mon->parser, (const char *) buf, size);
319}
320
321static QDict *qmp_greeting(MonitorQMP *mon)
322{
323 QList *cap_list = qlist_new();
324 QObject *ver = NULL;
325 QMPCapability cap;
326
327 qmp_marshal_query_version(NULL, &ver, NULL);
328
329 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
330 if (mon->capab_offered[cap]) {
331 qlist_append_str(cap_list, QMPCapability_str(cap));
332 }
333 }
334
335 return qdict_from_jsonf_nofail(
336 "{'QMP': {'version': %p, 'capabilities': %p}}",
337 ver, cap_list);
338}
339
340static void monitor_qmp_event(void *opaque, int event)
341{
342 QDict *data;
343 MonitorQMP *mon = opaque;
344
345 switch (event) {
346 case CHR_EVENT_OPENED:
347 mon->commands = &qmp_cap_negotiation_commands;
348 monitor_qmp_caps_reset(mon);
349 data = qmp_greeting(mon);
350 qmp_send_response(mon, data);
351 qobject_unref(data);
352 mon_refcount++;
353 break;
354 case CHR_EVENT_CLOSED:
355
356
357
358
359
360
361 monitor_qmp_cleanup_queue_and_resume(mon);
362 json_message_parser_destroy(&mon->parser);
363 json_message_parser_init(&mon->parser, handle_qmp_command,
364 mon, NULL);
365 mon_refcount--;
366 monitor_fdsets_cleanup();
367 break;
368 }
369}
370
371void monitor_data_destroy_qmp(MonitorQMP *mon)
372{
373 json_message_parser_destroy(&mon->parser);
374 qemu_mutex_destroy(&mon->qmp_queue_lock);
375 monitor_qmp_cleanup_req_queue_locked(mon);
376 g_queue_free(mon->qmp_requests);
377}
378
379static void monitor_qmp_setup_handlers_bh(void *opaque)
380{
381 MonitorQMP *mon = opaque;
382 GMainContext *context;
383
384 assert(mon->common.use_io_thread);
385 context = iothread_get_g_main_context(mon_iothread);
386 assert(context);
387 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
388 monitor_qmp_read, monitor_qmp_event,
389 NULL, &mon->common, context, true);
390 monitor_list_append(&mon->common);
391}
392
393void monitor_init_qmp(Chardev *chr, bool pretty)
394{
395 MonitorQMP *mon = g_new0(MonitorQMP, 1);
396
397
398 monitor_data_init(&mon->common, true, false,
399 qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
400
401 mon->pretty = pretty;
402
403 qemu_mutex_init(&mon->qmp_queue_lock);
404 mon->qmp_requests = g_queue_new();
405
406 qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
407 qemu_chr_fe_set_echo(&mon->common.chr, true);
408
409 json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
410 if (mon->common.use_io_thread) {
411
412
413
414
415 remove_fd_in_watch(chr);
416
417
418
419
420
421 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
422 monitor_qmp_setup_handlers_bh, mon);
423
424 } else {
425 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
426 monitor_qmp_read, monitor_qmp_event,
427 NULL, &mon->common, NULL, true);
428 monitor_list_append(&mon->common);
429 }
430}
431