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