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