monitor/qmp.c

   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-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
  37 struct QMPRequest {
  38     /* Owner of the request */
  39     MonitorQMP *mon;
  40     /*
  41      * Request object to be handled or Error to be reported
  42      * (exactly one of them is non-null)
  43      */
  44     QObject *req;
  45     Error *err;
  46 };
  47 typedef struct QMPRequest QMPRequest;
  48
  49 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
  50
  51 static bool qmp_oob_enabled(MonitorQMP *mon)
  52 {
  53     return mon->capab[QMP_CAPABILITY_OOB];
  54 }
  55
  56 static 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
  63 static void qmp_request_free(QMPRequest *req)
  64 {
  65     qobject_unref(req->req);
  66     error_free(req->err);
  67     g_free(req);
  68 }
  69
  70 /* Caller must hold mon->qmp.qmp_queue_lock */
  71 static 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
  78 static void monitor_qmp_cleanup_queues(MonitorQMP *mon)
  79 {
  80     qemu_mutex_lock(&mon->qmp_queue_lock);
  81     monitor_qmp_cleanup_req_queue_locked(mon);
  82     qemu_mutex_unlock(&mon->qmp_queue_lock);
  83 }
  84
  85 void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
  86 {
  87     const QObject *data = QOBJECT(rsp);
  88     QString *json;
  89
  90     json = mon->pretty ? qobject_to_json_pretty(data) : qobject_to_json(data);
  91     assert(json != NULL);
  92
  93     qstring_append_chr(json, '\n');
  94     monitor_puts(&mon->common, qstring_get_str(json));
  95
  96     qobject_unref(json);
  97 }
  98
  99 /*
 100  * Emit QMP response @rsp with ID @id to @mon.
 101  * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
 102  * Nothing is emitted then.
 103  */
 104 static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
 105 {
 106     if (rsp) {
 107         qmp_send_response(mon, rsp);
 108     }
 109 }
 110
 111 static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
 112 {
 113     Monitor *old_mon;
 114     QDict *rsp;
 115     QDict *error;
 116
 117     old_mon = cur_mon;
 118     cur_mon = &mon->common;
 119
 120     rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon));
 121
 122     cur_mon = old_mon;
 123
 124     if (mon->commands == &qmp_cap_negotiation_commands) {
 125         error = qdict_get_qdict(rsp, "error");
 126         if (error
 127             && !g_strcmp0(qdict_get_try_str(error, "class"),
 128                     QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
 129             /* Provide a more useful error message */
 130             qdict_del(error, "desc");
 131             qdict_put_str(error, "desc", "Expecting capabilities negotiation"
 132                           " with 'qmp_capabilities'");
 133         }
 134     }
 135
 136     monitor_qmp_respond(mon, rsp);
 137     qobject_unref(rsp);
 138 }
 139
 140 /*
 141  * Pop a QMP request from a monitor request queue.
 142  * Return the request, or NULL all request queues are empty.
 143  * We are using round-robin fashion to pop the request, to avoid
 144  * processing commands only on a very busy monitor.  To achieve that,
 145  * when we process one request on a specific monitor, we put that
 146  * monitor to the end of mon_list queue.
 147  *
 148  * Note: if the function returned with non-NULL, then the caller will
 149  * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
 150  * to release it.
 151  */
 152 static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
 153 {
 154     QMPRequest *req_obj = NULL;
 155     Monitor *mon;
 156     MonitorQMP *qmp_mon;
 157
 158     qemu_mutex_lock(&monitor_lock);
 159
 160     QTAILQ_FOREACH(mon, &mon_list, entry) {
 161         if (!monitor_is_qmp(mon)) {
 162             continue;
 163         }
 164
 165         qmp_mon = container_of(mon, MonitorQMP, common);
 166         qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
 167         req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
 168         if (req_obj) {
 169             /* With the lock of corresponding queue held */
 170             break;
 171         }
 172         qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
 173     }
 174
 175     if (req_obj) {
 176         /*
 177          * We found one request on the monitor. Degrade this monitor's
 178          * priority to lowest by re-inserting it to end of queue.
 179          */
 180         QTAILQ_REMOVE(&mon_list, mon, entry);
 181         QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
 182     }
 183
 184     qemu_mutex_unlock(&monitor_lock);
 185
 186     return req_obj;
 187 }
 188
 189 void monitor_qmp_bh_dispatcher(void *data)
 190 {
 191     QMPRequest *req_obj = monitor_qmp_requests_pop_any_with_lock();
 192     QDict *rsp;
 193     bool need_resume;
 194     MonitorQMP *mon;
 195
 196     if (!req_obj) {
 197         return;
 198     }
 199
 200     mon = req_obj->mon;
 201     /*  qmp_oob_enabled() might change after "qmp_capabilities" */
 202     need_resume = !qmp_oob_enabled(mon) ||
 203         mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
 204     qemu_mutex_unlock(&mon->qmp_queue_lock);
 205     if (req_obj->req) {
 206         QDict *qdict = qobject_to(QDict, req_obj->req);
 207         QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
 208         trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
 209         monitor_qmp_dispatch(mon, req_obj->req);
 210     } else {
 211         assert(req_obj->err);
 212         rsp = qmp_error_response(req_obj->err);
 213         req_obj->err = NULL;
 214         monitor_qmp_respond(mon, rsp);
 215         qobject_unref(rsp);
 216     }
 217
 218     if (need_resume) {
 219         /* Pairs with the monitor_suspend() in handle_qmp_command() */
 220         monitor_resume(&mon->common);
 221     }
 222     qmp_request_free(req_obj);
 223
 224     /* Reschedule instead of looping so the main loop stays responsive */
 225     qemu_bh_schedule(qmp_dispatcher_bh);
 226 }
 227
 228 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
 229 {
 230     MonitorQMP *mon = opaque;
 231     QObject *id = NULL;
 232     QDict *qdict;
 233     QMPRequest *req_obj;
 234
 235     assert(!req != !err);
 236
 237     qdict = qobject_to(QDict, req);
 238     if (qdict) {
 239         id = qdict_get(qdict, "id");
 240     } /* else will fail qmp_dispatch() */
 241
 242     if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
 243         QString *req_json = qobject_to_json(req);
 244         trace_handle_qmp_command(mon, qstring_get_str(req_json));
 245         qobject_unref(req_json);
 246     }
 247
 248     if (qdict && qmp_is_oob(qdict)) {
 249         /* OOB commands are executed immediately */
 250         trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
 251         monitor_qmp_dispatch(mon, req);
 252         qobject_unref(req);
 253         return;
 254     }
 255
 256     req_obj = g_new0(QMPRequest, 1);
 257     req_obj->mon = mon;
 258     req_obj->req = req;
 259     req_obj->err = err;
 260
 261     /* Protect qmp_requests and fetching its length. */
 262     qemu_mutex_lock(&mon->qmp_queue_lock);
 263
 264     /*
 265      * Suspend the monitor when we can't queue more requests after
 266      * this one.  Dequeuing in monitor_qmp_bh_dispatcher() will resume
 267      * it.  Note that when OOB is disabled, we queue at most one
 268      * command, for backward compatibility.
 269      */
 270     if (!qmp_oob_enabled(mon) ||
 271         mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
 272         monitor_suspend(&mon->common);
 273     }
 274
 275     /*
 276      * Put the request to the end of queue so that requests will be
 277      * handled in time order.  Ownership for req_obj, req,
 278      * etc. will be delivered to the handler side.
 279      */
 280     assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
 281     g_queue_push_tail(mon->qmp_requests, req_obj);
 282     qemu_mutex_unlock(&mon->qmp_queue_lock);
 283
 284     /* Kick the dispatcher routine */
 285     qemu_bh_schedule(qmp_dispatcher_bh);
 286 }
 287
 288 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
 289 {
 290     MonitorQMP *mon = opaque;
 291
 292     json_message_parser_feed(&mon->parser, (const char *) buf, size);
 293 }
 294
 295 static QDict *qmp_greeting(MonitorQMP *mon)
 296 {
 297     QList *cap_list = qlist_new();
 298     QObject *ver = NULL;
 299     QMPCapability cap;
 300
 301     qmp_marshal_query_version(NULL, &ver, NULL);
 302
 303     for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
 304         if (mon->capab_offered[cap]) {
 305             qlist_append_str(cap_list, QMPCapability_str(cap));
 306         }
 307     }
 308
 309     return qdict_from_jsonf_nofail(
 310         "{'QMP': {'version': %p, 'capabilities': %p}}",
 311         ver, cap_list);
 312 }
 313
 314 static void monitor_qmp_event(void *opaque, int event)
 315 {
 316     QDict *data;
 317     MonitorQMP *mon = opaque;
 318
 319     switch (event) {
 320     case CHR_EVENT_OPENED:
 321         mon->commands = &qmp_cap_negotiation_commands;
 322         monitor_qmp_caps_reset(mon);
 323         data = qmp_greeting(mon);
 324         qmp_send_response(mon, data);
 325         qobject_unref(data);
 326         mon_refcount++;
 327         break;
 328     case CHR_EVENT_CLOSED:
 329         /*
 330          * Note: this is only useful when the output of the chardev
 331          * backend is still open.  For example, when the backend is
 332          * stdio, it's possible that stdout is still open when stdin
 333          * is closed.
 334          */
 335         monitor_qmp_cleanup_queues(mon);
 336         json_message_parser_destroy(&mon->parser);
 337         json_message_parser_init(&mon->parser, handle_qmp_command,
 338                                  mon, NULL);
 339         mon_refcount--;
 340         monitor_fdsets_cleanup();
 341         break;
 342     }
 343 }
 344
 345 void monitor_data_destroy_qmp(MonitorQMP *mon)
 346 {
 347     json_message_parser_destroy(&mon->parser);
 348     qemu_mutex_destroy(&mon->qmp_queue_lock);
 349     monitor_qmp_cleanup_req_queue_locked(mon);
 350     g_queue_free(mon->qmp_requests);
 351 }
 352
 353 static void monitor_qmp_setup_handlers_bh(void *opaque)
 354 {
 355     MonitorQMP *mon = opaque;
 356     GMainContext *context;
 357
 358     assert(mon->common.use_io_thread);
 359     context = iothread_get_g_main_context(mon_iothread);
 360     assert(context);
 361     qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
 362                              monitor_qmp_read, monitor_qmp_event,
 363                              NULL, &mon->common, context, true);
 364     monitor_list_append(&mon->common);
 365 }
 366
 367 void monitor_init_qmp(Chardev *chr, bool pretty)
 368 {
 369     MonitorQMP *mon = g_new0(MonitorQMP, 1);
 370
 371     /* Note: we run QMP monitor in I/O thread when @chr supports that */
 372     monitor_data_init(&mon->common, true, false,
 373                       qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
 374
 375     mon->pretty = pretty;
 376
 377     qemu_mutex_init(&mon->qmp_queue_lock);
 378     mon->qmp_requests = g_queue_new();
 379
 380     qemu_chr_fe_init(&mon->common.chr, chr, &error_abort);
 381     qemu_chr_fe_set_echo(&mon->common.chr, true);
 382
 383     json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
 384     if (mon->common.use_io_thread) {
 385         /*
 386          * Make sure the old iowatch is gone.  It's possible when
 387          * e.g. the chardev is in client mode, with wait=on.
 388          */
 389         remove_fd_in_watch(chr);
 390         /*
 391          * We can't call qemu_chr_fe_set_handlers() directly here
 392          * since chardev might be running in the monitor I/O
 393          * thread.  Schedule a bottom half.
 394          */
 395         aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
 396                                 monitor_qmp_setup_handlers_bh, mon);
 397         /* The bottom half will add @mon to @mon_list */
 398     } else {
 399         qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
 400                                  monitor_qmp_read, monitor_qmp_event,
 401                                  NULL, &mon->common, NULL, true);
 402         monitor_list_append(&mon->common);
 403     }
 404 }