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