monitor/monitor.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 #include "monitor-internal.h"
  27 #include "qapi/error.h"
  28 #include "qapi/opts-visitor.h"
  29 #include "qapi/qapi-emit-events.h"
  30 #include "qapi/qapi-visit-control.h"
  31 #include "qapi/qmp/qdict.h"
  32 #include "qapi/qmp/qstring.h"
  33 #include "qemu/error-report.h"
  34 #include "qemu/option.h"
  35 #include "sysemu/qtest.h"
  36 #include "sysemu/sysemu.h"
  37 #include "trace.h"
  38
  39 /*
  40  * To prevent flooding clients, events can be throttled. The
  41  * throttling is calculated globally, rather than per-Monitor
  42  * instance.
  43  */
  44 typedef struct MonitorQAPIEventState {
  45     QAPIEvent event;    /* Throttling state for this event type and... */
  46     QDict *data;        /* ... data, see qapi_event_throttle_equal() */
  47     QEMUTimer *timer;   /* Timer for handling delayed events */
  48     QDict *qdict;       /* Delayed event (if any) */
  49 } MonitorQAPIEventState;
  50
  51 typedef struct {
  52     int64_t rate;       /* Minimum time (in ns) between two events */
  53 } MonitorQAPIEventConf;
  54
  55 /* Shared monitor I/O thread */
  56 IOThread *mon_iothread;
  57
  58 /* Bottom half to dispatch the requests received from I/O thread */
  59 QEMUBH *qmp_dispatcher_bh;
  60
  61 /* Protects mon_list, monitor_qapi_event_state, monitor_destroyed.  */
  62 QemuMutex monitor_lock;
  63 static GHashTable *monitor_qapi_event_state;
  64
  65 MonitorList mon_list;
  66 int mon_refcount;
  67 static bool monitor_destroyed;
  68
  69 __thread Monitor *cur_mon;
  70
  71 /**
  72  * Is the current monitor, if any, a QMP monitor?
  73  */
  74 bool monitor_cur_is_qmp(void)
  75 {
  76     return cur_mon && monitor_is_qmp(cur_mon);
  77 }
  78
  79 /**
  80  * Is @mon is using readline?
  81  * Note: not all HMP monitors use readline, e.g., gdbserver has a
  82  * non-interactive HMP monitor, so readline is not used there.
  83  */
  84 static inline bool monitor_uses_readline(const MonitorHMP *mon)
  85 {
  86     return mon->use_readline;
  87 }
  88
  89 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
  90 {
  91     if (monitor_is_qmp(mon)) {
  92         return false;
  93     }
  94
  95     return !monitor_uses_readline(container_of(mon, MonitorHMP, common));
  96 }
  97
  98 static void monitor_flush_locked(Monitor *mon);
  99
 100 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
 101                                   void *opaque)
 102 {
 103     Monitor *mon = opaque;
 104
 105     qemu_mutex_lock(&mon->mon_lock);
 106     mon->out_watch = 0;
 107     monitor_flush_locked(mon);
 108     qemu_mutex_unlock(&mon->mon_lock);
 109     return FALSE;
 110 }
 111
 112 /* Caller must hold mon->mon_lock */
 113 static void monitor_flush_locked(Monitor *mon)
 114 {
 115     int rc;
 116     size_t len;
 117     const char *buf;
 118
 119     if (mon->skip_flush) {
 120         return;
 121     }
 122
 123     buf = qstring_get_str(mon->outbuf);
 124     len = qstring_get_length(mon->outbuf);
 125
 126     if (len && !mon->mux_out) {
 127         rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
 128         if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
 129             /* all flushed or error */
 130             qobject_unref(mon->outbuf);
 131             mon->outbuf = qstring_new();
 132             return;
 133         }
 134         if (rc > 0) {
 135             /* partial write */
 136             QString *tmp = qstring_from_str(buf + rc);
 137             qobject_unref(mon->outbuf);
 138             mon->outbuf = tmp;
 139         }
 140         if (mon->out_watch == 0) {
 141             mon->out_watch =
 142                 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
 143                                       monitor_unblocked, mon);
 144         }
 145     }
 146 }
 147
 148 void monitor_flush(Monitor *mon)
 149 {
 150     qemu_mutex_lock(&mon->mon_lock);
 151     monitor_flush_locked(mon);
 152     qemu_mutex_unlock(&mon->mon_lock);
 153 }
 154
 155 /* flush at every end of line */
 156 int monitor_puts(Monitor *mon, const char *str)
 157 {
 158     int i;
 159     char c;
 160
 161     qemu_mutex_lock(&mon->mon_lock);
 162     for (i = 0; str[i]; i++) {
 163         c = str[i];
 164         if (c == '\n') {
 165             qstring_append_chr(mon->outbuf, '\r');
 166         }
 167         qstring_append_chr(mon->outbuf, c);
 168         if (c == '\n') {
 169             monitor_flush_locked(mon);
 170         }
 171     }
 172     qemu_mutex_unlock(&mon->mon_lock);
 173
 174     return i;
 175 }
 176
 177 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
 178 {
 179     char *buf;
 180     int n;
 181
 182     if (!mon) {
 183         return -1;
 184     }
 185
 186     if (monitor_is_qmp(mon)) {
 187         return -1;
 188     }
 189
 190     buf = g_strdup_vprintf(fmt, ap);
 191     n = monitor_puts(mon, buf);
 192     g_free(buf);
 193     return n;
 194 }
 195
 196 int monitor_printf(Monitor *mon, const char *fmt, ...)
 197 {
 198     int ret;
 199
 200     va_list ap;
 201     va_start(ap, fmt);
 202     ret = monitor_vprintf(mon, fmt, ap);
 203     va_end(ap);
 204     return ret;
 205 }
 206
 207 /*
 208  * Print to current monitor if we have one, else to stderr.
 209  */
 210 int error_vprintf(const char *fmt, va_list ap)
 211 {
 212     if (cur_mon && !monitor_cur_is_qmp()) {
 213         return monitor_vprintf(cur_mon, fmt, ap);
 214     }
 215     return vfprintf(stderr, fmt, ap);
 216 }
 217
 218 int error_vprintf_unless_qmp(const char *fmt, va_list ap)
 219 {
 220     if (!cur_mon) {
 221         return vfprintf(stderr, fmt, ap);
 222     }
 223     if (!monitor_cur_is_qmp()) {
 224         return monitor_vprintf(cur_mon, fmt, ap);
 225     }
 226     return -1;
 227 }
 228
 229
 230 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
 231     /* Limit guest-triggerable events to 1 per second */
 232     [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
 233     [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
 234     [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
 235     [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
 236     [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
 237     [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
 238     [QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE] = { 1000 * SCALE_MS },
 239 };
 240
 241 /*
 242  * Return the clock to use for recording an event's time.
 243  * It's QEMU_CLOCK_REALTIME, except for qtests it's
 244  * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
 245  * Beware: result is invalid before configure_accelerator().
 246  */
 247 static inline QEMUClockType monitor_get_event_clock(void)
 248 {
 249     return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
 250 }
 251
 252 /*
 253  * Broadcast an event to all monitors.
 254  * @qdict is the event object.  Its member "event" must match @event.
 255  * Caller must hold monitor_lock.
 256  */
 257 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
 258 {
 259     Monitor *mon;
 260     MonitorQMP *qmp_mon;
 261
 262     trace_monitor_protocol_event_emit(event, qdict);
 263     QTAILQ_FOREACH(mon, &mon_list, entry) {
 264         if (!monitor_is_qmp(mon)) {
 265             continue;
 266         }
 267
 268         qmp_mon = container_of(mon, MonitorQMP, common);
 269         if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
 270             qmp_send_response(qmp_mon, qdict);
 271         }
 272     }
 273 }
 274
 275 static void monitor_qapi_event_handler(void *opaque);
 276
 277 /*
 278  * Queue a new event for emission to Monitor instances,
 279  * applying any rate limiting if required.
 280  */
 281 static void
 282 monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
 283 {
 284     MonitorQAPIEventConf *evconf;
 285     MonitorQAPIEventState *evstate;
 286
 287     assert(event < QAPI_EVENT__MAX);
 288     evconf = &monitor_qapi_event_conf[event];
 289     trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
 290
 291     qemu_mutex_lock(&monitor_lock);
 292
 293     if (!evconf->rate) {
 294         /* Unthrottled event */
 295         monitor_qapi_event_emit(event, qdict);
 296     } else {
 297         QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
 298         MonitorQAPIEventState key = { .event = event, .data = data };
 299
 300         evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
 301         assert(!evstate || timer_pending(evstate->timer));
 302
 303         if (evstate) {
 304             /*
 305              * Timer is pending for (at least) evconf->rate ns after
 306              * last send.  Store event for sending when timer fires,
 307              * replacing a prior stored event if any.
 308              */
 309             qobject_unref(evstate->qdict);
 310             evstate->qdict = qobject_ref(qdict);
 311         } else {
 312             /*
 313              * Last send was (at least) evconf->rate ns ago.
 314              * Send immediately, and arm the timer to call
 315              * monitor_qapi_event_handler() in evconf->rate ns.  Any
 316              * events arriving before then will be delayed until then.
 317              */
 318             int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
 319
 320             monitor_qapi_event_emit(event, qdict);
 321
 322             evstate = g_new(MonitorQAPIEventState, 1);
 323             evstate->event = event;
 324             evstate->data = qobject_ref(data);
 325             evstate->qdict = NULL;
 326             evstate->timer = timer_new_ns(monitor_get_event_clock(),
 327                                           monitor_qapi_event_handler,
 328                                           evstate);
 329             g_hash_table_add(monitor_qapi_event_state, evstate);
 330             timer_mod_ns(evstate->timer, now + evconf->rate);
 331         }
 332     }
 333
 334     qemu_mutex_unlock(&monitor_lock);
 335 }
 336
 337 void qapi_event_emit(QAPIEvent event, QDict *qdict)
 338 {
 339     /*
 340      * monitor_qapi_event_queue_no_reenter() is not reentrant: it
 341      * would deadlock on monitor_lock.  Work around by queueing
 342      * events in thread-local storage.
 343      * TODO: remove this, make it re-enter safe.
 344      */
 345     typedef struct MonitorQapiEvent {
 346         QAPIEvent event;
 347         QDict *qdict;
 348         QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
 349     } MonitorQapiEvent;
 350     static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
 351     static __thread bool reentered;
 352     MonitorQapiEvent *ev;
 353
 354     if (!reentered) {
 355         QSIMPLEQ_INIT(&event_queue);
 356     }
 357
 358     ev = g_new(MonitorQapiEvent, 1);
 359     ev->qdict = qobject_ref(qdict);
 360     ev->event = event;
 361     QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
 362     if (reentered) {
 363         return;
 364     }
 365
 366     reentered = true;
 367
 368     while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
 369         QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
 370         monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
 371         qobject_unref(ev->qdict);
 372         g_free(ev);
 373     }
 374
 375     reentered = false;
 376 }
 377
 378 /*
 379  * This function runs evconf->rate ns after sending a throttled
 380  * event.
 381  * If another event has since been stored, send it.
 382  */
 383 static void monitor_qapi_event_handler(void *opaque)
 384 {
 385     MonitorQAPIEventState *evstate = opaque;
 386     MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
 387
 388     trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
 389     qemu_mutex_lock(&monitor_lock);
 390
 391     if (evstate->qdict) {
 392         int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
 393
 394         monitor_qapi_event_emit(evstate->event, evstate->qdict);
 395         qobject_unref(evstate->qdict);
 396         evstate->qdict = NULL;
 397         timer_mod_ns(evstate->timer, now + evconf->rate);
 398     } else {
 399         g_hash_table_remove(monitor_qapi_event_state, evstate);
 400         qobject_unref(evstate->data);
 401         timer_free(evstate->timer);
 402         g_free(evstate);
 403     }
 404
 405     qemu_mutex_unlock(&monitor_lock);
 406 }
 407
 408 static unsigned int qapi_event_throttle_hash(const void *key)
 409 {
 410     const MonitorQAPIEventState *evstate = key;
 411     unsigned int hash = evstate->event * 255;
 412
 413     if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
 414         hash += g_str_hash(qdict_get_str(evstate->data, "id"));
 415     }
 416
 417     if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 418         hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
 419     }
 420
 421     return hash;
 422 }
 423
 424 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
 425 {
 426     const MonitorQAPIEventState *eva = a;
 427     const MonitorQAPIEventState *evb = b;
 428
 429     if (eva->event != evb->event) {
 430         return FALSE;
 431     }
 432
 433     if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
 434         return !strcmp(qdict_get_str(eva->data, "id"),
 435                        qdict_get_str(evb->data, "id"));
 436     }
 437
 438     if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 439         return !strcmp(qdict_get_str(eva->data, "node-name"),
 440                        qdict_get_str(evb->data, "node-name"));
 441     }
 442
 443     return TRUE;
 444 }
 445
 446 int monitor_suspend(Monitor *mon)
 447 {
 448     if (monitor_is_hmp_non_interactive(mon)) {
 449         return -ENOTTY;
 450     }
 451
 452     atomic_inc(&mon->suspend_cnt);
 453
 454     if (mon->use_io_thread) {
 455         /*
 456          * Kick I/O thread to make sure this takes effect.  It'll be
 457          * evaluated again in prepare() of the watch object.
 458          */
 459         aio_notify(iothread_get_aio_context(mon_iothread));
 460     }
 461
 462     trace_monitor_suspend(mon, 1);
 463     return 0;
 464 }
 465
 466 static void monitor_accept_input(void *opaque)
 467 {
 468     Monitor *mon = opaque;
 469
 470     qemu_chr_fe_accept_input(&mon->chr);
 471 }
 472
 473 void monitor_resume(Monitor *mon)
 474 {
 475     if (monitor_is_hmp_non_interactive(mon)) {
 476         return;
 477     }
 478
 479     if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
 480         AioContext *ctx;
 481
 482         if (mon->use_io_thread) {
 483             ctx = iothread_get_aio_context(mon_iothread);
 484         } else {
 485             ctx = qemu_get_aio_context();
 486         }
 487
 488         if (!monitor_is_qmp(mon)) {
 489             MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
 490             assert(hmp_mon->rs);
 491             readline_show_prompt(hmp_mon->rs);
 492         }
 493
 494         aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
 495     }
 496
 497     trace_monitor_suspend(mon, -1);
 498 }
 499
 500 int monitor_can_read(void *opaque)
 501 {
 502     Monitor *mon = opaque;
 503
 504     return !atomic_mb_read(&mon->suspend_cnt);
 505 }
 506
 507 void monitor_list_append(Monitor *mon)
 508 {
 509     qemu_mutex_lock(&monitor_lock);
 510     /*
 511      * This prevents inserting new monitors during monitor_cleanup().
 512      * A cleaner solution would involve the main thread telling other
 513      * threads to terminate, waiting for their termination.
 514      */
 515     if (!monitor_destroyed) {
 516         QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
 517         mon = NULL;
 518     }
 519     qemu_mutex_unlock(&monitor_lock);
 520
 521     if (mon) {
 522         monitor_data_destroy(mon);
 523         g_free(mon);
 524     }
 525 }
 526
 527 static void monitor_iothread_init(void)
 528 {
 529     mon_iothread = iothread_create("mon_iothread", &error_abort);
 530 }
 531
 532 void monitor_data_init(Monitor *mon, bool is_qmp, bool skip_flush,
 533                        bool use_io_thread)
 534 {
 535     if (use_io_thread && !mon_iothread) {
 536         monitor_iothread_init();
 537     }
 538     qemu_mutex_init(&mon->mon_lock);
 539     mon->is_qmp = is_qmp;
 540     mon->outbuf = qstring_new();
 541     mon->skip_flush = skip_flush;
 542     mon->use_io_thread = use_io_thread;
 543 }
 544
 545 void monitor_data_destroy(Monitor *mon)
 546 {
 547     g_free(mon->mon_cpu_path);
 548     qemu_chr_fe_deinit(&mon->chr, false);
 549     if (monitor_is_qmp(mon)) {
 550         monitor_data_destroy_qmp(container_of(mon, MonitorQMP, common));
 551     } else {
 552         readline_free(container_of(mon, MonitorHMP, common)->rs);
 553     }
 554     qobject_unref(mon->outbuf);
 555     qemu_mutex_destroy(&mon->mon_lock);
 556 }
 557
 558 void monitor_cleanup(void)
 559 {
 560     /*
 561      * We need to explicitly stop the I/O thread (but not destroy it),
 562      * clean up the monitor resources, then destroy the I/O thread since
 563      * we need to unregister from chardev below in
 564      * monitor_data_destroy(), and chardev is not thread-safe yet
 565      */
 566     if (mon_iothread) {
 567         iothread_stop(mon_iothread);
 568     }
 569
 570     /* Flush output buffers and destroy monitors */
 571     qemu_mutex_lock(&monitor_lock);
 572     monitor_destroyed = true;
 573     while (!QTAILQ_EMPTY(&mon_list)) {
 574         Monitor *mon = QTAILQ_FIRST(&mon_list);
 575         QTAILQ_REMOVE(&mon_list, mon, entry);
 576         /* Permit QAPI event emission from character frontend release */
 577         qemu_mutex_unlock(&monitor_lock);
 578         monitor_flush(mon);
 579         monitor_data_destroy(mon);
 580         qemu_mutex_lock(&monitor_lock);
 581         g_free(mon);
 582     }
 583     qemu_mutex_unlock(&monitor_lock);
 584
 585     /* QEMUBHs needs to be deleted before destroying the I/O thread */
 586     qemu_bh_delete(qmp_dispatcher_bh);
 587     qmp_dispatcher_bh = NULL;
 588     if (mon_iothread) {
 589         iothread_destroy(mon_iothread);
 590         mon_iothread = NULL;
 591     }
 592 }
 593
 594 static void monitor_qapi_event_init(void)
 595 {
 596     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
 597                                                 qapi_event_throttle_equal);
 598 }
 599
 600 void monitor_init_globals_core(void)
 601 {
 602     monitor_qapi_event_init();
 603     qemu_mutex_init(&monitor_lock);
 604
 605     /*
 606      * The dispatcher BH must run in the main loop thread, since we
 607      * have commands assuming that context.  It would be nice to get
 608      * rid of those assumptions.
 609      */
 610     qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
 611                                    monitor_qmp_bh_dispatcher,
 612                                    NULL);
 613 }
 614
 615 int monitor_init(MonitorOptions *opts, bool allow_hmp, Error **errp)
 616 {
 617     Chardev *chr;
 618     Error *local_err = NULL;
 619
 620     chr = qemu_chr_find(opts->chardev);
 621     if (chr == NULL) {
 622         error_setg(errp, "chardev \"%s\" not found", opts->chardev);
 623         return -1;
 624     }
 625
 626     if (!opts->has_mode) {
 627         opts->mode = allow_hmp ? MONITOR_MODE_READLINE : MONITOR_MODE_CONTROL;
 628     }
 629
 630     switch (opts->mode) {
 631     case MONITOR_MODE_CONTROL:
 632         monitor_init_qmp(chr, opts->pretty, &local_err);
 633         break;
 634     case MONITOR_MODE_READLINE:
 635         if (!allow_hmp) {
 636             error_setg(errp, "Only QMP is supported");
 637             return -1;
 638         }
 639         if (opts->pretty) {
 640             warn_report("'pretty' is deprecated for HMP monitors, it has no "
 641                         "effect and will be removed in future versions");
 642         }
 643         monitor_init_hmp(chr, true, &local_err);
 644         break;
 645     default:
 646         g_assert_not_reached();
 647     }
 648
 649     if (local_err) {
 650         error_propagate(errp, local_err);
 651         return -1;
 652     }
 653     return 0;
 654 }
 655
 656 int monitor_init_opts(QemuOpts *opts, Error **errp)
 657 {
 658     Visitor *v;
 659     MonitorOptions *options;
 660     int ret;
 661
 662     v = opts_visitor_new(opts);
 663     visit_type_MonitorOptions(v, NULL, &options, errp);
 664     visit_free(v);
 665     if (!options) {
 666         return -1;
 667     }
 668
 669     ret = monitor_init(options, true, errp);
 670     qapi_free_MonitorOptions(options);
 671     return ret;
 672 }
 673
 674 QemuOptsList qemu_mon_opts = {
 675     .name = "mon",
 676     .implied_opt_name = "chardev",
 677     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
 678     .desc = {
 679         {
 680             .name = "mode",
 681             .type = QEMU_OPT_STRING,
 682         },{
 683             .name = "chardev",
 684             .type = QEMU_OPT_STRING,
 685         },{
 686             .name = "pretty",
 687             .type = QEMU_OPT_BOOL,
 688         },
 689         { /* end of list */ }
 690     },
 691 };