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