monitor.c

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