monitor.c

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