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 <dirent.h>
  27 #include "cpu.h"
  28 #include "hw/hw.h"
  29 #include "monitor/qdev.h"
  30 #include "hw/usb.h"
  31 #include "hw/pci/pci.h"
  32 #include "sysemu/watchdog.h"
  33 #include "hw/loader.h"
  34 #include "exec/gdbstub.h"
  35 #include "net/net.h"
  36 #include "net/slirp.h"
  37 #include "chardev/char-fe.h"
  38 #include "chardev/char-io.h"
  39 #include "chardev/char-mux.h"
  40 #include "ui/qemu-spice.h"
  41 #include "sysemu/numa.h"
  42 #include "monitor/monitor.h"
  43 #include "qemu/config-file.h"
  44 #include "qemu/readline.h"
  45 #include "ui/console.h"
  46 #include "ui/input.h"
  47 #include "sysemu/block-backend.h"
  48 #include "audio/audio.h"
  49 #include "disas/disas.h"
  50 #include "sysemu/balloon.h"
  51 #include "qemu/timer.h"
  52 #include "sysemu/hw_accel.h"
  53 #include "qemu/acl.h"
  54 #include "sysemu/tpm.h"
  55 #include "qapi/qmp/qdict.h"
  56 #include "qapi/qmp/qerror.h"
  57 #include "qapi/qmp/qnum.h"
  58 #include "qapi/qmp/qstring.h"
  59 #include "qapi/qmp/qjson.h"
  60 #include "qapi/qmp/json-streamer.h"
  61 #include "qapi/qmp/json-parser.h"
  62 #include "qapi/qmp/qlist.h"
  63 #include "qom/object_interfaces.h"
  64 #include "trace-root.h"
  65 #include "trace/control.h"
  66 #include "monitor/hmp-target.h"
  67 #ifdef CONFIG_TRACE_SIMPLE
  68 #include "trace/simple.h"
  69 #endif
  70 #include "exec/memory.h"
  71 #include "exec/exec-all.h"
  72 #include "qemu/log.h"
  73 #include "qemu/option.h"
  74 #include "hmp.h"
  75 #include "qemu/thread.h"
  76 #include "block/qapi.h"
  77 #include "qapi/qapi-commands.h"
  78 #include "qapi/qapi-events.h"
  79 #include "qapi/error.h"
  80 #include "qapi/qmp-event.h"
  81 #include "qapi/qapi-introspect.h"
  82 #include "sysemu/qtest.h"
  83 #include "sysemu/cpus.h"
  84 #include "sysemu/iothread.h"
  85 #include "qemu/cutils.h"
  86
  87 #if defined(TARGET_S390X)
  88 #include "hw/s390x/storage-keys.h"
  89 #include "hw/s390x/storage-attributes.h"
  90 #endif
  91
  92 /*
  93  * Supported types:
  94  *
  95  * 'F'          filename
  96  * 'B'          block device name
  97  * 's'          string (accept optional quote)
  98  * 'S'          it just appends the rest of the string (accept optional quote)
  99  * 'O'          option string of the form NAME=VALUE,...
 100  *              parsed according to QemuOptsList given by its name
 101  *              Example: 'device:O' uses qemu_device_opts.
 102  *              Restriction: only lists with empty desc are supported
 103  *              TODO lift the restriction
 104  * 'i'          32 bit integer
 105  * 'l'          target long (32 or 64 bit)
 106  * 'M'          Non-negative target long (32 or 64 bit), in user mode the
 107  *              value is multiplied by 2^20 (think Mebibyte)
 108  * 'o'          octets (aka bytes)
 109  *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
 110  *              K, k suffix, which multiplies the value by 2^60 for suffixes E
 111  *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
 112  *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
 113  * 'T'          double
 114  *              user mode accepts an optional ms, us, ns suffix,
 115  *              which divides the value by 1e3, 1e6, 1e9, respectively
 116  * '/'          optional gdb-like print format (like "/10x")
 117  *
 118  * '?'          optional type (for all types, except '/')
 119  * '.'          other form of optional type (for 'i' and 'l')
 120  * 'b'          boolean
 121  *              user mode accepts "on" or "off"
 122  * '-'          optional parameter (eg. '-f')
 123  *
 124  */
 125
 126 typedef struct mon_cmd_t {
 127     const char *name;
 128     const char *args_type;
 129     const char *params;
 130     const char *help;
 131     void (*cmd)(Monitor *mon, const QDict *qdict);
 132     /* @sub_table is a list of 2nd level of commands. If it does not exist,
 133      * cmd should be used. If it exists, sub_table[?].cmd should be
 134      * used, and cmd of 1st level plays the role of help function.
 135      */
 136     struct mon_cmd_t *sub_table;
 137     void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
 138 } mon_cmd_t;
 139
 140 /* file descriptors passed via SCM_RIGHTS */
 141 typedef struct mon_fd_t mon_fd_t;
 142 struct mon_fd_t {
 143     char *name;
 144     int fd;
 145     QLIST_ENTRY(mon_fd_t) next;
 146 };
 147
 148 /* file descriptor associated with a file descriptor set */
 149 typedef struct MonFdsetFd MonFdsetFd;
 150 struct MonFdsetFd {
 151     int fd;
 152     bool removed;
 153     char *opaque;
 154     QLIST_ENTRY(MonFdsetFd) next;
 155 };
 156
 157 /* file descriptor set containing fds passed via SCM_RIGHTS */
 158 typedef struct MonFdset MonFdset;
 159 struct MonFdset {
 160     int64_t id;
 161     QLIST_HEAD(, MonFdsetFd) fds;
 162     QLIST_HEAD(, MonFdsetFd) dup_fds;
 163     QLIST_ENTRY(MonFdset) next;
 164 };
 165
 166 typedef struct {
 167     JSONMessageParser parser;
 168     /*
 169      * When a client connects, we're in capabilities negotiation mode.
 170      * When command qmp_capabilities succeeds, we go into command
 171      * mode.
 172      */
 173     QmpCommandList *commands;
 174     bool qmp_caps[QMP_CAPABILITY__MAX];
 175     /*
 176      * Protects qmp request/response queue.  Please take monitor_lock
 177      * first when used together.
 178      */
 179     QemuMutex qmp_queue_lock;
 180     /* Input queue that holds all the parsed QMP requests */
 181     GQueue *qmp_requests;
 182     /* Output queue contains all the QMP responses in order */
 183     GQueue *qmp_responses;
 184 } MonitorQMP;
 185
 186 /*
 187  * To prevent flooding clients, events can be throttled. The
 188  * throttling is calculated globally, rather than per-Monitor
 189  * instance.
 190  */
 191 typedef struct MonitorQAPIEventState {
 192     QAPIEvent event;    /* Throttling state for this event type and... */
 193     QDict *data;        /* ... data, see qapi_event_throttle_equal() */
 194     QEMUTimer *timer;   /* Timer for handling delayed events */
 195     QDict *qdict;       /* Delayed event (if any) */
 196 } MonitorQAPIEventState;
 197
 198 typedef struct {
 199     int64_t rate;       /* Minimum time (in ns) between two events */
 200 } MonitorQAPIEventConf;
 201
 202 struct Monitor {
 203     CharBackend chr;
 204     int reset_seen;
 205     int flags;
 206     int suspend_cnt;            /* Needs to be accessed atomically */
 207     bool skip_flush;
 208     bool use_io_thr;
 209
 210     /*
 211      * State used only in the thread "owning" the monitor.
 212      * If @use_io_thr, this is mon_global.mon_iothread.
 213      * Else, it's the main thread.
 214      * These members can be safely accessed without locks.
 215      */
 216     ReadLineState *rs;
 217
 218     MonitorQMP qmp;
 219     gchar *mon_cpu_path;
 220     BlockCompletionFunc *password_completion_cb;
 221     void *password_opaque;
 222     mon_cmd_t *cmd_table;
 223     QTAILQ_ENTRY(Monitor) entry;
 224
 225     /*
 226      * The per-monitor lock. We can't access guest memory when holding
 227      * the lock.
 228      */
 229     QemuMutex mon_lock;
 230
 231     /*
 232      * Fields that are protected by the per-monitor lock.
 233      */
 234     QLIST_HEAD(, mon_fd_t) fds;
 235     QString *outbuf;
 236     guint out_watch;
 237     /* Read under either BQL or mon_lock, written with BQL+mon_lock.  */
 238     int mux_out;
 239 };
 240
 241 /* Let's add monitor global variables to this struct. */
 242 static struct {
 243     IOThread *mon_iothread;
 244     /* Bottom half to dispatch the requests received from IO thread */
 245     QEMUBH *qmp_dispatcher_bh;
 246     /* Bottom half to deliver the responses back to clients */
 247     QEMUBH *qmp_respond_bh;
 248 } mon_global;
 249
 250 struct QMPRequest {
 251     /* Owner of the request */
 252     Monitor *mon;
 253     /* "id" field of the request */
 254     QObject *id;
 255     /* Request object to be handled */
 256     QObject *req;
 257     /*
 258      * Whether we need to resume the monitor afterward.  This flag is
 259      * used to emulate the old QMP server behavior that the current
 260      * command must be completed before execution of the next one.
 261      */
 262     bool need_resume;
 263 };
 264 typedef struct QMPRequest QMPRequest;
 265
 266 /* QMP checker flags */
 267 #define QMP_ACCEPT_UNKNOWNS 1
 268
 269 /* Protects mon_list, monitor_qapi_event_state.  */
 270 static QemuMutex monitor_lock;
 271 static GHashTable *monitor_qapi_event_state;
 272 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
 273
 274 /* Protects mon_fdsets */
 275 static QemuMutex mon_fdsets_lock;
 276 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
 277
 278 static int mon_refcount;
 279
 280 static mon_cmd_t mon_cmds[];
 281 static mon_cmd_t info_cmds[];
 282
 283 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
 284
 285 Monitor *cur_mon;
 286
 287 static void monitor_command_cb(void *opaque, const char *cmdline,
 288                                void *readline_opaque);
 289
 290 /**
 291  * Is @mon a QMP monitor?
 292  */
 293 static inline bool monitor_is_qmp(const Monitor *mon)
 294 {
 295     return (mon->flags & MONITOR_USE_CONTROL);
 296 }
 297
 298 /**
 299  * Whether @mon is using readline?  Note: not all HMP monitors use
 300  * readline, e.g., gdbserver has a non-interactive HMP monitor, so
 301  * readline is not used there.
 302  */
 303 static inline bool monitor_uses_readline(const Monitor *mon)
 304 {
 305     return mon->flags & MONITOR_USE_READLINE;
 306 }
 307
 308 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
 309 {
 310     return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
 311 }
 312
 313 /*
 314  * Return the clock to use for recording an event's time.
 315  * Beware: result is invalid before configure_accelerator().
 316  */
 317 static inline QEMUClockType monitor_get_event_clock(void)
 318 {
 319     /*
 320      * This allows us to perform tests on the monitor queues to verify
 321      * that the rate limits are enforced.
 322      */
 323     return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
 324 }
 325
 326 /**
 327  * Is the current monitor, if any, a QMP monitor?
 328  */
 329 bool monitor_cur_is_qmp(void)
 330 {
 331     return cur_mon && monitor_is_qmp(cur_mon);
 332 }
 333
 334 void monitor_read_command(Monitor *mon, int show_prompt)
 335 {
 336     if (!mon->rs)
 337         return;
 338
 339     readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
 340     if (show_prompt)
 341         readline_show_prompt(mon->rs);
 342 }
 343
 344 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
 345                           void *opaque)
 346 {
 347     if (mon->rs) {
 348         readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
 349         /* prompt is printed on return from the command handler */
 350         return 0;
 351     } else {
 352         monitor_printf(mon, "terminal does not support password prompting\n");
 353         return -ENOTTY;
 354     }
 355 }
 356
 357 static void qmp_request_free(QMPRequest *req)
 358 {
 359     qobject_unref(req->id);
 360     qobject_unref(req->req);
 361     g_free(req);
 362 }
 363
 364 /* Must with the mon->qmp.qmp_queue_lock held */
 365 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
 366 {
 367     while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
 368         qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
 369     }
 370 }
 371
 372 /* Must with the mon->qmp.qmp_queue_lock held */
 373 static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
 374 {
 375     while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
 376         qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
 377     }
 378 }
 379
 380 static void monitor_qmp_cleanup_queues(Monitor *mon)
 381 {
 382     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 383     monitor_qmp_cleanup_req_queue_locked(mon);
 384     monitor_qmp_cleanup_resp_queue_locked(mon);
 385     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 386 }
 387
 388
 389 static void monitor_flush_locked(Monitor *mon);
 390
 391 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
 392                                   void *opaque)
 393 {
 394     Monitor *mon = opaque;
 395
 396     qemu_mutex_lock(&mon->mon_lock);
 397     mon->out_watch = 0;
 398     monitor_flush_locked(mon);
 399     qemu_mutex_unlock(&mon->mon_lock);
 400     return FALSE;
 401 }
 402
 403 /* Called with mon->mon_lock held.  */
 404 static void monitor_flush_locked(Monitor *mon)
 405 {
 406     int rc;
 407     size_t len;
 408     const char *buf;
 409
 410     if (mon->skip_flush) {
 411         return;
 412     }
 413
 414     buf = qstring_get_str(mon->outbuf);
 415     len = qstring_get_length(mon->outbuf);
 416
 417     if (len && !mon->mux_out) {
 418         rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
 419         if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
 420             /* all flushed or error */
 421             qobject_unref(mon->outbuf);
 422             mon->outbuf = qstring_new();
 423             return;
 424         }
 425         if (rc > 0) {
 426             /* partial write */
 427             QString *tmp = qstring_from_str(buf + rc);
 428             qobject_unref(mon->outbuf);
 429             mon->outbuf = tmp;
 430         }
 431         if (mon->out_watch == 0) {
 432             mon->out_watch =
 433                 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
 434                                       monitor_unblocked, mon);
 435         }
 436     }
 437 }
 438
 439 void monitor_flush(Monitor *mon)
 440 {
 441     qemu_mutex_lock(&mon->mon_lock);
 442     monitor_flush_locked(mon);
 443     qemu_mutex_unlock(&mon->mon_lock);
 444 }
 445
 446 /* flush at every end of line */
 447 static void monitor_puts(Monitor *mon, const char *str)
 448 {
 449     char c;
 450
 451     qemu_mutex_lock(&mon->mon_lock);
 452     for(;;) {
 453         c = *str++;
 454         if (c == '\0')
 455             break;
 456         if (c == '\n') {
 457             qstring_append_chr(mon->outbuf, '\r');
 458         }
 459         qstring_append_chr(mon->outbuf, c);
 460         if (c == '\n') {
 461             monitor_flush_locked(mon);
 462         }
 463     }
 464     qemu_mutex_unlock(&mon->mon_lock);
 465 }
 466
 467 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
 468 {
 469     char *buf;
 470
 471     if (!mon)
 472         return;
 473
 474     if (monitor_is_qmp(mon)) {
 475         return;
 476     }
 477
 478     buf = g_strdup_vprintf(fmt, ap);
 479     monitor_puts(mon, buf);
 480     g_free(buf);
 481 }
 482
 483 void monitor_printf(Monitor *mon, const char *fmt, ...)
 484 {
 485     va_list ap;
 486     va_start(ap, fmt);
 487     monitor_vprintf(mon, fmt, ap);
 488     va_end(ap);
 489 }
 490
 491 int monitor_fprintf(FILE *stream, const char *fmt, ...)
 492 {
 493     va_list ap;
 494     va_start(ap, fmt);
 495     monitor_vprintf((Monitor *)stream, fmt, ap);
 496     va_end(ap);
 497     return 0;
 498 }
 499
 500 static void monitor_json_emitter_raw(Monitor *mon,
 501                                      QObject *data)
 502 {
 503     QString *json;
 504
 505     json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
 506                                              qobject_to_json(data);
 507     assert(json != NULL);
 508
 509     qstring_append_chr(json, '\n');
 510     monitor_puts(mon, qstring_get_str(json));
 511
 512     qobject_unref(json);
 513 }
 514
 515 static void monitor_json_emitter(Monitor *mon, QObject *data)
 516 {
 517     if (mon->use_io_thr) {
 518         /*
 519          * If using IO thread, we need to queue the item so that IO
 520          * thread will do the rest for us.  Take refcount so that
 521          * caller won't free the data (which will be finally freed in
 522          * responder thread).
 523          */
 524         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 525         g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
 526         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 527         qemu_bh_schedule(mon_global.qmp_respond_bh);
 528     } else {
 529         /*
 530          * If not using monitor IO thread, then we are in main thread.
 531          * Do the emission right away.
 532          */
 533         monitor_json_emitter_raw(mon, data);
 534     }
 535 }
 536
 537 struct QMPResponse {
 538     Monitor *mon;
 539     QObject *data;
 540 };
 541 typedef struct QMPResponse QMPResponse;
 542
 543 /*
 544  * Return one QMPResponse.  The response is only valid if
 545  * response.data is not NULL.
 546  */
 547 static QMPResponse monitor_qmp_response_pop_one(void)
 548 {
 549     Monitor *mon;
 550     QObject *data = NULL;
 551
 552     qemu_mutex_lock(&monitor_lock);
 553     QTAILQ_FOREACH(mon, &mon_list, entry) {
 554         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 555         data = g_queue_pop_head(mon->qmp.qmp_responses);
 556         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 557         if (data) {
 558             break;
 559         }
 560     }
 561     qemu_mutex_unlock(&monitor_lock);
 562     return (QMPResponse) { .mon = mon, .data = data };
 563 }
 564
 565 static void monitor_qmp_bh_responder(void *opaque)
 566 {
 567     QMPResponse response;
 568
 569     while (true) {
 570         response = monitor_qmp_response_pop_one();
 571         if (!response.data) {
 572             break;
 573         }
 574         monitor_json_emitter_raw(response.mon, response.data);
 575         qobject_unref(response.data);
 576     }
 577 }
 578
 579 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
 580     /* Limit guest-triggerable events to 1 per second */
 581     [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
 582     [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
 583     [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
 584     [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
 585     [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
 586     [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
 587 };
 588
 589 /*
 590  * Emits the event to every monitor instance, @event is only used for trace
 591  * Called with monitor_lock held.
 592  */
 593 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
 594 {
 595     Monitor *mon;
 596
 597     trace_monitor_protocol_event_emit(event, qdict);
 598     QTAILQ_FOREACH(mon, &mon_list, entry) {
 599         if (monitor_is_qmp(mon)
 600             && mon->qmp.commands != &qmp_cap_negotiation_commands) {
 601             monitor_json_emitter(mon, QOBJECT(qdict));
 602         }
 603     }
 604 }
 605
 606 static void monitor_qapi_event_handler(void *opaque);
 607
 608 /*
 609  * Queue a new event for emission to Monitor instances,
 610  * applying any rate limiting if required.
 611  */
 612 static void
 613 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
 614 {
 615     MonitorQAPIEventConf *evconf;
 616     MonitorQAPIEventState *evstate;
 617
 618     assert(event < QAPI_EVENT__MAX);
 619     evconf = &monitor_qapi_event_conf[event];
 620     trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
 621
 622     qemu_mutex_lock(&monitor_lock);
 623
 624     if (!evconf->rate) {
 625         /* Unthrottled event */
 626         monitor_qapi_event_emit(event, qdict);
 627     } else {
 628         QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
 629         MonitorQAPIEventState key = { .event = event, .data = data };
 630
 631         evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
 632         assert(!evstate || timer_pending(evstate->timer));
 633
 634         if (evstate) {
 635             /*
 636              * Timer is pending for (at least) evconf->rate ns after
 637              * last send.  Store event for sending when timer fires,
 638              * replacing a prior stored event if any.
 639              */
 640             qobject_unref(evstate->qdict);
 641             evstate->qdict = qobject_ref(qdict);
 642         } else {
 643             /*
 644              * Last send was (at least) evconf->rate ns ago.
 645              * Send immediately, and arm the timer to call
 646              * monitor_qapi_event_handler() in evconf->rate ns.  Any
 647              * events arriving before then will be delayed until then.
 648              */
 649             int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
 650
 651             monitor_qapi_event_emit(event, qdict);
 652
 653             evstate = g_new(MonitorQAPIEventState, 1);
 654             evstate->event = event;
 655             evstate->data = qobject_ref(data);
 656             evstate->qdict = NULL;
 657             evstate->timer = timer_new_ns(monitor_get_event_clock(),
 658                                           monitor_qapi_event_handler,
 659                                           evstate);
 660             g_hash_table_add(monitor_qapi_event_state, evstate);
 661             timer_mod_ns(evstate->timer, now + evconf->rate);
 662         }
 663     }
 664
 665     qemu_mutex_unlock(&monitor_lock);
 666 }
 667
 668 /*
 669  * This function runs evconf->rate ns after sending a throttled
 670  * event.
 671  * If another event has since been stored, send it.
 672  */
 673 static void monitor_qapi_event_handler(void *opaque)
 674 {
 675     MonitorQAPIEventState *evstate = opaque;
 676     MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
 677
 678     trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
 679     qemu_mutex_lock(&monitor_lock);
 680
 681     if (evstate->qdict) {
 682         int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
 683
 684         monitor_qapi_event_emit(evstate->event, evstate->qdict);
 685         qobject_unref(evstate->qdict);
 686         evstate->qdict = NULL;
 687         timer_mod_ns(evstate->timer, now + evconf->rate);
 688     } else {
 689         g_hash_table_remove(monitor_qapi_event_state, evstate);
 690         qobject_unref(evstate->data);
 691         timer_free(evstate->timer);
 692         g_free(evstate);
 693     }
 694
 695     qemu_mutex_unlock(&monitor_lock);
 696 }
 697
 698 static unsigned int qapi_event_throttle_hash(const void *key)
 699 {
 700     const MonitorQAPIEventState *evstate = key;
 701     unsigned int hash = evstate->event * 255;
 702
 703     if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
 704         hash += g_str_hash(qdict_get_str(evstate->data, "id"));
 705     }
 706
 707     if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 708         hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
 709     }
 710
 711     return hash;
 712 }
 713
 714 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
 715 {
 716     const MonitorQAPIEventState *eva = a;
 717     const MonitorQAPIEventState *evb = b;
 718
 719     if (eva->event != evb->event) {
 720         return FALSE;
 721     }
 722
 723     if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
 724         return !strcmp(qdict_get_str(eva->data, "id"),
 725                        qdict_get_str(evb->data, "id"));
 726     }
 727
 728     if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 729         return !strcmp(qdict_get_str(eva->data, "node-name"),
 730                        qdict_get_str(evb->data, "node-name"));
 731     }
 732
 733     return TRUE;
 734 }
 735
 736 static void monitor_qapi_event_init(void)
 737 {
 738     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
 739                                                 qapi_event_throttle_equal);
 740     qmp_event_set_func_emit(monitor_qapi_event_queue);
 741 }
 742
 743 static void handle_hmp_command(Monitor *mon, const char *cmdline);
 744
 745 static void monitor_data_init(Monitor *mon, bool skip_flush,
 746                               bool use_io_thr)
 747 {
 748     memset(mon, 0, sizeof(Monitor));
 749     qemu_mutex_init(&mon->mon_lock);
 750     qemu_mutex_init(&mon->qmp.qmp_queue_lock);
 751     mon->outbuf = qstring_new();
 752     /* Use *mon_cmds by default. */
 753     mon->cmd_table = mon_cmds;
 754     mon->skip_flush = skip_flush;
 755     mon->use_io_thr = use_io_thr;
 756     mon->qmp.qmp_requests = g_queue_new();
 757     mon->qmp.qmp_responses = g_queue_new();
 758 }
 759
 760 static void monitor_data_destroy(Monitor *mon)
 761 {
 762     g_free(mon->mon_cpu_path);
 763     qemu_chr_fe_deinit(&mon->chr, false);
 764     if (monitor_is_qmp(mon)) {
 765         json_message_parser_destroy(&mon->qmp.parser);
 766     }
 767     readline_free(mon->rs);
 768     qobject_unref(mon->outbuf);
 769     qemu_mutex_destroy(&mon->mon_lock);
 770     qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
 771     monitor_qmp_cleanup_req_queue_locked(mon);
 772     monitor_qmp_cleanup_resp_queue_locked(mon);
 773     g_queue_free(mon->qmp.qmp_requests);
 774     g_queue_free(mon->qmp.qmp_responses);
 775 }
 776
 777 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
 778                                 int64_t cpu_index, Error **errp)
 779 {
 780     char *output = NULL;
 781     Monitor *old_mon, hmp;
 782
 783     monitor_data_init(&hmp, true, false);
 784
 785     old_mon = cur_mon;
 786     cur_mon = &hmp;
 787
 788     if (has_cpu_index) {
 789         int ret = monitor_set_cpu(cpu_index);
 790         if (ret < 0) {
 791             cur_mon = old_mon;
 792             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
 793                        "a CPU number");
 794             goto out;
 795         }
 796     }
 797
 798     handle_hmp_command(&hmp, command_line);
 799     cur_mon = old_mon;
 800
 801     qemu_mutex_lock(&hmp.mon_lock);
 802     if (qstring_get_length(hmp.outbuf) > 0) {
 803         output = g_strdup(qstring_get_str(hmp.outbuf));
 804     } else {
 805         output = g_strdup("");
 806     }
 807     qemu_mutex_unlock(&hmp.mon_lock);
 808
 809 out:
 810     monitor_data_destroy(&hmp);
 811     return output;
 812 }
 813
 814 static int compare_cmd(const char *name, const char *list)
 815 {
 816     const char *p, *pstart;
 817     int len;
 818     len = strlen(name);
 819     p = list;
 820     for(;;) {
 821         pstart = p;
 822         p = strchr(p, '|');
 823         if (!p)
 824             p = pstart + strlen(pstart);
 825         if ((p - pstart) == len && !memcmp(pstart, name, len))
 826             return 1;
 827         if (*p == '\0')
 828             break;
 829         p++;
 830     }
 831     return 0;
 832 }
 833
 834 static int get_str(char *buf, int buf_size, const char **pp)
 835 {
 836     const char *p;
 837     char *q;
 838     int c;
 839
 840     q = buf;
 841     p = *pp;
 842     while (qemu_isspace(*p)) {
 843         p++;
 844     }
 845     if (*p == '\0') {
 846     fail:
 847         *q = '\0';
 848         *pp = p;
 849         return -1;
 850     }
 851     if (*p == '\"') {
 852         p++;
 853         while (*p != '\0' && *p != '\"') {
 854             if (*p == '\\') {
 855                 p++;
 856                 c = *p++;
 857                 switch (c) {
 858                 case 'n':
 859                     c = '\n';
 860                     break;
 861                 case 'r':
 862                     c = '\r';
 863                     break;
 864                 case '\\':
 865                 case '\'':
 866                 case '\"':
 867                     break;
 868                 default:
 869                     printf("unsupported escape code: '\\%c'\n", c);
 870                     goto fail;
 871                 }
 872                 if ((q - buf) < buf_size - 1) {
 873                     *q++ = c;
 874                 }
 875             } else {
 876                 if ((q - buf) < buf_size - 1) {
 877                     *q++ = *p;
 878                 }
 879                 p++;
 880             }
 881         }
 882         if (*p != '\"') {
 883             printf("unterminated string\n");
 884             goto fail;
 885         }
 886         p++;
 887     } else {
 888         while (*p != '\0' && !qemu_isspace(*p)) {
 889             if ((q - buf) < buf_size - 1) {
 890                 *q++ = *p;
 891             }
 892             p++;
 893         }
 894     }
 895     *q = '\0';
 896     *pp = p;
 897     return 0;
 898 }
 899
 900 #define MAX_ARGS 16
 901
 902 static void free_cmdline_args(char **args, int nb_args)
 903 {
 904     int i;
 905
 906     assert(nb_args <= MAX_ARGS);
 907
 908     for (i = 0; i < nb_args; i++) {
 909         g_free(args[i]);
 910     }
 911
 912 }
 913
 914 /*
 915  * Parse the command line to get valid args.
 916  * @cmdline: command line to be parsed.
 917  * @pnb_args: location to store the number of args, must NOT be NULL.
 918  * @args: location to store the args, which should be freed by caller, must
 919  *        NOT be NULL.
 920  *
 921  * Returns 0 on success, negative on failure.
 922  *
 923  * NOTE: this parser is an approximate form of the real command parser. Number
 924  *       of args have a limit of MAX_ARGS. If cmdline contains more, it will
 925  *       return with failure.
 926  */
 927 static int parse_cmdline(const char *cmdline,
 928                          int *pnb_args, char **args)
 929 {
 930     const char *p;
 931     int nb_args, ret;
 932     char buf[1024];
 933
 934     p = cmdline;
 935     nb_args = 0;
 936     for (;;) {
 937         while (qemu_isspace(*p)) {
 938             p++;
 939         }
 940         if (*p == '\0') {
 941             break;
 942         }
 943         if (nb_args >= MAX_ARGS) {
 944             goto fail;
 945         }
 946         ret = get_str(buf, sizeof(buf), &p);
 947         if (ret < 0) {
 948             goto fail;
 949         }
 950         args[nb_args] = g_strdup(buf);
 951         nb_args++;
 952     }
 953     *pnb_args = nb_args;
 954     return 0;
 955
 956  fail:
 957     free_cmdline_args(args, nb_args);
 958     return -1;
 959 }
 960
 961 static void help_cmd_dump_one(Monitor *mon,
 962                               const mon_cmd_t *cmd,
 963                               char **prefix_args,
 964                               int prefix_args_nb)
 965 {
 966     int i;
 967
 968     for (i = 0; i < prefix_args_nb; i++) {
 969         monitor_printf(mon, "%s ", prefix_args[i]);
 970     }
 971     monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
 972 }
 973
 974 /* @args[@arg_index] is the valid command need to find in @cmds */
 975 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
 976                           char **args, int nb_args, int arg_index)
 977 {
 978     const mon_cmd_t *cmd;
 979
 980     /* No valid arg need to compare with, dump all in *cmds */
 981     if (arg_index >= nb_args) {
 982         for (cmd = cmds; cmd->name != NULL; cmd++) {
 983             help_cmd_dump_one(mon, cmd, args, arg_index);
 984         }
 985         return;
 986     }
 987
 988     /* Find one entry to dump */
 989     for (cmd = cmds; cmd->name != NULL; cmd++) {
 990         if (compare_cmd(args[arg_index], cmd->name)) {
 991             if (cmd->sub_table) {
 992                 /* continue with next arg */
 993                 help_cmd_dump(mon, cmd->sub_table,
 994                               args, nb_args, arg_index + 1);
 995             } else {
 996                 help_cmd_dump_one(mon, cmd, args, arg_index);
 997             }
 998             break;
 999         }
1000     }
1001 }
1002
1003 static void help_cmd(Monitor *mon, const char *name)
1004 {
1005     char *args[MAX_ARGS];
1006     int nb_args = 0;
1007
1008     /* 1. parse user input */
1009     if (name) {
1010         /* special case for log, directly dump and return */
1011         if (!strcmp(name, "log")) {
1012             const QEMULogItem *item;
1013             monitor_printf(mon, "Log items (comma separated):\n");
1014             monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
1015             for (item = qemu_log_items; item->mask != 0; item++) {
1016                 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
1017             }
1018             return;
1019         }
1020
1021         if (parse_cmdline(name, &nb_args, args) < 0) {
1022             return;
1023         }
1024     }
1025
1026     /* 2. dump the contents according to parsed args */
1027     help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1028
1029     free_cmdline_args(args, nb_args);
1030 }
1031
1032 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1033 {
1034     help_cmd(mon, qdict_get_try_str(qdict, "name"));
1035 }
1036
1037 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1038 {
1039     const char *tp_name = qdict_get_str(qdict, "name");
1040     bool new_state = qdict_get_bool(qdict, "option");
1041     bool has_vcpu = qdict_haskey(qdict, "vcpu");
1042     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1043     Error *local_err = NULL;
1044
1045     if (vcpu < 0) {
1046         monitor_printf(mon, "argument vcpu must be positive");
1047         return;
1048     }
1049
1050     qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1051     if (local_err) {
1052         error_report_err(local_err);
1053     }
1054 }
1055
1056 #ifdef CONFIG_TRACE_SIMPLE
1057 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1058 {
1059     const char *op = qdict_get_try_str(qdict, "op");
1060     const char *arg = qdict_get_try_str(qdict, "arg");
1061
1062     if (!op) {
1063         st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1064     } else if (!strcmp(op, "on")) {
1065         st_set_trace_file_enabled(true);
1066     } else if (!strcmp(op, "off")) {
1067         st_set_trace_file_enabled(false);
1068     } else if (!strcmp(op, "flush")) {
1069         st_flush_trace_buffer();
1070     } else if (!strcmp(op, "set")) {
1071         if (arg) {
1072             st_set_trace_file(arg);
1073         }
1074     } else {
1075         monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1076         help_cmd(mon, "trace-file");
1077     }
1078 }
1079 #endif
1080
1081 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1082 {
1083     help_cmd(mon, "info");
1084 }
1085
1086 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1087 {
1088     CommandInfoList *info, **list = opaque;
1089
1090     if (!cmd->enabled) {
1091         return;
1092     }
1093
1094     info = g_malloc0(sizeof(*info));
1095     info->value = g_malloc0(sizeof(*info->value));
1096     info->value->name = g_strdup(cmd->name);
1097     info->next = *list;
1098     *list = info;
1099 }
1100
1101 CommandInfoList *qmp_query_commands(Error **errp)
1102 {
1103     CommandInfoList *list = NULL;
1104
1105     qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1106
1107     return list;
1108 }
1109
1110 EventInfoList *qmp_query_events(Error **errp)
1111 {
1112     EventInfoList *info, *ev_list = NULL;
1113     QAPIEvent e;
1114
1115     for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1116         const char *event_name = QAPIEvent_str(e);
1117         assert(event_name != NULL);
1118         info = g_malloc0(sizeof(*info));
1119         info->value = g_malloc0(sizeof(*info->value));
1120         info->value->name = g_strdup(event_name);
1121
1122         info->next = ev_list;
1123         ev_list = info;
1124     }
1125
1126     return ev_list;
1127 }
1128
1129 /*
1130  * Minor hack: generated marshalling suppressed for this command
1131  * ('gen': false in the schema) so we can parse the JSON string
1132  * directly into QObject instead of first parsing it with
1133  * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1134  * to QObject with generated output marshallers, every time.  Instead,
1135  * we do it in test-qobject-input-visitor.c, just to make sure
1136  * qapi-gen.py's output actually conforms to the schema.
1137  */
1138 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1139                                  Error **errp)
1140 {
1141     *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1142 }
1143
1144 /*
1145  * We used to define commands in qmp-commands.hx in addition to the
1146  * QAPI schema.  This permitted defining some of them only in certain
1147  * configurations.  query-commands has always reflected that (good,
1148  * because it lets QMP clients figure out what's actually available),
1149  * while query-qmp-schema never did (not so good).  This function is a
1150  * hack to keep the configuration-specific commands defined exactly as
1151  * before, even though qmp-commands.hx is gone.
1152  *
1153  * FIXME Educate the QAPI schema on configuration-specific commands,
1154  * and drop this hack.
1155  */
1156 static void qmp_unregister_commands_hack(void)
1157 {
1158 #ifndef CONFIG_SPICE
1159     qmp_unregister_command(&qmp_commands, "query-spice");
1160 #endif
1161 #ifndef CONFIG_REPLICATION
1162     qmp_unregister_command(&qmp_commands, "xen-set-replication");
1163     qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1164     qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1165 #endif
1166 #ifndef TARGET_I386
1167     qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1168     qmp_unregister_command(&qmp_commands, "query-sev");
1169     qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1170     qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1171 #endif
1172 #ifndef TARGET_S390X
1173     qmp_unregister_command(&qmp_commands, "dump-skeys");
1174 #endif
1175 #ifndef TARGET_ARM
1176     qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1177 #endif
1178 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1179     qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1180 #endif
1181 #if !defined(TARGET_S390X)
1182     qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1183     qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1184 #endif
1185 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1186     && !defined(TARGET_S390X)
1187     qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1188 #endif
1189 }
1190
1191 static void monitor_init_qmp_commands(void)
1192 {
1193     /*
1194      * Two command lists:
1195      * - qmp_commands contains all QMP commands
1196      * - qmp_cap_negotiation_commands contains just
1197      *   "qmp_capabilities", to enforce capability negotiation
1198      */
1199
1200     qmp_init_marshal(&qmp_commands);
1201
1202     qmp_register_command(&qmp_commands, "query-qmp-schema",
1203                          qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
1204     qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1205                          QCO_NO_OPTIONS);
1206     qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1207                          QCO_NO_OPTIONS);
1208
1209     qmp_unregister_commands_hack();
1210
1211     QTAILQ_INIT(&qmp_cap_negotiation_commands);
1212     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1213                          qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
1214 }
1215
1216 static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
1217 {
1218     return mon->qmp.qmp_caps[cap];
1219 }
1220
1221 static bool qmp_oob_enabled(Monitor *mon)
1222 {
1223     return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
1224 }
1225
1226 static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
1227                            Error **errp)
1228 {
1229     for (; list; list = list->next) {
1230         assert(list->value < QMP_CAPABILITY__MAX);
1231         switch (list->value) {
1232         case QMP_CAPABILITY_OOB:
1233             if (!mon->use_io_thr) {
1234                 /*
1235                  * Out-Of-Band only works with monitors that are
1236                  * running on dedicated IOThread.
1237                  */
1238                 error_setg(errp, "This monitor does not support "
1239                            "Out-Of-Band (OOB)");
1240                 return;
1241             }
1242             break;
1243         default:
1244             break;
1245         }
1246     }
1247 }
1248
1249 /* This function should only be called after capabilities are checked. */
1250 static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
1251 {
1252     for (; list; list = list->next) {
1253         mon->qmp.qmp_caps[list->value] = true;
1254     }
1255 }
1256
1257 /*
1258  * Return true if check successful, or false otherwise.  When false is
1259  * returned, detailed error will be in errp if provided.
1260  */
1261 static bool qmp_cmd_oob_check(Monitor *mon, QDict *req, Error **errp)
1262 {
1263     const char *command;
1264     QmpCommand *cmd;
1265
1266     command = qdict_get_try_str(req, "execute");
1267     if (!command) {
1268         error_setg(errp, "Command field 'execute' missing");
1269         return false;
1270     }
1271
1272     cmd = qmp_find_command(mon->qmp.commands, command);
1273     if (!cmd) {
1274         if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
1275             error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1276                       "Expecting capabilities negotiation "
1277                       "with 'qmp_capabilities'");
1278         } else {
1279             error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1280                       "The command %s has not been found", command);
1281         }
1282         return false;
1283     }
1284
1285     if (qmp_is_oob(req)) {
1286         if (!qmp_oob_enabled(mon)) {
1287             error_setg(errp, "Please enable Out-Of-Band first "
1288                        "for the session during capabilities negotiation");
1289             return false;
1290         }
1291         if (!(cmd->options & QCO_ALLOW_OOB)) {
1292             error_setg(errp, "The command %s does not support OOB",
1293                        command);
1294             return false;
1295         }
1296     }
1297
1298     return true;
1299 }
1300
1301 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1302                           Error **errp)
1303 {
1304     Error *local_err = NULL;
1305
1306     if (cur_mon->qmp.commands == &qmp_commands) {
1307         error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1308                   "Capabilities negotiation is already complete, command "
1309                   "ignored");
1310         return;
1311     }
1312
1313     /* Enable QMP capabilities provided by the client if applicable. */
1314     if (has_enable) {
1315         qmp_caps_check(cur_mon, enable, &local_err);
1316         if (local_err) {
1317             /*
1318              * Failed check on any of the capabilities will fail the
1319              * entire command (and thus not apply any of the other
1320              * capabilities that were also requested).
1321              */
1322             error_propagate(errp, local_err);
1323             return;
1324         }
1325         qmp_caps_apply(cur_mon, enable);
1326     }
1327
1328     cur_mon->qmp.commands = &qmp_commands;
1329 }
1330
1331 /* Set the current CPU defined by the user. Callers must hold BQL. */
1332 int monitor_set_cpu(int cpu_index)
1333 {
1334     CPUState *cpu;
1335
1336     cpu = qemu_get_cpu(cpu_index);
1337     if (cpu == NULL) {
1338         return -1;
1339     }
1340     g_free(cur_mon->mon_cpu_path);
1341     cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1342     return 0;
1343 }
1344
1345 /* Callers must hold BQL. */
1346 static CPUState *mon_get_cpu_sync(bool synchronize)
1347 {
1348     CPUState *cpu;
1349
1350     if (cur_mon->mon_cpu_path) {
1351         cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1352                                                     TYPE_CPU, NULL);
1353         if (!cpu) {
1354             g_free(cur_mon->mon_cpu_path);
1355             cur_mon->mon_cpu_path = NULL;
1356         }
1357     }
1358     if (!cur_mon->mon_cpu_path) {
1359         if (!first_cpu) {
1360             return NULL;
1361         }
1362         monitor_set_cpu(first_cpu->cpu_index);
1363         cpu = first_cpu;
1364     }
1365     if (synchronize) {
1366         cpu_synchronize_state(cpu);
1367     }
1368     return cpu;
1369 }
1370
1371 CPUState *mon_get_cpu(void)
1372 {
1373     return mon_get_cpu_sync(true);
1374 }
1375
1376 CPUArchState *mon_get_cpu_env(void)
1377 {
1378     CPUState *cs = mon_get_cpu();
1379
1380     return cs ? cs->env_ptr : NULL;
1381 }
1382
1383 int monitor_get_cpu_index(void)
1384 {
1385     CPUState *cs = mon_get_cpu_sync(false);
1386
1387     return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1388 }
1389
1390 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1391 {
1392     bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1393     CPUState *cs;
1394
1395     if (all_cpus) {
1396         CPU_FOREACH(cs) {
1397             monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1398             cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1399         }
1400     } else {
1401         cs = mon_get_cpu();
1402
1403         if (!cs) {
1404             monitor_printf(mon, "No CPU available\n");
1405             return;
1406         }
1407
1408         cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1409     }
1410 }
1411
1412 #ifdef CONFIG_TCG
1413 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1414 {
1415     if (!tcg_enabled()) {
1416         error_report("JIT information is only available with accel=tcg");
1417         return;
1418     }
1419
1420     dump_exec_info((FILE *)mon, monitor_fprintf);
1421     dump_drift_info((FILE *)mon, monitor_fprintf);
1422 }
1423
1424 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1425 {
1426     dump_opcount_info((FILE *)mon, monitor_fprintf);
1427 }
1428 #endif
1429
1430 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1431 {
1432     int i;
1433     const char *str;
1434
1435     if (!mon->rs)
1436         return;
1437     i = 0;
1438     for(;;) {
1439         str = readline_get_history(mon->rs, i);
1440         if (!str)
1441             break;
1442         monitor_printf(mon, "%d: '%s'\n", i, str);
1443         i++;
1444     }
1445 }
1446
1447 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1448 {
1449     CPUState *cs = mon_get_cpu();
1450
1451     if (!cs) {
1452         monitor_printf(mon, "No CPU available\n");
1453         return;
1454     }
1455     cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1456 }
1457
1458 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1459 {
1460     const char *name = qdict_get_try_str(qdict, "name");
1461     bool has_vcpu = qdict_haskey(qdict, "vcpu");
1462     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1463     TraceEventInfoList *events;
1464     TraceEventInfoList *elem;
1465     Error *local_err = NULL;
1466
1467     if (name == NULL) {
1468         name = "*";
1469     }
1470     if (vcpu < 0) {
1471         monitor_printf(mon, "argument vcpu must be positive");
1472         return;
1473     }
1474
1475     events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1476     if (local_err) {
1477         error_report_err(local_err);
1478         return;
1479     }
1480
1481     for (elem = events; elem != NULL; elem = elem->next) {
1482         monitor_printf(mon, "%s : state %u\n",
1483                        elem->value->name,
1484                        elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1485     }
1486     qapi_free_TraceEventInfoList(events);
1487 }
1488
1489 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1490                              bool has_port, int64_t port,
1491                              bool has_tls_port, int64_t tls_port,
1492                              bool has_cert_subject, const char *cert_subject,
1493                              Error **errp)
1494 {
1495     if (strcmp(protocol, "spice") == 0) {
1496         if (!qemu_using_spice(errp)) {
1497             return;
1498         }
1499
1500         if (!has_port && !has_tls_port) {
1501             error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1502             return;
1503         }
1504
1505         if (qemu_spice_migrate_info(hostname,
1506                                     has_port ? port : -1,
1507                                     has_tls_port ? tls_port : -1,
1508                                     cert_subject)) {
1509             error_setg(errp, QERR_UNDEFINED_ERROR);
1510             return;
1511         }
1512         return;
1513     }
1514
1515     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1516 }
1517
1518 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1519 {
1520     Error *err = NULL;
1521
1522     qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1523     if (err) {
1524         error_report_err(err);
1525     }
1526 }
1527
1528 static void hmp_log(Monitor *mon, const QDict *qdict)
1529 {
1530     int mask;
1531     const char *items = qdict_get_str(qdict, "items");
1532
1533     if (!strcmp(items, "none")) {
1534         mask = 0;
1535     } else {
1536         mask = qemu_str_to_log_mask(items);
1537         if (!mask) {
1538             help_cmd(mon, "log");
1539             return;
1540         }
1541     }
1542     qemu_set_log(mask);
1543 }
1544
1545 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1546 {
1547     const char *option = qdict_get_try_str(qdict, "option");
1548     if (!option || !strcmp(option, "on")) {
1549         singlestep = 1;
1550     } else if (!strcmp(option, "off")) {
1551         singlestep = 0;
1552     } else {
1553         monitor_printf(mon, "unexpected option %s\n", option);
1554     }
1555 }
1556
1557 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1558 {
1559     const char *device = qdict_get_try_str(qdict, "device");
1560     if (!device)
1561         device = "tcp::" DEFAULT_GDBSTUB_PORT;
1562     if (gdbserver_start(device) < 0) {
1563         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1564                        device);
1565     } else if (strcmp(device, "none") == 0) {
1566         monitor_printf(mon, "Disabled gdbserver\n");
1567     } else {
1568         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1569                        device);
1570     }
1571 }
1572
1573 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1574 {
1575     const char *action = qdict_get_str(qdict, "action");
1576     if (select_watchdog_action(action) == -1) {
1577         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1578     }
1579 }
1580
1581 static void monitor_printc(Monitor *mon, int c)
1582 {
1583     monitor_printf(mon, "'");
1584     switch(c) {
1585     case '\'':
1586         monitor_printf(mon, "\\'");
1587         break;
1588     case '\\':
1589         monitor_printf(mon, "\\\\");
1590         break;
1591     case '\n':
1592         monitor_printf(mon, "\\n");
1593         break;
1594     case '\r':
1595         monitor_printf(mon, "\\r");
1596         break;
1597     default:
1598         if (c >= 32 && c <= 126) {
1599             monitor_printf(mon, "%c", c);
1600         } else {
1601             monitor_printf(mon, "\\x%02x", c);
1602         }
1603         break;
1604     }
1605     monitor_printf(mon, "'");
1606 }
1607
1608 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1609                         hwaddr addr, int is_physical)
1610 {
1611     int l, line_size, i, max_digits, len;
1612     uint8_t buf[16];
1613     uint64_t v;
1614     CPUState *cs = mon_get_cpu();
1615
1616     if (!cs && (format == 'i' || !is_physical)) {
1617         monitor_printf(mon, "Can not dump without CPU\n");
1618         return;
1619     }
1620
1621     if (format == 'i') {
1622         monitor_disas(mon, cs, addr, count, is_physical);
1623         return;
1624     }
1625
1626     len = wsize * count;
1627     if (wsize == 1)
1628         line_size = 8;
1629     else
1630         line_size = 16;
1631     max_digits = 0;
1632
1633     switch(format) {
1634     case 'o':
1635         max_digits = DIV_ROUND_UP(wsize * 8, 3);
1636         break;
1637     default:
1638     case 'x':
1639         max_digits = (wsize * 8) / 4;
1640         break;
1641     case 'u':
1642     case 'd':
1643         max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1644         break;
1645     case 'c':
1646         wsize = 1;
1647         break;
1648     }
1649
1650     while (len > 0) {
1651         if (is_physical)
1652             monitor_printf(mon, TARGET_FMT_plx ":", addr);
1653         else
1654             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1655         l = len;
1656         if (l > line_size)
1657             l = line_size;
1658         if (is_physical) {
1659             cpu_physical_memory_read(addr, buf, l);
1660         } else {
1661             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1662                 monitor_printf(mon, " Cannot access memory\n");
1663                 break;
1664             }
1665         }
1666         i = 0;
1667         while (i < l) {
1668             switch(wsize) {
1669             default:
1670             case 1:
1671                 v = ldub_p(buf + i);
1672                 break;
1673             case 2:
1674                 v = lduw_p(buf + i);
1675                 break;
1676             case 4:
1677                 v = (uint32_t)ldl_p(buf + i);
1678                 break;
1679             case 8:
1680                 v = ldq_p(buf + i);
1681                 break;
1682             }
1683             monitor_printf(mon, " ");
1684             switch(format) {
1685             case 'o':
1686                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1687                 break;
1688             case 'x':
1689                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1690                 break;
1691             case 'u':
1692                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1693                 break;
1694             case 'd':
1695                 monitor_printf(mon, "%*" PRId64, max_digits, v);
1696                 break;
1697             case 'c':
1698                 monitor_printc(mon, v);
1699                 break;
1700             }
1701             i += wsize;
1702         }
1703         monitor_printf(mon, "\n");
1704         addr += l;
1705         len -= l;
1706     }
1707 }
1708
1709 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1710 {
1711     int count = qdict_get_int(qdict, "count");
1712     int format = qdict_get_int(qdict, "format");
1713     int size = qdict_get_int(qdict, "size");
1714     target_long addr = qdict_get_int(qdict, "addr");
1715
1716     memory_dump(mon, count, format, size, addr, 0);
1717 }
1718
1719 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1720 {
1721     int count = qdict_get_int(qdict, "count");
1722     int format = qdict_get_int(qdict, "format");
1723     int size = qdict_get_int(qdict, "size");
1724     hwaddr addr = qdict_get_int(qdict, "addr");
1725
1726     memory_dump(mon, count, format, size, addr, 1);
1727 }
1728
1729 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1730 {
1731     MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1732                                                  addr, 1);
1733
1734     if (!mrs.mr) {
1735         error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1736         return NULL;
1737     }
1738
1739     if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1740         error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1741         memory_region_unref(mrs.mr);
1742         return NULL;
1743     }
1744
1745     *p_mr = mrs.mr;
1746     return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1747 }
1748
1749 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1750 {
1751     hwaddr addr = qdict_get_int(qdict, "addr");
1752     Error *local_err = NULL;
1753     MemoryRegion *mr = NULL;
1754     void *ptr;
1755
1756     ptr = gpa2hva(&mr, addr, &local_err);
1757     if (local_err) {
1758         error_report_err(local_err);
1759         return;
1760     }
1761
1762     monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1763                    " (%s) is %p\n",
1764                    addr, mr->name, ptr);
1765
1766     memory_region_unref(mr);
1767 }
1768
1769 #ifdef CONFIG_LINUX
1770 static uint64_t vtop(void *ptr, Error **errp)
1771 {
1772     uint64_t pinfo;
1773     uint64_t ret = -1;
1774     uintptr_t addr = (uintptr_t) ptr;
1775     uintptr_t pagesize = getpagesize();
1776     off_t offset = addr / pagesize * sizeof(pinfo);
1777     int fd;
1778
1779     fd = open("/proc/self/pagemap", O_RDONLY);
1780     if (fd == -1) {
1781         error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1782         return -1;
1783     }
1784
1785     /* Force copy-on-write if necessary.  */
1786     atomic_add((uint8_t *)ptr, 0);
1787
1788     if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1789         error_setg_errno(errp, errno, "Cannot read pagemap");
1790         goto out;
1791     }
1792     if ((pinfo & (1ull << 63)) == 0) {
1793         error_setg(errp, "Page not present");
1794         goto out;
1795     }
1796     ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1797
1798 out:
1799     close(fd);
1800     return ret;
1801 }
1802
1803 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1804 {
1805     hwaddr addr = qdict_get_int(qdict, "addr");
1806     Error *local_err = NULL;
1807     MemoryRegion *mr = NULL;
1808     void *ptr;
1809     uint64_t physaddr;
1810
1811     ptr = gpa2hva(&mr, addr, &local_err);
1812     if (local_err) {
1813         error_report_err(local_err);
1814         return;
1815     }
1816
1817     physaddr = vtop(ptr, &local_err);
1818     if (local_err) {
1819         error_report_err(local_err);
1820     } else {
1821         monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1822                        " (%s) is 0x%" PRIx64 "\n",
1823                        addr, mr->name, (uint64_t) physaddr);
1824     }
1825
1826     memory_region_unref(mr);
1827 }
1828 #endif
1829
1830 static void do_print(Monitor *mon, const QDict *qdict)
1831 {
1832     int format = qdict_get_int(qdict, "format");
1833     hwaddr val = qdict_get_int(qdict, "val");
1834
1835     switch(format) {
1836     case 'o':
1837         monitor_printf(mon, "%#" HWADDR_PRIo, val);
1838         break;
1839     case 'x':
1840         monitor_printf(mon, "%#" HWADDR_PRIx, val);
1841         break;
1842     case 'u':
1843         monitor_printf(mon, "%" HWADDR_PRIu, val);
1844         break;
1845     default:
1846     case 'd':
1847         monitor_printf(mon, "%" HWADDR_PRId, val);
1848         break;
1849     case 'c':
1850         monitor_printc(mon, val);
1851         break;
1852     }
1853     monitor_printf(mon, "\n");
1854 }
1855
1856 static void hmp_sum(Monitor *mon, const QDict *qdict)
1857 {
1858     uint32_t addr;
1859     uint16_t sum;
1860     uint32_t start = qdict_get_int(qdict, "start");
1861     uint32_t size = qdict_get_int(qdict, "size");
1862
1863     sum = 0;
1864     for(addr = start; addr < (start + size); addr++) {
1865         uint8_t val = address_space_ldub(&address_space_memory, addr,
1866                                          MEMTXATTRS_UNSPECIFIED, NULL);
1867         /* BSD sum algorithm ('sum' Unix command) */
1868         sum = (sum >> 1) | (sum << 15);
1869         sum += val;
1870     }
1871     monitor_printf(mon, "%05d\n", sum);
1872 }
1873
1874 static int mouse_button_state;
1875
1876 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1877 {
1878     int dx, dy, dz, button;
1879     const char *dx_str = qdict_get_str(qdict, "dx_str");
1880     const char *dy_str = qdict_get_str(qdict, "dy_str");
1881     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1882
1883     dx = strtol(dx_str, NULL, 0);
1884     dy = strtol(dy_str, NULL, 0);
1885     qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1886     qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1887
1888     if (dz_str) {
1889         dz = strtol(dz_str, NULL, 0);
1890         if (dz != 0) {
1891             button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1892             qemu_input_queue_btn(NULL, button, true);
1893             qemu_input_event_sync();
1894             qemu_input_queue_btn(NULL, button, false);
1895         }
1896     }
1897     qemu_input_event_sync();
1898 }
1899
1900 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1901 {
1902     static uint32_t bmap[INPUT_BUTTON__MAX] = {
1903         [INPUT_BUTTON_LEFT]       = MOUSE_EVENT_LBUTTON,
1904         [INPUT_BUTTON_MIDDLE]     = MOUSE_EVENT_MBUTTON,
1905         [INPUT_BUTTON_RIGHT]      = MOUSE_EVENT_RBUTTON,
1906     };
1907     int button_state = qdict_get_int(qdict, "button_state");
1908
1909     if (mouse_button_state == button_state) {
1910         return;
1911     }
1912     qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1913     qemu_input_event_sync();
1914     mouse_button_state = button_state;
1915 }
1916
1917 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1918 {
1919     int size = qdict_get_int(qdict, "size");
1920     int addr = qdict_get_int(qdict, "addr");
1921     int has_index = qdict_haskey(qdict, "index");
1922     uint32_t val;
1923     int suffix;
1924
1925     if (has_index) {
1926         int index = qdict_get_int(qdict, "index");
1927         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1928         addr++;
1929     }
1930     addr &= 0xffff;
1931
1932     switch(size) {
1933     default:
1934     case 1:
1935         val = cpu_inb(addr);
1936         suffix = 'b';
1937         break;
1938     case 2:
1939         val = cpu_inw(addr);
1940         suffix = 'w';
1941         break;
1942     case 4:
1943         val = cpu_inl(addr);
1944         suffix = 'l';
1945         break;
1946     }
1947     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1948                    suffix, addr, size * 2, val);
1949 }
1950
1951 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1952 {
1953     int size = qdict_get_int(qdict, "size");
1954     int addr = qdict_get_int(qdict, "addr");
1955     int val = qdict_get_int(qdict, "val");
1956
1957     addr &= IOPORTS_MASK;
1958
1959     switch (size) {
1960     default:
1961     case 1:
1962         cpu_outb(addr, val);
1963         break;
1964     case 2:
1965         cpu_outw(addr, val);
1966         break;
1967     case 4:
1968         cpu_outl(addr, val);
1969         break;
1970     }
1971 }
1972
1973 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1974 {
1975     Error *local_err = NULL;
1976     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1977
1978     qemu_boot_set(bootdevice, &local_err);
1979     if (local_err) {
1980         error_report_err(local_err);
1981     } else {
1982         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1983     }
1984 }
1985
1986 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1987 {
1988     bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1989     bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1990
1991     mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
1992 }
1993
1994 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1995 {
1996     int i;
1997     NumaNodeMem *node_mem;
1998     CpuInfoList *cpu_list, *cpu;
1999
2000     cpu_list = qmp_query_cpus(&error_abort);
2001     node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
2002
2003     query_numa_node_mem(node_mem);
2004     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2005     for (i = 0; i < nb_numa_nodes; i++) {
2006         monitor_printf(mon, "node %d cpus:", i);
2007         for (cpu = cpu_list; cpu; cpu = cpu->next) {
2008             if (cpu->value->has_props && cpu->value->props->has_node_id &&
2009                 cpu->value->props->node_id == i) {
2010                 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
2011             }
2012         }
2013         monitor_printf(mon, "\n");
2014         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2015                        node_mem[i].node_mem >> 20);
2016         monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
2017                        node_mem[i].node_plugged_mem >> 20);
2018     }
2019     qapi_free_CpuInfoList(cpu_list);
2020     g_free(node_mem);
2021 }
2022
2023 #ifdef CONFIG_PROFILER
2024
2025 int64_t tcg_time;
2026 int64_t dev_time;
2027
2028 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2029 {
2030     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
2031                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
2032     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
2033                    tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
2034     tcg_time = 0;
2035     dev_time = 0;
2036 }
2037 #else
2038 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2039 {
2040     monitor_printf(mon, "Internal profiler not compiled\n");
2041 }
2042 #endif
2043
2044 /* Capture support */
2045 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2046
2047 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2048 {
2049     int i;
2050     CaptureState *s;
2051
2052     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2053         monitor_printf(mon, "[%d]: ", i);
2054         s->ops.info (s->opaque);
2055     }
2056 }
2057
2058 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2059 {
2060     int i;
2061     int n = qdict_get_int(qdict, "n");
2062     CaptureState *s;
2063
2064     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2065         if (i == n) {
2066             s->ops.destroy (s->opaque);
2067             QLIST_REMOVE (s, entries);
2068             g_free (s);
2069             return;
2070         }
2071     }
2072 }
2073
2074 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2075 {
2076     const char *path = qdict_get_str(qdict, "path");
2077     int has_freq = qdict_haskey(qdict, "freq");
2078     int freq = qdict_get_try_int(qdict, "freq", -1);
2079     int has_bits = qdict_haskey(qdict, "bits");
2080     int bits = qdict_get_try_int(qdict, "bits", -1);
2081     int has_channels = qdict_haskey(qdict, "nchannels");
2082     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2083     CaptureState *s;
2084
2085     s = g_malloc0 (sizeof (*s));
2086
2087     freq = has_freq ? freq : 44100;
2088     bits = has_bits ? bits : 16;
2089     nchannels = has_channels ? nchannels : 2;
2090
2091     if (wav_start_capture (s, path, freq, bits, nchannels)) {
2092         monitor_printf(mon, "Failed to add wave capture\n");
2093         g_free (s);
2094         return;
2095     }
2096     QLIST_INSERT_HEAD (&capture_head, s, entries);
2097 }
2098
2099 static qemu_acl *find_acl(Monitor *mon, const char *name)
2100 {
2101     qemu_acl *acl = qemu_acl_find(name);
2102
2103     if (!acl) {
2104         monitor_printf(mon, "acl: unknown list '%s'\n", name);
2105     }
2106     return acl;
2107 }
2108
2109 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2110 {
2111     const char *aclname = qdict_get_str(qdict, "aclname");
2112     qemu_acl *acl = find_acl(mon, aclname);
2113     qemu_acl_entry *entry;
2114     int i = 0;
2115
2116     if (acl) {
2117         monitor_printf(mon, "policy: %s\n",
2118                        acl->defaultDeny ? "deny" : "allow");
2119         QTAILQ_FOREACH(entry, &acl->entries, next) {
2120             i++;
2121             monitor_printf(mon, "%d: %s %s\n", i,
2122                            entry->deny ? "deny" : "allow", entry->match);
2123         }
2124     }
2125 }
2126
2127 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2128 {
2129     const char *aclname = qdict_get_str(qdict, "aclname");
2130     qemu_acl *acl = find_acl(mon, aclname);
2131
2132     if (acl) {
2133         qemu_acl_reset(acl);
2134         monitor_printf(mon, "acl: removed all rules\n");
2135     }
2136 }
2137
2138 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2139 {
2140     const char *aclname = qdict_get_str(qdict, "aclname");
2141     const char *policy = qdict_get_str(qdict, "policy");
2142     qemu_acl *acl = find_acl(mon, aclname);
2143
2144     if (acl) {
2145         if (strcmp(policy, "allow") == 0) {
2146             acl->defaultDeny = 0;
2147             monitor_printf(mon, "acl: policy set to 'allow'\n");
2148         } else if (strcmp(policy, "deny") == 0) {
2149             acl->defaultDeny = 1;
2150             monitor_printf(mon, "acl: policy set to 'deny'\n");
2151         } else {
2152             monitor_printf(mon, "acl: unknown policy '%s', "
2153                            "expected 'deny' or 'allow'\n", policy);
2154         }
2155     }
2156 }
2157
2158 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2159 {
2160     const char *aclname = qdict_get_str(qdict, "aclname");
2161     const char *match = qdict_get_str(qdict, "match");
2162     const char *policy = qdict_get_str(qdict, "policy");
2163     int has_index = qdict_haskey(qdict, "index");
2164     int index = qdict_get_try_int(qdict, "index", -1);
2165     qemu_acl *acl = find_acl(mon, aclname);
2166     int deny, ret;
2167
2168     if (acl) {
2169         if (strcmp(policy, "allow") == 0) {
2170             deny = 0;
2171         } else if (strcmp(policy, "deny") == 0) {
2172             deny = 1;
2173         } else {
2174             monitor_printf(mon, "acl: unknown policy '%s', "
2175                            "expected 'deny' or 'allow'\n", policy);
2176             return;
2177         }
2178         if (has_index)
2179             ret = qemu_acl_insert(acl, deny, match, index);
2180         else
2181             ret = qemu_acl_append(acl, deny, match);
2182         if (ret < 0)
2183             monitor_printf(mon, "acl: unable to add acl entry\n");
2184         else
2185             monitor_printf(mon, "acl: added rule at position %d\n", ret);
2186     }
2187 }
2188
2189 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2190 {
2191     const char *aclname = qdict_get_str(qdict, "aclname");
2192     const char *match = qdict_get_str(qdict, "match");
2193     qemu_acl *acl = find_acl(mon, aclname);
2194     int ret;
2195
2196     if (acl) {
2197         ret = qemu_acl_remove(acl, match);
2198         if (ret < 0)
2199             monitor_printf(mon, "acl: no matching acl entry\n");
2200         else
2201             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2202     }
2203 }
2204
2205 void qmp_getfd(const char *fdname, Error **errp)
2206 {
2207     mon_fd_t *monfd;
2208     int fd, tmp_fd;
2209
2210     fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2211     if (fd == -1) {
2212         error_setg(errp, QERR_FD_NOT_SUPPLIED);
2213         return;
2214     }
2215
2216     if (qemu_isdigit(fdname[0])) {
2217         close(fd);
2218         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2219                    "a name not starting with a digit");
2220         return;
2221     }
2222
2223     qemu_mutex_lock(&cur_mon->mon_lock);
2224     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2225         if (strcmp(monfd->name, fdname) != 0) {
2226             continue;
2227         }
2228
2229         tmp_fd = monfd->fd;
2230         monfd->fd = fd;
2231         qemu_mutex_unlock(&cur_mon->mon_lock);
2232         /* Make sure close() is out of critical section */
2233         close(tmp_fd);
2234         return;
2235     }
2236
2237     monfd = g_malloc0(sizeof(mon_fd_t));
2238     monfd->name = g_strdup(fdname);
2239     monfd->fd = fd;
2240
2241     QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2242     qemu_mutex_unlock(&cur_mon->mon_lock);
2243 }
2244
2245 void qmp_closefd(const char *fdname, Error **errp)
2246 {
2247     mon_fd_t *monfd;
2248     int tmp_fd;
2249
2250     qemu_mutex_lock(&cur_mon->mon_lock);
2251     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2252         if (strcmp(monfd->name, fdname) != 0) {
2253             continue;
2254         }
2255
2256         QLIST_REMOVE(monfd, next);
2257         tmp_fd = monfd->fd;
2258         g_free(monfd->name);
2259         g_free(monfd);
2260         qemu_mutex_unlock(&cur_mon->mon_lock);
2261         /* Make sure close() is out of critical section */
2262         close(tmp_fd);
2263         return;
2264     }
2265
2266     qemu_mutex_unlock(&cur_mon->mon_lock);
2267     error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2268 }
2269
2270 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2271 {
2272     mon_fd_t *monfd;
2273
2274     qemu_mutex_lock(&mon->mon_lock);
2275     QLIST_FOREACH(monfd, &mon->fds, next) {
2276         int fd;
2277
2278         if (strcmp(monfd->name, fdname) != 0) {
2279             continue;
2280         }
2281
2282         fd = monfd->fd;
2283
2284         /* caller takes ownership of fd */
2285         QLIST_REMOVE(monfd, next);
2286         g_free(monfd->name);
2287         g_free(monfd);
2288         qemu_mutex_unlock(&mon->mon_lock);
2289
2290         return fd;
2291     }
2292
2293     qemu_mutex_unlock(&mon->mon_lock);
2294     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2295     return -1;
2296 }
2297
2298 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2299 {
2300     MonFdsetFd *mon_fdset_fd;
2301     MonFdsetFd *mon_fdset_fd_next;
2302
2303     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2304         if ((mon_fdset_fd->removed ||
2305                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2306                 runstate_is_running()) {
2307             close(mon_fdset_fd->fd);
2308             g_free(mon_fdset_fd->opaque);
2309             QLIST_REMOVE(mon_fdset_fd, next);
2310             g_free(mon_fdset_fd);
2311         }
2312     }
2313
2314     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2315         QLIST_REMOVE(mon_fdset, next);
2316         g_free(mon_fdset);
2317     }
2318 }
2319
2320 static void monitor_fdsets_cleanup(void)
2321 {
2322     MonFdset *mon_fdset;
2323     MonFdset *mon_fdset_next;
2324
2325     qemu_mutex_lock(&mon_fdsets_lock);
2326     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2327         monitor_fdset_cleanup(mon_fdset);
2328     }
2329     qemu_mutex_unlock(&mon_fdsets_lock);
2330 }
2331
2332 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2333                       const char *opaque, Error **errp)
2334 {
2335     int fd;
2336     Monitor *mon = cur_mon;
2337     AddfdInfo *fdinfo;
2338
2339     fd = qemu_chr_fe_get_msgfd(&mon->chr);
2340     if (fd == -1) {
2341         error_setg(errp, QERR_FD_NOT_SUPPLIED);
2342         goto error;
2343     }
2344
2345     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2346                                   has_opaque, opaque, errp);
2347     if (fdinfo) {
2348         return fdinfo;
2349     }
2350
2351 error:
2352     if (fd != -1) {
2353         close(fd);
2354     }
2355     return NULL;
2356 }
2357
2358 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2359 {
2360     MonFdset *mon_fdset;
2361     MonFdsetFd *mon_fdset_fd;
2362     char fd_str[60];
2363
2364     qemu_mutex_lock(&mon_fdsets_lock);
2365     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2366         if (mon_fdset->id != fdset_id) {
2367             continue;
2368         }
2369         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2370             if (has_fd) {
2371                 if (mon_fdset_fd->fd != fd) {
2372                     continue;
2373                 }
2374                 mon_fdset_fd->removed = true;
2375                 break;
2376             } else {
2377                 mon_fdset_fd->removed = true;
2378             }
2379         }
2380         if (has_fd && !mon_fdset_fd) {
2381             goto error;
2382         }
2383         monitor_fdset_cleanup(mon_fdset);
2384         qemu_mutex_unlock(&mon_fdsets_lock);
2385         return;
2386     }
2387
2388 error:
2389     qemu_mutex_unlock(&mon_fdsets_lock);
2390     if (has_fd) {
2391         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2392                  fdset_id, fd);
2393     } else {
2394         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2395     }
2396     error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2397 }
2398
2399 FdsetInfoList *qmp_query_fdsets(Error **errp)
2400 {
2401     MonFdset *mon_fdset;
2402     MonFdsetFd *mon_fdset_fd;
2403     FdsetInfoList *fdset_list = NULL;
2404
2405     qemu_mutex_lock(&mon_fdsets_lock);
2406     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2407         FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2408         FdsetFdInfoList *fdsetfd_list = NULL;
2409
2410         fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2411         fdset_info->value->fdset_id = mon_fdset->id;
2412
2413         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2414             FdsetFdInfoList *fdsetfd_info;
2415
2416             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2417             fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2418             fdsetfd_info->value->fd = mon_fdset_fd->fd;
2419             if (mon_fdset_fd->opaque) {
2420                 fdsetfd_info->value->has_opaque = true;
2421                 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2422             } else {
2423                 fdsetfd_info->value->has_opaque = false;
2424             }
2425
2426             fdsetfd_info->next = fdsetfd_list;
2427             fdsetfd_list = fdsetfd_info;
2428         }
2429
2430         fdset_info->value->fds = fdsetfd_list;
2431
2432         fdset_info->next = fdset_list;
2433         fdset_list = fdset_info;
2434     }
2435     qemu_mutex_unlock(&mon_fdsets_lock);
2436
2437     return fdset_list;
2438 }
2439
2440 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2441                                 bool has_opaque, const char *opaque,
2442                                 Error **errp)
2443 {
2444     MonFdset *mon_fdset = NULL;
2445     MonFdsetFd *mon_fdset_fd;
2446     AddfdInfo *fdinfo;
2447
2448     qemu_mutex_lock(&mon_fdsets_lock);
2449     if (has_fdset_id) {
2450         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2451             /* Break if match found or match impossible due to ordering by ID */
2452             if (fdset_id <= mon_fdset->id) {
2453                 if (fdset_id < mon_fdset->id) {
2454                     mon_fdset = NULL;
2455                 }
2456                 break;
2457             }
2458         }
2459     }
2460
2461     if (mon_fdset == NULL) {
2462         int64_t fdset_id_prev = -1;
2463         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2464
2465         if (has_fdset_id) {
2466             if (fdset_id < 0) {
2467                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2468                            "a non-negative value");
2469                 qemu_mutex_unlock(&mon_fdsets_lock);
2470                 return NULL;
2471             }
2472             /* Use specified fdset ID */
2473             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2474                 mon_fdset_cur = mon_fdset;
2475                 if (fdset_id < mon_fdset_cur->id) {
2476                     break;
2477                 }
2478             }
2479         } else {
2480             /* Use first available fdset ID */
2481             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2482                 mon_fdset_cur = mon_fdset;
2483                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2484                     fdset_id_prev = mon_fdset_cur->id;
2485                     continue;
2486                 }
2487                 break;
2488             }
2489         }
2490
2491         mon_fdset = g_malloc0(sizeof(*mon_fdset));
2492         if (has_fdset_id) {
2493             mon_fdset->id = fdset_id;
2494         } else {
2495             mon_fdset->id = fdset_id_prev + 1;
2496         }
2497
2498         /* The fdset list is ordered by fdset ID */
2499         if (!mon_fdset_cur) {
2500             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2501         } else if (mon_fdset->id < mon_fdset_cur->id) {
2502             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2503         } else {
2504             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2505         }
2506     }
2507
2508     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2509     mon_fdset_fd->fd = fd;
2510     mon_fdset_fd->removed = false;
2511     if (has_opaque) {
2512         mon_fdset_fd->opaque = g_strdup(opaque);
2513     }
2514     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2515
2516     fdinfo = g_malloc0(sizeof(*fdinfo));
2517     fdinfo->fdset_id = mon_fdset->id;
2518     fdinfo->fd = mon_fdset_fd->fd;
2519
2520     qemu_mutex_unlock(&mon_fdsets_lock);
2521     return fdinfo;
2522 }
2523
2524 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2525 {
2526 #ifdef _WIN32
2527     return -ENOENT;
2528 #else
2529     MonFdset *mon_fdset;
2530     MonFdsetFd *mon_fdset_fd;
2531     int mon_fd_flags;
2532     int ret;
2533
2534     qemu_mutex_lock(&mon_fdsets_lock);
2535     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2536         if (mon_fdset->id != fdset_id) {
2537             continue;
2538         }
2539         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2540             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2541             if (mon_fd_flags == -1) {
2542                 ret = -errno;
2543                 goto out;
2544             }
2545
2546             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2547                 ret = mon_fdset_fd->fd;
2548                 goto out;
2549             }
2550         }
2551         ret = -EACCES;
2552         goto out;
2553     }
2554     ret = -ENOENT;
2555
2556 out:
2557     qemu_mutex_unlock(&mon_fdsets_lock);
2558     return ret;
2559 #endif
2560 }
2561
2562 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2563 {
2564     MonFdset *mon_fdset;
2565     MonFdsetFd *mon_fdset_fd_dup;
2566
2567     qemu_mutex_lock(&mon_fdsets_lock);
2568     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2569         if (mon_fdset->id != fdset_id) {
2570             continue;
2571         }
2572         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2573             if (mon_fdset_fd_dup->fd == dup_fd) {
2574                 goto err;
2575             }
2576         }
2577         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2578         mon_fdset_fd_dup->fd = dup_fd;
2579         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2580         qemu_mutex_unlock(&mon_fdsets_lock);
2581         return 0;
2582     }
2583
2584 err:
2585     qemu_mutex_unlock(&mon_fdsets_lock);
2586     return -1;
2587 }
2588
2589 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2590 {
2591     MonFdset *mon_fdset;
2592     MonFdsetFd *mon_fdset_fd_dup;
2593
2594     qemu_mutex_lock(&mon_fdsets_lock);
2595     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2596         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2597             if (mon_fdset_fd_dup->fd == dup_fd) {
2598                 if (remove) {
2599                     QLIST_REMOVE(mon_fdset_fd_dup, next);
2600                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2601                         monitor_fdset_cleanup(mon_fdset);
2602                     }
2603                     goto err;
2604                 } else {
2605                     qemu_mutex_unlock(&mon_fdsets_lock);
2606                     return mon_fdset->id;
2607                 }
2608             }
2609         }
2610     }
2611
2612 err:
2613     qemu_mutex_unlock(&mon_fdsets_lock);
2614     return -1;
2615 }
2616
2617 int monitor_fdset_dup_fd_find(int dup_fd)
2618 {
2619     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2620 }
2621
2622 void monitor_fdset_dup_fd_remove(int dup_fd)
2623 {
2624     monitor_fdset_dup_fd_find_remove(dup_fd, true);
2625 }
2626
2627 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2628 {
2629     int fd;
2630     Error *local_err = NULL;
2631
2632     if (!qemu_isdigit(fdname[0]) && mon) {
2633         fd = monitor_get_fd(mon, fdname, &local_err);
2634     } else {
2635         fd = qemu_parse_fd(fdname);
2636         if (fd == -1) {
2637             error_setg(&local_err, "Invalid file descriptor number '%s'",
2638                        fdname);
2639         }
2640     }
2641     if (local_err) {
2642         error_propagate(errp, local_err);
2643         assert(fd == -1);
2644     } else {
2645         assert(fd != -1);
2646     }
2647
2648     return fd;
2649 }
2650
2651 /* Please update hmp-commands.hx when adding or changing commands */
2652 static mon_cmd_t info_cmds[] = {
2653 #include "hmp-commands-info.h"
2654     { NULL, NULL, },
2655 };
2656
2657 /* mon_cmds and info_cmds would be sorted at runtime */
2658 static mon_cmd_t mon_cmds[] = {
2659 #include "hmp-commands.h"
2660     { NULL, NULL, },
2661 };
2662
2663 /*******************************************************************/
2664
2665 static const char *pch;
2666 static sigjmp_buf expr_env;
2667
2668
2669 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2670 expr_error(Monitor *mon, const char *fmt, ...)
2671 {
2672     va_list ap;
2673     va_start(ap, fmt);
2674     monitor_vprintf(mon, fmt, ap);
2675     monitor_printf(mon, "\n");
2676     va_end(ap);
2677     siglongjmp(expr_env, 1);
2678 }
2679
2680 /* return 0 if OK, -1 if not found */
2681 static int get_monitor_def(target_long *pval, const char *name)
2682 {
2683     const MonitorDef *md = target_monitor_defs();
2684     CPUState *cs = mon_get_cpu();
2685     void *ptr;
2686     uint64_t tmp = 0;
2687     int ret;
2688
2689     if (cs == NULL || md == NULL) {
2690         return -1;
2691     }
2692
2693     for(; md->name != NULL; md++) {
2694         if (compare_cmd(name, md->name)) {
2695             if (md->get_value) {
2696                 *pval = md->get_value(md, md->offset);
2697             } else {
2698                 CPUArchState *env = mon_get_cpu_env();
2699                 ptr = (uint8_t *)env + md->offset;
2700                 switch(md->type) {
2701                 case MD_I32:
2702                     *pval = *(int32_t *)ptr;
2703                     break;
2704                 case MD_TLONG:
2705                     *pval = *(target_long *)ptr;
2706                     break;
2707                 default:
2708                     *pval = 0;
2709                     break;
2710                 }
2711             }
2712             return 0;
2713         }
2714     }
2715
2716     ret = target_get_monitor_def(cs, name, &tmp);
2717     if (!ret) {
2718         *pval = (target_long) tmp;
2719     }
2720
2721     return ret;
2722 }
2723
2724 static void next(void)
2725 {
2726     if (*pch != '\0') {
2727         pch++;
2728         while (qemu_isspace(*pch))
2729             pch++;
2730     }
2731 }
2732
2733 static int64_t expr_sum(Monitor *mon);
2734
2735 static int64_t expr_unary(Monitor *mon)
2736 {
2737     int64_t n;
2738     char *p;
2739     int ret;
2740
2741     switch(*pch) {
2742     case '+':
2743         next();
2744         n = expr_unary(mon);
2745         break;
2746     case '-':
2747         next();
2748         n = -expr_unary(mon);
2749         break;
2750     case '~':
2751         next();
2752         n = ~expr_unary(mon);
2753         break;
2754     case '(':
2755         next();
2756         n = expr_sum(mon);
2757         if (*pch != ')') {
2758             expr_error(mon, "')' expected");
2759         }
2760         next();
2761         break;
2762     case '\'':
2763         pch++;
2764         if (*pch == '\0')
2765             expr_error(mon, "character constant expected");
2766         n = *pch;
2767         pch++;
2768         if (*pch != '\'')
2769             expr_error(mon, "missing terminating \' character");
2770         next();
2771         break;
2772     case '$':
2773         {
2774             char buf[128], *q;
2775             target_long reg=0;
2776
2777             pch++;
2778             q = buf;
2779             while ((*pch >= 'a' && *pch <= 'z') ||
2780                    (*pch >= 'A' && *pch <= 'Z') ||
2781                    (*pch >= '0' && *pch <= '9') ||
2782                    *pch == '_' || *pch == '.') {
2783                 if ((q - buf) < sizeof(buf) - 1)
2784                     *q++ = *pch;
2785                 pch++;
2786             }
2787             while (qemu_isspace(*pch))
2788                 pch++;
2789             *q = 0;
2790             ret = get_monitor_def(&reg, buf);
2791             if (ret < 0)
2792                 expr_error(mon, "unknown register");
2793             n = reg;
2794         }
2795         break;
2796     case '\0':
2797         expr_error(mon, "unexpected end of expression");
2798         n = 0;
2799         break;
2800     default:
2801         errno = 0;
2802         n = strtoull(pch, &p, 0);
2803         if (errno == ERANGE) {
2804             expr_error(mon, "number too large");
2805         }
2806         if (pch == p) {
2807             expr_error(mon, "invalid char '%c' in expression", *p);
2808         }
2809         pch = p;
2810         while (qemu_isspace(*pch))
2811             pch++;
2812         break;
2813     }
2814     return n;
2815 }
2816
2817
2818 static int64_t expr_prod(Monitor *mon)
2819 {
2820     int64_t val, val2;
2821     int op;
2822
2823     val = expr_unary(mon);
2824     for(;;) {
2825         op = *pch;
2826         if (op != '*' && op != '/' && op != '%')
2827             break;
2828         next();
2829         val2 = expr_unary(mon);
2830         switch(op) {
2831         default:
2832         case '*':
2833             val *= val2;
2834             break;
2835         case '/':
2836         case '%':
2837             if (val2 == 0)
2838                 expr_error(mon, "division by zero");
2839             if (op == '/')
2840                 val /= val2;
2841             else
2842                 val %= val2;
2843             break;
2844         }
2845     }
2846     return val;
2847 }
2848
2849 static int64_t expr_logic(Monitor *mon)
2850 {
2851     int64_t val, val2;
2852     int op;
2853
2854     val = expr_prod(mon);
2855     for(;;) {
2856         op = *pch;
2857         if (op != '&' && op != '|' && op != '^')
2858             break;
2859         next();
2860         val2 = expr_prod(mon);
2861         switch(op) {
2862         default:
2863         case '&':
2864             val &= val2;
2865             break;
2866         case '|':
2867             val |= val2;
2868             break;
2869         case '^':
2870             val ^= val2;
2871             break;
2872         }
2873     }
2874     return val;
2875 }
2876
2877 static int64_t expr_sum(Monitor *mon)
2878 {
2879     int64_t val, val2;
2880     int op;
2881
2882     val = expr_logic(mon);
2883     for(;;) {
2884         op = *pch;
2885         if (op != '+' && op != '-')
2886             break;
2887         next();
2888         val2 = expr_logic(mon);
2889         if (op == '+')
2890             val += val2;
2891         else
2892             val -= val2;
2893     }
2894     return val;
2895 }
2896
2897 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2898 {
2899     pch = *pp;
2900     if (sigsetjmp(expr_env, 0)) {
2901         *pp = pch;
2902         return -1;
2903     }
2904     while (qemu_isspace(*pch))
2905         pch++;
2906     *pval = expr_sum(mon);
2907     *pp = pch;
2908     return 0;
2909 }
2910
2911 static int get_double(Monitor *mon, double *pval, const char **pp)
2912 {
2913     const char *p = *pp;
2914     char *tailp;
2915     double d;
2916
2917     d = strtod(p, &tailp);
2918     if (tailp == p) {
2919         monitor_printf(mon, "Number expected\n");
2920         return -1;
2921     }
2922     if (d != d || d - d != 0) {
2923         /* NaN or infinity */
2924         monitor_printf(mon, "Bad number\n");
2925         return -1;
2926     }
2927     *pval = d;
2928     *pp = tailp;
2929     return 0;
2930 }
2931
2932 /*
2933  * Store the command-name in cmdname, and return a pointer to
2934  * the remaining of the command string.
2935  */
2936 static const char *get_command_name(const char *cmdline,
2937                                     char *cmdname, size_t nlen)
2938 {
2939     size_t len;
2940     const char *p, *pstart;
2941
2942     p = cmdline;
2943     while (qemu_isspace(*p))
2944         p++;
2945     if (*p == '\0')
2946         return NULL;
2947     pstart = p;
2948     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2949         p++;
2950     len = p - pstart;
2951     if (len > nlen - 1)
2952         len = nlen - 1;
2953     memcpy(cmdname, pstart, len);
2954     cmdname[len] = '\0';
2955     return p;
2956 }
2957
2958 /**
2959  * Read key of 'type' into 'key' and return the current
2960  * 'type' pointer.
2961  */
2962 static char *key_get_info(const char *type, char **key)
2963 {
2964     size_t len;
2965     char *p, *str;
2966
2967     if (*type == ',')
2968         type++;
2969
2970     p = strchr(type, ':');
2971     if (!p) {
2972         *key = NULL;
2973         return NULL;
2974     }
2975     len = p - type;
2976
2977     str = g_malloc(len + 1);
2978     memcpy(str, type, len);
2979     str[len] = '\0';
2980
2981     *key = str;
2982     return ++p;
2983 }
2984
2985 static int default_fmt_format = 'x';
2986 static int default_fmt_size = 4;
2987
2988 static int is_valid_option(const char *c, const char *typestr)
2989 {
2990     char option[3];
2991
2992     option[0] = '-';
2993     option[1] = *c;
2994     option[2] = '\0';
2995
2996     typestr = strstr(typestr, option);
2997     return (typestr != NULL);
2998 }
2999
3000 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3001                                               const char *cmdname)
3002 {
3003     const mon_cmd_t *cmd;
3004
3005     for (cmd = disp_table; cmd->name != NULL; cmd++) {
3006         if (compare_cmd(cmdname, cmd->name)) {
3007             return cmd;
3008         }
3009     }
3010
3011     return NULL;
3012 }
3013
3014 /*
3015  * Parse command name from @cmdp according to command table @table.
3016  * If blank, return NULL.
3017  * Else, if no valid command can be found, report to @mon, and return
3018  * NULL.
3019  * Else, change @cmdp to point right behind the name, and return its
3020  * command table entry.
3021  * Do not assume the return value points into @table!  It doesn't when
3022  * the command is found in a sub-command table.
3023  */
3024 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3025                                               const char *cmdp_start,
3026                                               const char **cmdp,
3027                                               mon_cmd_t *table)
3028 {
3029     const char *p;
3030     const mon_cmd_t *cmd;
3031     char cmdname[256];
3032
3033     /* extract the command name */
3034     p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
3035     if (!p)
3036         return NULL;
3037
3038     cmd = search_dispatch_table(table, cmdname);
3039     if (!cmd) {
3040         monitor_printf(mon, "unknown command: '%.*s'\n",
3041                        (int)(p - cmdp_start), cmdp_start);
3042         return NULL;
3043     }
3044
3045     /* filter out following useless space */
3046     while (qemu_isspace(*p)) {
3047         p++;
3048     }
3049
3050     *cmdp = p;
3051     /* search sub command */
3052     if (cmd->sub_table != NULL && *p != '\0') {
3053         return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
3054     }
3055
3056     return cmd;
3057 }
3058
3059 /*
3060  * Parse arguments for @cmd.
3061  * If it can't be parsed, report to @mon, and return NULL.
3062  * Else, insert command arguments into a QDict, and return it.
3063  * Note: On success, caller has to free the QDict structure.
3064  */
3065
3066 static QDict *monitor_parse_arguments(Monitor *mon,
3067                                       const char **endp,
3068                                       const mon_cmd_t *cmd)
3069 {
3070     const char *typestr;
3071     char *key;
3072     int c;
3073     const char *p = *endp;
3074     char buf[1024];
3075     QDict *qdict = qdict_new();
3076
3077     /* parse the parameters */
3078     typestr = cmd->args_type;
3079     for(;;) {
3080         typestr = key_get_info(typestr, &key);
3081         if (!typestr)
3082             break;
3083         c = *typestr;
3084         typestr++;
3085         switch(c) {
3086         case 'F':
3087         case 'B':
3088         case 's':
3089             {
3090                 int ret;
3091
3092                 while (qemu_isspace(*p))
3093                     p++;
3094                 if (*typestr == '?') {
3095                     typestr++;
3096                     if (*p == '\0') {
3097                         /* no optional string: NULL argument */
3098                         break;
3099                     }
3100                 }
3101                 ret = get_str(buf, sizeof(buf), &p);
3102                 if (ret < 0) {
3103                     switch(c) {
3104                     case 'F':
3105                         monitor_printf(mon, "%s: filename expected\n",
3106                                        cmd->name);
3107                         break;
3108                     case 'B':
3109                         monitor_printf(mon, "%s: block device name expected\n",
3110                                        cmd->name);
3111                         break;
3112                     default:
3113                         monitor_printf(mon, "%s: string expected\n", cmd->name);
3114                         break;
3115                     }
3116                     goto fail;
3117                 }
3118                 qdict_put_str(qdict, key, buf);
3119             }
3120             break;
3121         case 'O':
3122             {
3123                 QemuOptsList *opts_list;
3124                 QemuOpts *opts;
3125
3126                 opts_list = qemu_find_opts(key);
3127                 if (!opts_list || opts_list->desc->name) {
3128                     goto bad_type;
3129                 }
3130                 while (qemu_isspace(*p)) {
3131                     p++;
3132                 }
3133                 if (!*p)
3134                     break;
3135                 if (get_str(buf, sizeof(buf), &p) < 0) {
3136                     goto fail;
3137                 }
3138                 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3139                 if (!opts) {
3140                     goto fail;
3141                 }
3142                 qemu_opts_to_qdict(opts, qdict);
3143                 qemu_opts_del(opts);
3144             }
3145             break;
3146         case '/':
3147             {
3148                 int count, format, size;
3149
3150                 while (qemu_isspace(*p))
3151                     p++;
3152                 if (*p == '/') {
3153                     /* format found */
3154                     p++;
3155                     count = 1;
3156                     if (qemu_isdigit(*p)) {
3157                         count = 0;
3158                         while (qemu_isdigit(*p)) {
3159                             count = count * 10 + (*p - '0');
3160                             p++;
3161                         }
3162                     }
3163                     size = -1;
3164                     format = -1;
3165                     for(;;) {
3166                         switch(*p) {
3167                         case 'o':
3168                         case 'd':
3169                         case 'u':
3170                         case 'x':
3171                         case 'i':
3172                         case 'c':
3173                             format = *p++;
3174                             break;
3175                         case 'b':
3176                             size = 1;
3177                             p++;
3178                             break;
3179                         case 'h':
3180                             size = 2;
3181                             p++;
3182                             break;
3183                         case 'w':
3184                             size = 4;
3185                             p++;
3186                             break;
3187                         case 'g':
3188                         case 'L':
3189                             size = 8;
3190                             p++;
3191                             break;
3192                         default:
3193                             goto next;
3194                         }
3195                     }
3196                 next:
3197                     if (*p != '\0' && !qemu_isspace(*p)) {
3198                         monitor_printf(mon, "invalid char in format: '%c'\n",
3199                                        *p);
3200                         goto fail;
3201                     }
3202                     if (format < 0)
3203                         format = default_fmt_format;
3204                     if (format != 'i') {
3205                         /* for 'i', not specifying a size gives -1 as size */
3206                         if (size < 0)
3207                             size = default_fmt_size;
3208                         default_fmt_size = size;
3209                     }
3210                     default_fmt_format = format;
3211                 } else {
3212                     count = 1;
3213                     format = default_fmt_format;
3214                     if (format != 'i') {
3215                         size = default_fmt_size;
3216                     } else {
3217                         size = -1;
3218                     }
3219                 }
3220                 qdict_put_int(qdict, "count", count);
3221                 qdict_put_int(qdict, "format", format);
3222                 qdict_put_int(qdict, "size", size);
3223             }
3224             break;
3225         case 'i':
3226         case 'l':
3227         case 'M':
3228             {
3229                 int64_t val;
3230
3231                 while (qemu_isspace(*p))
3232                     p++;
3233                 if (*typestr == '?' || *typestr == '.') {
3234                     if (*typestr == '?') {
3235                         if (*p == '\0') {
3236                             typestr++;
3237                             break;
3238                         }
3239                     } else {
3240                         if (*p == '.') {
3241                             p++;
3242                             while (qemu_isspace(*p))
3243                                 p++;
3244                         } else {
3245                             typestr++;
3246                             break;
3247                         }
3248                     }
3249                     typestr++;
3250                 }
3251                 if (get_expr(mon, &val, &p))
3252                     goto fail;
3253                 /* Check if 'i' is greater than 32-bit */
3254                 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3255                     monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3256                     monitor_printf(mon, "integer is for 32-bit values\n");
3257                     goto fail;
3258                 } else if (c == 'M') {
3259                     if (val < 0) {
3260                         monitor_printf(mon, "enter a positive value\n");
3261                         goto fail;
3262                     }
3263                     val <<= 20;
3264                 }
3265                 qdict_put_int(qdict, key, val);
3266             }
3267             break;
3268         case 'o':
3269             {
3270                 int ret;
3271                 uint64_t val;
3272                 char *end;
3273
3274                 while (qemu_isspace(*p)) {
3275                     p++;
3276                 }
3277                 if (*typestr == '?') {
3278                     typestr++;
3279                     if (*p == '\0') {
3280                         break;
3281                     }
3282                 }
3283                 ret = qemu_strtosz_MiB(p, &end, &val);
3284                 if (ret < 0 || val > INT64_MAX) {
3285                     monitor_printf(mon, "invalid size\n");
3286                     goto fail;
3287                 }
3288                 qdict_put_int(qdict, key, val);
3289                 p = end;
3290             }
3291             break;
3292         case 'T':
3293             {
3294                 double val;
3295
3296                 while (qemu_isspace(*p))
3297                     p++;
3298                 if (*typestr == '?') {
3299                     typestr++;
3300                     if (*p == '\0') {
3301                         break;
3302                     }
3303                 }
3304                 if (get_double(mon, &val, &p) < 0) {
3305                     goto fail;
3306                 }
3307                 if (p[0] && p[1] == 's') {
3308                     switch (*p) {
3309                     case 'm':
3310                         val /= 1e3; p += 2; break;
3311                     case 'u':
3312                         val /= 1e6; p += 2; break;
3313                     case 'n':
3314                         val /= 1e9; p += 2; break;
3315                     }
3316                 }
3317                 if (*p && !qemu_isspace(*p)) {
3318                     monitor_printf(mon, "Unknown unit suffix\n");
3319                     goto fail;
3320                 }
3321                 qdict_put(qdict, key, qnum_from_double(val));
3322             }
3323             break;
3324         case 'b':
3325             {
3326                 const char *beg;
3327                 bool val;
3328
3329                 while (qemu_isspace(*p)) {
3330                     p++;
3331                 }
3332                 beg = p;
3333                 while (qemu_isgraph(*p)) {
3334                     p++;
3335                 }
3336                 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3337                     val = true;
3338                 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3339                     val = false;
3340                 } else {
3341                     monitor_printf(mon, "Expected 'on' or 'off'\n");
3342                     goto fail;
3343                 }
3344                 qdict_put_bool(qdict, key, val);
3345             }
3346             break;
3347         case '-':
3348             {
3349                 const char *tmp = p;
3350                 int skip_key = 0;
3351                 /* option */
3352
3353                 c = *typestr++;
3354                 if (c == '\0')
3355                     goto bad_type;
3356                 while (qemu_isspace(*p))
3357                     p++;
3358                 if (*p == '-') {
3359                     p++;
3360                     if(c != *p) {
3361                         if(!is_valid_option(p, typestr)) {
3362
3363                             monitor_printf(mon, "%s: unsupported option -%c\n",
3364                                            cmd->name, *p);
3365                             goto fail;
3366                         } else {
3367                             skip_key = 1;
3368                         }
3369                     }
3370                     if(skip_key) {
3371                         p = tmp;
3372                     } else {
3373                         /* has option */
3374                         p++;
3375                         qdict_put_bool(qdict, key, true);
3376                     }
3377                 }
3378             }
3379             break;
3380         case 'S':
3381             {
3382                 /* package all remaining string */
3383                 int len;
3384
3385                 while (qemu_isspace(*p)) {
3386                     p++;
3387                 }
3388                 if (*typestr == '?') {
3389                     typestr++;
3390                     if (*p == '\0') {
3391                         /* no remaining string: NULL argument */
3392                         break;
3393                     }
3394                 }
3395                 len = strlen(p);
3396                 if (len <= 0) {
3397                     monitor_printf(mon, "%s: string expected\n",
3398                                    cmd->name);
3399                     goto fail;
3400                 }
3401                 qdict_put_str(qdict, key, p);
3402                 p += len;
3403             }
3404             break;
3405         default:
3406         bad_type:
3407             monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3408             goto fail;
3409         }
3410         g_free(key);
3411         key = NULL;
3412     }
3413     /* check that all arguments were parsed */
3414     while (qemu_isspace(*p))
3415         p++;
3416     if (*p != '\0') {
3417         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3418                        cmd->name);
3419         goto fail;
3420     }
3421
3422     return qdict;
3423
3424 fail:
3425     qobject_unref(qdict);
3426     g_free(key);
3427     return NULL;
3428 }
3429
3430 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3431 {
3432     QDict *qdict;
3433     const mon_cmd_t *cmd;
3434
3435     trace_handle_hmp_command(mon, cmdline);
3436
3437     if (runstate_check(RUN_STATE_PRECONFIG)) {
3438         monitor_printf(mon, "HMP not available in preconfig state, "
3439                             "use QMP instead\n");
3440         return;
3441     }
3442
3443     cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3444     if (!cmd) {
3445         return;
3446     }
3447
3448     qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3449     if (!qdict) {
3450         monitor_printf(mon, "Try \"help %s\" for more information\n",
3451                        cmd->name);
3452         return;
3453     }
3454
3455     cmd->cmd(mon, qdict);
3456     qobject_unref(qdict);
3457 }
3458
3459 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3460 {
3461     const char *p, *pstart;
3462     char cmd[128];
3463     int len;
3464
3465     p = list;
3466     for(;;) {
3467         pstart = p;
3468         p = strchr(p, '|');
3469         if (!p)
3470             p = pstart + strlen(pstart);
3471         len = p - pstart;
3472         if (len > sizeof(cmd) - 2)
3473             len = sizeof(cmd) - 2;
3474         memcpy(cmd, pstart, len);
3475         cmd[len] = '\0';
3476         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3477             readline_add_completion(mon->rs, cmd);
3478         }
3479         if (*p == '\0')
3480             break;
3481         p++;
3482     }
3483 }
3484
3485 static void file_completion(Monitor *mon, const char *input)
3486 {
3487     DIR *ffs;
3488     struct dirent *d;
3489     char path[1024];
3490     char file[1024], file_prefix[1024];
3491     int input_path_len;
3492     const char *p;
3493
3494     p = strrchr(input, '/');
3495     if (!p) {
3496         input_path_len = 0;
3497         pstrcpy(file_prefix, sizeof(file_prefix), input);
3498         pstrcpy(path, sizeof(path), ".");
3499     } else {
3500         input_path_len = p - input + 1;
3501         memcpy(path, input, input_path_len);
3502         if (input_path_len > sizeof(path) - 1)
3503             input_path_len = sizeof(path) - 1;
3504         path[input_path_len] = '\0';
3505         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3506     }
3507
3508     ffs = opendir(path);
3509     if (!ffs)
3510         return;
3511     for(;;) {
3512         struct stat sb;
3513         d = readdir(ffs);
3514         if (!d)
3515             break;
3516
3517         if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3518             continue;
3519         }
3520
3521         if (strstart(d->d_name, file_prefix, NULL)) {
3522             memcpy(file, input, input_path_len);
3523             if (input_path_len < sizeof(file))
3524                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3525                         d->d_name);
3526             /* stat the file to find out if it's a directory.
3527              * In that case add a slash to speed up typing long paths
3528              */
3529             if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3530                 pstrcat(file, sizeof(file), "/");
3531             }
3532             readline_add_completion(mon->rs, file);
3533         }
3534     }
3535     closedir(ffs);
3536 }
3537
3538 static const char *next_arg_type(const char *typestr)
3539 {
3540     const char *p = strchr(typestr, ':');
3541     return (p != NULL ? ++p : typestr);
3542 }
3543
3544 static void add_completion_option(ReadLineState *rs, const char *str,
3545                                   const char *option)
3546 {
3547     if (!str || !option) {
3548         return;
3549     }
3550     if (!strncmp(option, str, strlen(str))) {
3551         readline_add_completion(rs, option);
3552     }
3553 }
3554
3555 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3556 {
3557     size_t len;
3558     ChardevBackendInfoList *list, *start;
3559
3560     if (nb_args != 2) {
3561         return;
3562     }
3563     len = strlen(str);
3564     readline_set_completion_index(rs, len);
3565
3566     start = list = qmp_query_chardev_backends(NULL);
3567     while (list) {
3568         const char *chr_name = list->value->name;
3569
3570         if (!strncmp(chr_name, str, len)) {
3571             readline_add_completion(rs, chr_name);
3572         }
3573         list = list->next;
3574     }
3575     qapi_free_ChardevBackendInfoList(start);
3576 }
3577
3578 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3579 {
3580     size_t len;
3581     int i;
3582
3583     if (nb_args != 2) {
3584         return;
3585     }
3586     len = strlen(str);
3587     readline_set_completion_index(rs, len);
3588     for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3589         add_completion_option(rs, str, NetClientDriver_str(i));
3590     }
3591 }
3592
3593 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3594 {
3595     GSList *list, *elt;
3596     size_t len;
3597
3598     if (nb_args != 2) {
3599         return;
3600     }
3601
3602     len = strlen(str);
3603     readline_set_completion_index(rs, len);
3604     list = elt = object_class_get_list(TYPE_DEVICE, false);
3605     while (elt) {
3606         const char *name;
3607         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3608                                              TYPE_DEVICE);
3609         name = object_class_get_name(OBJECT_CLASS(dc));
3610
3611         if (dc->user_creatable
3612             && !strncmp(name, str, len)) {
3613             readline_add_completion(rs, name);
3614         }
3615         elt = elt->next;
3616     }
3617     g_slist_free(list);
3618 }
3619
3620 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3621 {
3622     GSList *list, *elt;
3623     size_t len;
3624
3625     if (nb_args != 2) {
3626         return;
3627     }
3628
3629     len = strlen(str);
3630     readline_set_completion_index(rs, len);
3631     list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3632     while (elt) {
3633         const char *name;
3634
3635         name = object_class_get_name(OBJECT_CLASS(elt->data));
3636         if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3637             readline_add_completion(rs, name);
3638         }
3639         elt = elt->next;
3640     }
3641     g_slist_free(list);
3642 }
3643
3644 static void peripheral_device_del_completion(ReadLineState *rs,
3645                                              const char *str, size_t len)
3646 {
3647     Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3648     GSList *list, *item;
3649
3650     list = qdev_build_hotpluggable_device_list(peripheral);
3651     if (!list) {
3652         return;
3653     }
3654
3655     for (item = list; item; item = g_slist_next(item)) {
3656         DeviceState *dev = item->data;
3657
3658         if (dev->id && !strncmp(str, dev->id, len)) {
3659             readline_add_completion(rs, dev->id);
3660         }
3661     }
3662
3663     g_slist_free(list);
3664 }
3665
3666 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3667 {
3668     size_t len;
3669     ChardevInfoList *list, *start;
3670
3671     if (nb_args != 2) {
3672         return;
3673     }
3674     len = strlen(str);
3675     readline_set_completion_index(rs, len);
3676
3677     start = list = qmp_query_chardev(NULL);
3678     while (list) {
3679         ChardevInfo *chr = list->value;
3680
3681         if (!strncmp(chr->label, str, len)) {
3682             readline_add_completion(rs, chr->label);
3683         }
3684         list = list->next;
3685     }
3686     qapi_free_ChardevInfoList(start);
3687 }
3688
3689 static void ringbuf_completion(ReadLineState *rs, const char *str)
3690 {
3691     size_t len;
3692     ChardevInfoList *list, *start;
3693
3694     len = strlen(str);
3695     readline_set_completion_index(rs, len);
3696
3697     start = list = qmp_query_chardev(NULL);
3698     while (list) {
3699         ChardevInfo *chr_info = list->value;
3700
3701         if (!strncmp(chr_info->label, str, len)) {
3702             Chardev *chr = qemu_chr_find(chr_info->label);
3703             if (chr && CHARDEV_IS_RINGBUF(chr)) {
3704                 readline_add_completion(rs, chr_info->label);
3705             }
3706         }
3707         list = list->next;
3708     }
3709     qapi_free_ChardevInfoList(start);
3710 }
3711
3712 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3713 {
3714     if (nb_args != 2) {
3715         return;
3716     }
3717     ringbuf_completion(rs, str);
3718 }
3719
3720 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3721 {
3722     size_t len;
3723
3724     if (nb_args != 2) {
3725         return;
3726     }
3727
3728     len = strlen(str);
3729     readline_set_completion_index(rs, len);
3730     peripheral_device_del_completion(rs, str, len);
3731 }
3732
3733 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3734 {
3735     ObjectPropertyInfoList *list, *start;
3736     size_t len;
3737
3738     if (nb_args != 2) {
3739         return;
3740     }
3741     len = strlen(str);
3742     readline_set_completion_index(rs, len);
3743
3744     start = list = qmp_qom_list("/objects", NULL);
3745     while (list) {
3746         ObjectPropertyInfo *info = list->value;
3747
3748         if (!strncmp(info->type, "child<", 5)
3749             && !strncmp(info->name, str, len)) {
3750             readline_add_completion(rs, info->name);
3751         }
3752         list = list->next;
3753     }
3754     qapi_free_ObjectPropertyInfoList(start);
3755 }
3756
3757 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3758 {
3759     int i;
3760     char *sep;
3761     size_t len;
3762
3763     if (nb_args != 2) {
3764         return;
3765     }
3766     sep = strrchr(str, '-');
3767     if (sep) {
3768         str = sep + 1;
3769     }
3770     len = strlen(str);
3771     readline_set_completion_index(rs, len);
3772     for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3773         if (!strncmp(str, QKeyCode_str(i), len)) {
3774             readline_add_completion(rs, QKeyCode_str(i));
3775         }
3776     }
3777 }
3778
3779 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3780 {
3781     size_t len;
3782
3783     len = strlen(str);
3784     readline_set_completion_index(rs, len);
3785     if (nb_args == 2) {
3786         NetClientState *ncs[MAX_QUEUE_NUM];
3787         int count, i;
3788         count = qemu_find_net_clients_except(NULL, ncs,
3789                                              NET_CLIENT_DRIVER_NONE,
3790                                              MAX_QUEUE_NUM);
3791         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3792             const char *name = ncs[i]->name;
3793             if (!strncmp(str, name, len)) {
3794                 readline_add_completion(rs, name);
3795             }
3796         }
3797     } else if (nb_args == 3) {
3798         add_completion_option(rs, str, "on");
3799         add_completion_option(rs, str, "off");
3800     }
3801 }
3802
3803 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3804 {
3805     int len, count, i;
3806     NetClientState *ncs[MAX_QUEUE_NUM];
3807
3808     if (nb_args != 2) {
3809         return;
3810     }
3811
3812     len = strlen(str);
3813     readline_set_completion_index(rs, len);
3814     count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3815                                          MAX_QUEUE_NUM);
3816     for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3817         QemuOpts *opts;
3818         const char *name = ncs[i]->name;
3819         if (strncmp(str, name, len)) {
3820             continue;
3821         }
3822         opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3823         if (opts) {
3824             readline_add_completion(rs, name);
3825         }
3826     }
3827 }
3828
3829 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3830 {
3831     size_t len;
3832
3833     len = strlen(str);
3834     readline_set_completion_index(rs, len);
3835     if (nb_args == 2) {
3836         TraceEventIter iter;
3837         TraceEvent *ev;
3838         char *pattern = g_strdup_printf("%s*", str);
3839         trace_event_iter_init(&iter, pattern);
3840         while ((ev = trace_event_iter_next(&iter)) != NULL) {
3841             readline_add_completion(rs, trace_event_get_name(ev));
3842         }
3843         g_free(pattern);
3844     }
3845 }
3846
3847 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3848 {
3849     size_t len;
3850
3851     len = strlen(str);
3852     readline_set_completion_index(rs, len);
3853     if (nb_args == 2) {
3854         TraceEventIter iter;
3855         TraceEvent *ev;
3856         char *pattern = g_strdup_printf("%s*", str);
3857         trace_event_iter_init(&iter, pattern);
3858         while ((ev = trace_event_iter_next(&iter)) != NULL) {
3859             readline_add_completion(rs, trace_event_get_name(ev));
3860         }
3861         g_free(pattern);
3862     } else if (nb_args == 3) {
3863         add_completion_option(rs, str, "on");
3864         add_completion_option(rs, str, "off");
3865     }
3866 }
3867
3868 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3869 {
3870     int i;
3871
3872     if (nb_args != 2) {
3873         return;
3874     }
3875     readline_set_completion_index(rs, strlen(str));
3876     for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3877         add_completion_option(rs, str, WatchdogAction_str(i));
3878     }
3879 }
3880
3881 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3882                                        const char *str)
3883 {
3884     size_t len;
3885
3886     len = strlen(str);
3887     readline_set_completion_index(rs, len);
3888     if (nb_args == 2) {
3889         int i;
3890         for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3891             const char *name = MigrationCapability_str(i);
3892             if (!strncmp(str, name, len)) {
3893                 readline_add_completion(rs, name);
3894             }
3895         }
3896     } else if (nb_args == 3) {
3897         add_completion_option(rs, str, "on");
3898         add_completion_option(rs, str, "off");
3899     }
3900 }
3901
3902 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3903                                       const char *str)
3904 {
3905     size_t len;
3906
3907     len = strlen(str);
3908     readline_set_completion_index(rs, len);
3909     if (nb_args == 2) {
3910         int i;
3911         for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3912             const char *name = MigrationParameter_str(i);
3913             if (!strncmp(str, name, len)) {
3914                 readline_add_completion(rs, name);
3915             }
3916         }
3917     }
3918 }
3919
3920 static void vm_completion(ReadLineState *rs, const char *str)
3921 {
3922     size_t len;
3923     BlockDriverState *bs;
3924     BdrvNextIterator it;
3925
3926     len = strlen(str);
3927     readline_set_completion_index(rs, len);
3928
3929     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3930         SnapshotInfoList *snapshots, *snapshot;
3931         AioContext *ctx = bdrv_get_aio_context(bs);
3932         bool ok = false;
3933
3934         aio_context_acquire(ctx);
3935         if (bdrv_can_snapshot(bs)) {
3936             ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3937         }
3938         aio_context_release(ctx);
3939         if (!ok) {
3940             continue;
3941         }
3942
3943         snapshot = snapshots;
3944         while (snapshot) {
3945             char *completion = snapshot->value->name;
3946             if (!strncmp(str, completion, len)) {
3947                 readline_add_completion(rs, completion);
3948             }
3949             completion = snapshot->value->id;
3950             if (!strncmp(str, completion, len)) {
3951                 readline_add_completion(rs, completion);
3952             }
3953             snapshot = snapshot->next;
3954         }
3955         qapi_free_SnapshotInfoList(snapshots);
3956     }
3957
3958 }
3959
3960 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3961 {
3962     if (nb_args == 2) {
3963         vm_completion(rs, str);
3964     }
3965 }
3966
3967 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3968 {
3969     if (nb_args == 2) {
3970         vm_completion(rs, str);
3971     }
3972 }
3973
3974 static void monitor_find_completion_by_table(Monitor *mon,
3975                                              const mon_cmd_t *cmd_table,
3976                                              char **args,
3977                                              int nb_args)
3978 {
3979     const char *cmdname;
3980     int i;
3981     const char *ptype, *old_ptype, *str, *name;
3982     const mon_cmd_t *cmd;
3983     BlockBackend *blk = NULL;
3984
3985     if (nb_args <= 1) {
3986         /* command completion */
3987         if (nb_args == 0)
3988             cmdname = "";
3989         else
3990             cmdname = args[0];
3991         readline_set_completion_index(mon->rs, strlen(cmdname));
3992         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3993             cmd_completion(mon, cmdname, cmd->name);
3994         }
3995     } else {
3996         /* find the command */
3997         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3998             if (compare_cmd(args[0], cmd->name)) {
3999                 break;
4000             }
4001         }
4002         if (!cmd->name) {
4003             return;
4004         }
4005
4006         if (cmd->sub_table) {
4007             /* do the job again */
4008             monitor_find_completion_by_table(mon, cmd->sub_table,
4009                                              &args[1], nb_args - 1);
4010             return;
4011         }
4012         if (cmd->command_completion) {
4013             cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4014             return;
4015         }
4016
4017         ptype = next_arg_type(cmd->args_type);
4018         for(i = 0; i < nb_args - 2; i++) {
4019             if (*ptype != '\0') {
4020                 ptype = next_arg_type(ptype);
4021                 while (*ptype == '?')
4022                     ptype = next_arg_type(ptype);
4023             }
4024         }
4025         str = args[nb_args - 1];
4026         old_ptype = NULL;
4027         while (*ptype == '-' && old_ptype != ptype) {
4028             old_ptype = ptype;
4029             ptype = next_arg_type(ptype);
4030         }
4031         switch(*ptype) {
4032         case 'F':
4033             /* file completion */
4034             readline_set_completion_index(mon->rs, strlen(str));
4035             file_completion(mon, str);
4036             break;
4037         case 'B':
4038             /* block device name completion */
4039             readline_set_completion_index(mon->rs, strlen(str));
4040             while ((blk = blk_next(blk)) != NULL) {
4041                 name = blk_name(blk);
4042                 if (str[0] == '\0' ||
4043                     !strncmp(name, str, strlen(str))) {
4044                     readline_add_completion(mon->rs, name);
4045                 }
4046             }
4047             break;
4048         case 's':
4049         case 'S':
4050             if (!strcmp(cmd->name, "help|?")) {
4051                 monitor_find_completion_by_table(mon, cmd_table,
4052                                                  &args[1], nb_args - 1);
4053             }
4054             break;
4055         default:
4056             break;
4057         }
4058     }
4059 }
4060
4061 static void monitor_find_completion(void *opaque,
4062                                     const char *cmdline)
4063 {
4064     Monitor *mon = opaque;
4065     char *args[MAX_ARGS];
4066     int nb_args, len;
4067
4068     /* 1. parse the cmdline */
4069     if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4070         return;
4071     }
4072
4073     /* if the line ends with a space, it means we want to complete the
4074        next arg */
4075     len = strlen(cmdline);
4076     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4077         if (nb_args >= MAX_ARGS) {
4078             goto cleanup;
4079         }
4080         args[nb_args++] = g_strdup("");
4081     }
4082
4083     /* 2. auto complete according to args */
4084     monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4085
4086 cleanup:
4087     free_cmdline_args(args, nb_args);
4088 }
4089
4090 static int monitor_can_read(void *opaque)
4091 {
4092     Monitor *mon = opaque;
4093
4094     return !atomic_mb_read(&mon->suspend_cnt);
4095 }
4096
4097 /*
4098  * 1. This function takes ownership of rsp, err, and id.
4099  * 2. rsp, err, and id may be NULL.
4100  * 3. If err != NULL then rsp must be NULL.
4101  */
4102 static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
4103                                 Error *err, QObject *id)
4104 {
4105     QDict *qdict = NULL;
4106
4107     if (err) {
4108         assert(!rsp);
4109         qdict = qdict_new();
4110         qdict_put_obj(qdict, "error", qmp_build_error_object(err));
4111         error_free(err);
4112         rsp = QOBJECT(qdict);
4113     }
4114
4115     if (rsp) {
4116         if (id) {
4117             qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
4118         }
4119
4120         monitor_json_emitter(mon, rsp);
4121     }
4122
4123     qobject_unref(id);
4124     qobject_unref(rsp);
4125 }
4126
4127 /*
4128  * Dispatch one single QMP request. The function will free the req_obj
4129  * and objects inside it before return.
4130  */
4131 static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
4132 {
4133     Monitor *mon, *old_mon;
4134     QObject *req, *rsp = NULL, *id;
4135     bool need_resume;
4136
4137     req = req_obj->req;
4138     mon = req_obj->mon;
4139     id = req_obj->id;
4140     need_resume = req_obj->need_resume;
4141
4142     g_free(req_obj);
4143
4144     if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4145         QString *req_json = qobject_to_json(req);
4146         trace_handle_qmp_command(mon, qstring_get_str(req_json));
4147         qobject_unref(req_json);
4148     }
4149
4150     old_mon = cur_mon;
4151     cur_mon = mon;
4152
4153     rsp = qmp_dispatch(mon->qmp.commands, req);
4154
4155     cur_mon = old_mon;
4156
4157     /* Respond if necessary */
4158     monitor_qmp_respond(mon, rsp, NULL, id);
4159
4160     /* This pairs with the monitor_suspend() in handle_qmp_command(). */
4161     if (need_resume) {
4162         monitor_resume(mon);
4163     }
4164
4165     qobject_unref(req);
4166 }
4167
4168 /*
4169  * Pop one QMP request from monitor queues, return NULL if not found.
4170  * We are using round-robin fashion to pop the request, to avoid
4171  * processing commands only on a very busy monitor.  To achieve that,
4172  * when we process one request on a specific monitor, we put that
4173  * monitor to the end of mon_list queue.
4174  */
4175 static QMPRequest *monitor_qmp_requests_pop_one(void)
4176 {
4177     QMPRequest *req_obj = NULL;
4178     Monitor *mon;
4179
4180     qemu_mutex_lock(&monitor_lock);
4181
4182     QTAILQ_FOREACH(mon, &mon_list, entry) {
4183         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4184         req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4185         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4186         if (req_obj) {
4187             break;
4188         }
4189     }
4190
4191     if (req_obj) {
4192         /*
4193          * We found one request on the monitor. Degrade this monitor's
4194          * priority to lowest by re-inserting it to end of queue.
4195          */
4196         QTAILQ_REMOVE(&mon_list, mon, entry);
4197         QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4198     }
4199
4200     qemu_mutex_unlock(&monitor_lock);
4201
4202     return req_obj;
4203 }
4204
4205 static void monitor_qmp_bh_dispatcher(void *data)
4206 {
4207     QMPRequest *req_obj = monitor_qmp_requests_pop_one();
4208
4209     if (req_obj) {
4210         trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4211         monitor_qmp_dispatch_one(req_obj);
4212         /* Reschedule instead of looping so the main loop stays responsive */
4213         qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4214     }
4215 }
4216
4217 #define  QMP_REQ_QUEUE_LEN_MAX  (8)
4218
4219 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
4220 {
4221     QObject *req, *id = NULL;
4222     QDict *qdict = NULL;
4223     MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
4224     Monitor *mon = container_of(mon_qmp, Monitor, qmp);
4225     Error *err = NULL;
4226     QMPRequest *req_obj;
4227
4228     req = json_parser_parse_err(tokens, NULL, &err);
4229     if (!req && !err) {
4230         /* json_parser_parse_err() sucks: can fail without setting @err */
4231         error_setg(&err, QERR_JSON_PARSING);
4232     }
4233     if (err) {
4234         goto err;
4235     }
4236
4237     /* Check against the request in general layout */
4238     qdict = qmp_dispatch_check_obj(req, &err);
4239     if (!qdict) {
4240         goto err;
4241     }
4242
4243     /* Check against OOB specific */
4244     if (!qmp_cmd_oob_check(mon, qdict, &err)) {
4245         goto err;
4246     }
4247
4248     id = qdict_get(qdict, "id");
4249
4250     /* When OOB is enabled, the "id" field is mandatory. */
4251     if (qmp_oob_enabled(mon) && !id) {
4252         error_setg(&err, "Out-Of-Band capability requires that "
4253                    "every command contains an 'id' field");
4254         goto err;
4255     }
4256
4257     req_obj = g_new0(QMPRequest, 1);
4258     req_obj->mon = mon;
4259     req_obj->id = qobject_ref(id);
4260     req_obj->req = req;
4261     req_obj->need_resume = false;
4262
4263     qdict_del(qdict, "id");
4264
4265     if (qmp_is_oob(qdict)) {
4266         /* Out-Of-Band (OOB) requests are executed directly in parser. */
4267         trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
4268                                           ?: "");
4269         monitor_qmp_dispatch_one(req_obj);
4270         return;
4271     }
4272
4273     /* Protect qmp_requests and fetching its length. */
4274     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4275
4276     /*
4277      * If OOB is not enabled on the current monitor, we'll emulate the
4278      * old behavior that we won't process the current monitor any more
4279      * until it has responded.  This helps make sure that as long as
4280      * OOB is not enabled, the server will never drop any command.
4281      */
4282     if (!qmp_oob_enabled(mon)) {
4283         monitor_suspend(mon);
4284         req_obj->need_resume = true;
4285     } else {
4286         /* Drop the request if queue is full. */
4287         if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4288             qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4289             qapi_event_send_command_dropped(id,
4290                                             COMMAND_DROP_REASON_QUEUE_FULL,
4291                                             &error_abort);
4292             qmp_request_free(req_obj);
4293             return;
4294         }
4295     }
4296
4297     /*
4298      * Put the request to the end of queue so that requests will be
4299      * handled in time order.  Ownership for req_obj, req, id,
4300      * etc. will be delivered to the handler side.
4301      */
4302     g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4303     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4304
4305     /* Kick the dispatcher routine */
4306     qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4307     return;
4308
4309 err:
4310     monitor_qmp_respond(mon, NULL, err, NULL);
4311     qobject_unref(req);
4312 }
4313
4314 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4315 {
4316     Monitor *mon = opaque;
4317
4318     json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4319 }
4320
4321 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4322 {
4323     Monitor *old_mon = cur_mon;
4324     int i;
4325
4326     cur_mon = opaque;
4327
4328     if (cur_mon->rs) {
4329         for (i = 0; i < size; i++)
4330             readline_handle_byte(cur_mon->rs, buf[i]);
4331     } else {
4332         if (size == 0 || buf[size - 1] != 0)
4333             monitor_printf(cur_mon, "corrupted command\n");
4334         else
4335             handle_hmp_command(cur_mon, (char *)buf);
4336     }
4337
4338     cur_mon = old_mon;
4339 }
4340
4341 static void monitor_command_cb(void *opaque, const char *cmdline,
4342                                void *readline_opaque)
4343 {
4344     Monitor *mon = opaque;
4345
4346     monitor_suspend(mon);
4347     handle_hmp_command(mon, cmdline);
4348     monitor_resume(mon);
4349 }
4350
4351 int monitor_suspend(Monitor *mon)
4352 {
4353     if (monitor_is_hmp_non_interactive(mon)) {
4354         return -ENOTTY;
4355     }
4356
4357     atomic_inc(&mon->suspend_cnt);
4358
4359     if (monitor_is_qmp(mon)) {
4360         /*
4361          * Kick iothread to make sure this takes effect.  It'll be
4362          * evaluated again in prepare() of the watch object.
4363          */
4364         aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4365     }
4366
4367     trace_monitor_suspend(mon, 1);
4368     return 0;
4369 }
4370
4371 void monitor_resume(Monitor *mon)
4372 {
4373     if (monitor_is_hmp_non_interactive(mon)) {
4374         return;
4375     }
4376
4377     if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4378         if (monitor_is_qmp(mon)) {
4379             /*
4380              * For QMP monitors that are running in IOThread, let's
4381              * kick the thread in case it's sleeping.
4382              */
4383             if (mon->use_io_thr) {
4384                 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4385             }
4386         } else {
4387             assert(mon->rs);
4388             readline_show_prompt(mon->rs);
4389         }
4390     }
4391     trace_monitor_suspend(mon, -1);
4392 }
4393
4394 static QObject *get_qmp_greeting(Monitor *mon)
4395 {
4396     QList *cap_list = qlist_new();
4397     QObject *ver = NULL;
4398     QMPCapability cap;
4399
4400     qmp_marshal_query_version(NULL, &ver, NULL);
4401
4402     for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4403         if (!mon->use_io_thr && cap == QMP_CAPABILITY_OOB) {
4404             /* Monitors that are not using IOThread won't support OOB */
4405             continue;
4406         }
4407         qlist_append_str(cap_list, QMPCapability_str(cap));
4408     }
4409
4410     return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
4411                               ver, cap_list);
4412 }
4413
4414 static void monitor_qmp_caps_reset(Monitor *mon)
4415 {
4416     memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
4417 }
4418
4419 static void monitor_qmp_event(void *opaque, int event)
4420 {
4421     QObject *data;
4422     Monitor *mon = opaque;
4423
4424     switch (event) {
4425     case CHR_EVENT_OPENED:
4426         mon->qmp.commands = &qmp_cap_negotiation_commands;
4427         monitor_qmp_caps_reset(mon);
4428         data = get_qmp_greeting(mon);
4429         monitor_json_emitter(mon, data);
4430         qobject_unref(data);
4431         mon_refcount++;
4432         break;
4433     case CHR_EVENT_CLOSED:
4434         monitor_qmp_cleanup_queues(mon);
4435         json_message_parser_destroy(&mon->qmp.parser);
4436         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4437         mon_refcount--;
4438         monitor_fdsets_cleanup();
4439         break;
4440     }
4441 }
4442
4443 static void monitor_event(void *opaque, int event)
4444 {
4445     Monitor *mon = opaque;
4446
4447     switch (event) {
4448     case CHR_EVENT_MUX_IN:
4449         qemu_mutex_lock(&mon->mon_lock);
4450         mon->mux_out = 0;
4451         qemu_mutex_unlock(&mon->mon_lock);
4452         if (mon->reset_seen) {
4453             readline_restart(mon->rs);
4454             monitor_resume(mon);
4455             monitor_flush(mon);
4456         } else {
4457             atomic_mb_set(&mon->suspend_cnt, 0);
4458         }
4459         break;
4460
4461     case CHR_EVENT_MUX_OUT:
4462         if (mon->reset_seen) {
4463             if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4464                 monitor_printf(mon, "\n");
4465             }
4466             monitor_flush(mon);
4467             monitor_suspend(mon);
4468         } else {
4469             atomic_inc(&mon->suspend_cnt);
4470         }
4471         qemu_mutex_lock(&mon->mon_lock);
4472         mon->mux_out = 1;
4473         qemu_mutex_unlock(&mon->mon_lock);
4474         break;
4475
4476     case CHR_EVENT_OPENED:
4477         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4478                        "information\n", QEMU_VERSION);
4479         if (!mon->mux_out) {
4480             readline_restart(mon->rs);
4481             readline_show_prompt(mon->rs);
4482         }
4483         mon->reset_seen = 1;
4484         mon_refcount++;
4485         break;
4486
4487     case CHR_EVENT_CLOSED:
4488         mon_refcount--;
4489         monitor_fdsets_cleanup();
4490         break;
4491     }
4492 }
4493
4494 static int
4495 compare_mon_cmd(const void *a, const void *b)
4496 {
4497     return strcmp(((const mon_cmd_t *)a)->name,
4498             ((const mon_cmd_t *)b)->name);
4499 }
4500
4501 static void sortcmdlist(void)
4502 {
4503     int array_num;
4504     int elem_size = sizeof(mon_cmd_t);
4505
4506     array_num = sizeof(mon_cmds)/elem_size-1;
4507     qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4508
4509     array_num = sizeof(info_cmds)/elem_size-1;
4510     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4511 }
4512
4513 static GMainContext *monitor_get_io_context(void)
4514 {
4515     return iothread_get_g_main_context(mon_global.mon_iothread);
4516 }
4517
4518 static AioContext *monitor_get_aio_context(void)
4519 {
4520     return iothread_get_aio_context(mon_global.mon_iothread);
4521 }
4522
4523 static void monitor_iothread_init(void)
4524 {
4525     mon_global.mon_iothread = iothread_create("mon_iothread",
4526                                               &error_abort);
4527
4528     /*
4529      * This MUST be on main loop thread since we have commands that
4530      * have assumption to be run on main loop thread.  It would be
4531      * nice that one day we can remove this assumption in the future.
4532      */
4533     mon_global.qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4534                                               monitor_qmp_bh_dispatcher,
4535                                               NULL);
4536
4537     /*
4538      * Unlike the dispatcher BH, this must be run on the monitor IO
4539      * thread, so that monitors that are using IO thread will make
4540      * sure read/write operations are all done on the IO thread.
4541      */
4542     mon_global.qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4543                                            monitor_qmp_bh_responder,
4544                                            NULL);
4545 }
4546
4547 void monitor_init_globals(void)
4548 {
4549     monitor_init_qmp_commands();
4550     monitor_qapi_event_init();
4551     sortcmdlist();
4552     qemu_mutex_init(&monitor_lock);
4553     qemu_mutex_init(&mon_fdsets_lock);
4554     monitor_iothread_init();
4555 }
4556
4557 /* These functions just adapt the readline interface in a typesafe way.  We
4558  * could cast function pointers but that discards compiler checks.
4559  */
4560 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4561                                                        const char *fmt, ...)
4562 {
4563     va_list ap;
4564     va_start(ap, fmt);
4565     monitor_vprintf(opaque, fmt, ap);
4566     va_end(ap);
4567 }
4568
4569 static void monitor_readline_flush(void *opaque)
4570 {
4571     monitor_flush(opaque);
4572 }
4573
4574 /*
4575  * Print to current monitor if we have one, else to stderr.
4576  * TODO should return int, so callers can calculate width, but that
4577  * requires surgery to monitor_vprintf().  Left for another day.
4578  */
4579 void error_vprintf(const char *fmt, va_list ap)
4580 {
4581     if (cur_mon && !monitor_cur_is_qmp()) {
4582         monitor_vprintf(cur_mon, fmt, ap);
4583     } else {
4584         vfprintf(stderr, fmt, ap);
4585     }
4586 }
4587
4588 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4589 {
4590     if (cur_mon && !monitor_cur_is_qmp()) {
4591         monitor_vprintf(cur_mon, fmt, ap);
4592     } else if (!cur_mon) {
4593         vfprintf(stderr, fmt, ap);
4594     }
4595 }
4596
4597 static void monitor_list_append(Monitor *mon)
4598 {
4599     qemu_mutex_lock(&monitor_lock);
4600     QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4601     qemu_mutex_unlock(&monitor_lock);
4602 }
4603
4604 static void monitor_qmp_setup_handlers_bh(void *opaque)
4605 {
4606     Monitor *mon = opaque;
4607     GMainContext *context;
4608
4609     if (mon->use_io_thr) {
4610         /*
4611          * When use_io_thr is set, we use the global shared dedicated
4612          * IO thread for this monitor to handle input/output.
4613          */
4614         context = monitor_get_io_context();
4615         /* We should have inited globals before reaching here. */
4616         assert(context);
4617     } else {
4618         /* The default main loop, which is the main thread */
4619         context = NULL;
4620     }
4621
4622     qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4623                              monitor_qmp_event, NULL, mon, context, true);
4624     monitor_list_append(mon);
4625 }
4626
4627 void monitor_init(Chardev *chr, int flags)
4628 {
4629     Monitor *mon = g_malloc(sizeof(*mon));
4630     bool use_readline = flags & MONITOR_USE_READLINE;
4631     bool use_oob = flags & MONITOR_USE_OOB;
4632
4633     if (use_oob) {
4634         if (CHARDEV_IS_MUX(chr)) {
4635             error_report("Monitor Out-Of-Band is not supported with "
4636                          "MUX typed chardev backend");
4637             exit(1);
4638         }
4639         if (use_readline) {
4640             error_report("Monitor Out-Of-band is only supported by QMP");
4641             exit(1);
4642         }
4643     }
4644
4645     monitor_data_init(mon, false, use_oob);
4646
4647     qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4648     mon->flags = flags;
4649     if (use_readline) {
4650         mon->rs = readline_init(monitor_readline_printf,
4651                                 monitor_readline_flush,
4652                                 mon,
4653                                 monitor_find_completion);
4654         monitor_read_command(mon, 0);
4655     }
4656
4657     if (monitor_is_qmp(mon)) {
4658         qemu_chr_fe_set_echo(&mon->chr, true);
4659         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4660         if (mon->use_io_thr) {
4661             /*
4662              * Make sure the old iowatch is gone.  It's possible when
4663              * e.g. the chardev is in client mode, with wait=on.
4664              */
4665             remove_fd_in_watch(chr);
4666             /*
4667              * We can't call qemu_chr_fe_set_handlers() directly here
4668              * since during the procedure the chardev will be active
4669              * and running in monitor iothread, while we'll still do
4670              * something before returning from it, which is a possible
4671              * race too.  To avoid that, we just create a BH to setup
4672              * the handlers.
4673              */
4674             aio_bh_schedule_oneshot(monitor_get_aio_context(),
4675                                     monitor_qmp_setup_handlers_bh, mon);
4676             /* We'll add this to mon_list in the BH when setup done */
4677             return;
4678         } else {
4679             qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4680                                      monitor_qmp_read, monitor_qmp_event,
4681                                      NULL, mon, NULL, true);
4682         }
4683     } else {
4684         qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4685                                  monitor_event, NULL, mon, NULL, true);
4686     }
4687
4688     monitor_list_append(mon);
4689 }
4690
4691 void monitor_cleanup(void)
4692 {
4693     Monitor *mon, *next;
4694
4695     /*
4696      * We need to explicitly stop the iothread (but not destroy it),
4697      * cleanup the monitor resources, then destroy the iothread since
4698      * we need to unregister from chardev below in
4699      * monitor_data_destroy(), and chardev is not thread-safe yet
4700      */
4701     iothread_stop(mon_global.mon_iothread);
4702
4703     /*
4704      * After we have IOThread to send responses, it's possible that
4705      * when we stop the IOThread there are still replies queued in the
4706      * responder queue.  Flush all of them.  Note that even after this
4707      * flush it's still possible that out buffer is not flushed.
4708      * It'll be done in below monitor_flush() as the last resort.
4709      */
4710     monitor_qmp_bh_responder(NULL);
4711
4712     qemu_mutex_lock(&monitor_lock);
4713     QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4714         QTAILQ_REMOVE(&mon_list, mon, entry);
4715         monitor_flush(mon);
4716         monitor_data_destroy(mon);
4717         g_free(mon);
4718     }
4719     qemu_mutex_unlock(&monitor_lock);
4720
4721     /* QEMUBHs needs to be deleted before destroying the IOThread. */
4722     qemu_bh_delete(mon_global.qmp_dispatcher_bh);
4723     mon_global.qmp_dispatcher_bh = NULL;
4724     qemu_bh_delete(mon_global.qmp_respond_bh);
4725     mon_global.qmp_respond_bh = NULL;
4726
4727     iothread_destroy(mon_global.mon_iothread);
4728     mon_global.mon_iothread = NULL;
4729 }
4730
4731 QemuOptsList qemu_mon_opts = {
4732     .name = "mon",
4733     .implied_opt_name = "chardev",
4734     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4735     .desc = {
4736         {
4737             .name = "mode",
4738             .type = QEMU_OPT_STRING,
4739         },{
4740             .name = "chardev",
4741             .type = QEMU_OPT_STRING,
4742         },{
4743             .name = "pretty",
4744             .type = QEMU_OPT_BOOL,
4745         },{
4746             .name = "x-oob",
4747             .type = QEMU_OPT_BOOL,
4748         },
4749         { /* end of list */ }
4750     },
4751 };
4752
4753 #ifndef TARGET_I386
4754 void qmp_rtc_reset_reinjection(Error **errp)
4755 {
4756     error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4757 }
4758
4759 SevInfo *qmp_query_sev(Error **errp)
4760 {
4761     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4762     return NULL;
4763 }
4764
4765 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4766 {
4767     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4768     return NULL;
4769 }
4770
4771 SevCapability *qmp_query_sev_capabilities(Error **errp)
4772 {
4773     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4774     return NULL;
4775 }
4776 #endif
4777
4778 #ifndef TARGET_S390X
4779 void qmp_dump_skeys(const char *filename, Error **errp)
4780 {
4781     error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4782 }
4783 #endif
4784
4785 #ifndef TARGET_ARM
4786 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4787 {
4788     error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4789     return NULL;
4790 }
4791 #endif
4792
4793 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4794 {
4795     MachineState *ms = MACHINE(qdev_get_machine());
4796     MachineClass *mc = MACHINE_GET_CLASS(ms);
4797
4798     if (!mc->has_hotpluggable_cpus) {
4799         error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4800         return NULL;
4801     }
4802
4803     return machine_query_hotpluggable_cpus(ms);
4804 }