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