monitor.c

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