monitor.c

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