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