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