monitor.c

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