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             /* partinal 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     qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1115 }
1116
1117 static void hmp_log(Monitor *mon, const QDict *qdict)
1118 {
1119     int mask;
1120     const char *items = qdict_get_str(qdict, "items");
1121
1122     if (!strcmp(items, "none")) {
1123         mask = 0;
1124     } else {
1125         mask = qemu_str_to_log_mask(items);
1126         if (!mask) {
1127             help_cmd(mon, "log");
1128             return;
1129         }
1130     }
1131     qemu_set_log(mask);
1132 }
1133
1134 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1135 {
1136     const char *option = qdict_get_try_str(qdict, "option");
1137     if (!option || !strcmp(option, "on")) {
1138         singlestep = 1;
1139     } else if (!strcmp(option, "off")) {
1140         singlestep = 0;
1141     } else {
1142         monitor_printf(mon, "unexpected option %s\n", option);
1143     }
1144 }
1145
1146 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1147 {
1148     const char *device = qdict_get_try_str(qdict, "device");
1149     if (!device)
1150         device = "tcp::" DEFAULT_GDBSTUB_PORT;
1151     if (gdbserver_start(device) < 0) {
1152         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1153                        device);
1154     } else if (strcmp(device, "none") == 0) {
1155         monitor_printf(mon, "Disabled gdbserver\n");
1156     } else {
1157         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1158                        device);
1159     }
1160 }
1161
1162 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1163 {
1164     const char *action = qdict_get_str(qdict, "action");
1165     if (select_watchdog_action(action) == -1) {
1166         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1167     }
1168 }
1169
1170 static void monitor_printc(Monitor *mon, int c)
1171 {
1172     monitor_printf(mon, "'");
1173     switch(c) {
1174     case '\'':
1175         monitor_printf(mon, "\\'");
1176         break;
1177     case '\\':
1178         monitor_printf(mon, "\\\\");
1179         break;
1180     case '\n':
1181         monitor_printf(mon, "\\n");
1182         break;
1183     case '\r':
1184         monitor_printf(mon, "\\r");
1185         break;
1186     default:
1187         if (c >= 32 && c <= 126) {
1188             monitor_printf(mon, "%c", c);
1189         } else {
1190             monitor_printf(mon, "\\x%02x", c);
1191         }
1192         break;
1193     }
1194     monitor_printf(mon, "'");
1195 }
1196
1197 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1198                         hwaddr addr, int is_physical)
1199 {
1200     int l, line_size, i, max_digits, len;
1201     uint8_t buf[16];
1202     uint64_t v;
1203
1204     if (format == 'i') {
1205         int flags = 0;
1206 #ifdef TARGET_I386
1207         CPUArchState *env = mon_get_cpu_env();
1208         if (wsize == 2) {
1209             flags = 1;
1210         } else if (wsize == 4) {
1211             flags = 0;
1212         } else {
1213             /* as default we use the current CS size */
1214             flags = 0;
1215             if (env) {
1216 #ifdef TARGET_X86_64
1217                 if ((env->efer & MSR_EFER_LMA) &&
1218                     (env->segs[R_CS].flags & DESC_L_MASK))
1219                     flags = 2;
1220                 else
1221 #endif
1222                 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1223                     flags = 1;
1224             }
1225         }
1226 #endif
1227 #ifdef TARGET_PPC
1228         CPUArchState *env = mon_get_cpu_env();
1229         flags = msr_le << 16;
1230         flags |= env->bfd_mach;
1231 #endif
1232         monitor_disas(mon, mon_get_cpu(), addr, count, is_physical, flags);
1233         return;
1234     }
1235
1236     len = wsize * count;
1237     if (wsize == 1)
1238         line_size = 8;
1239     else
1240         line_size = 16;
1241     max_digits = 0;
1242
1243     switch(format) {
1244     case 'o':
1245         max_digits = (wsize * 8 + 2) / 3;
1246         break;
1247     default:
1248     case 'x':
1249         max_digits = (wsize * 8) / 4;
1250         break;
1251     case 'u':
1252     case 'd':
1253         max_digits = (wsize * 8 * 10 + 32) / 33;
1254         break;
1255     case 'c':
1256         wsize = 1;
1257         break;
1258     }
1259
1260     while (len > 0) {
1261         if (is_physical)
1262             monitor_printf(mon, TARGET_FMT_plx ":", addr);
1263         else
1264             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1265         l = len;
1266         if (l > line_size)
1267             l = line_size;
1268         if (is_physical) {
1269             cpu_physical_memory_read(addr, buf, l);
1270         } else {
1271             if (cpu_memory_rw_debug(mon_get_cpu(), addr, buf, l, 0) < 0) {
1272                 monitor_printf(mon, " Cannot access memory\n");
1273                 break;
1274             }
1275         }
1276         i = 0;
1277         while (i < l) {
1278             switch(wsize) {
1279             default:
1280             case 1:
1281                 v = ldub_p(buf + i);
1282                 break;
1283             case 2:
1284                 v = lduw_p(buf + i);
1285                 break;
1286             case 4:
1287                 v = (uint32_t)ldl_p(buf + i);
1288                 break;
1289             case 8:
1290                 v = ldq_p(buf + i);
1291                 break;
1292             }
1293             monitor_printf(mon, " ");
1294             switch(format) {
1295             case 'o':
1296                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1297                 break;
1298             case 'x':
1299                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1300                 break;
1301             case 'u':
1302                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1303                 break;
1304             case 'd':
1305                 monitor_printf(mon, "%*" PRId64, max_digits, v);
1306                 break;
1307             case 'c':
1308                 monitor_printc(mon, v);
1309                 break;
1310             }
1311             i += wsize;
1312         }
1313         monitor_printf(mon, "\n");
1314         addr += l;
1315         len -= l;
1316     }
1317 }
1318
1319 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1320 {
1321     int count = qdict_get_int(qdict, "count");
1322     int format = qdict_get_int(qdict, "format");
1323     int size = qdict_get_int(qdict, "size");
1324     target_long addr = qdict_get_int(qdict, "addr");
1325
1326     memory_dump(mon, count, format, size, addr, 0);
1327 }
1328
1329 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1330 {
1331     int count = qdict_get_int(qdict, "count");
1332     int format = qdict_get_int(qdict, "format");
1333     int size = qdict_get_int(qdict, "size");
1334     hwaddr addr = qdict_get_int(qdict, "addr");
1335
1336     memory_dump(mon, count, format, size, addr, 1);
1337 }
1338
1339 static void do_print(Monitor *mon, const QDict *qdict)
1340 {
1341     int format = qdict_get_int(qdict, "format");
1342     hwaddr val = qdict_get_int(qdict, "val");
1343
1344     switch(format) {
1345     case 'o':
1346         monitor_printf(mon, "%#" HWADDR_PRIo, val);
1347         break;
1348     case 'x':
1349         monitor_printf(mon, "%#" HWADDR_PRIx, val);
1350         break;
1351     case 'u':
1352         monitor_printf(mon, "%" HWADDR_PRIu, val);
1353         break;
1354     default:
1355     case 'd':
1356         monitor_printf(mon, "%" HWADDR_PRId, val);
1357         break;
1358     case 'c':
1359         monitor_printc(mon, val);
1360         break;
1361     }
1362     monitor_printf(mon, "\n");
1363 }
1364
1365 static void hmp_sum(Monitor *mon, const QDict *qdict)
1366 {
1367     uint32_t addr;
1368     uint16_t sum;
1369     uint32_t start = qdict_get_int(qdict, "start");
1370     uint32_t size = qdict_get_int(qdict, "size");
1371
1372     sum = 0;
1373     for(addr = start; addr < (start + size); addr++) {
1374         uint8_t val = address_space_ldub(&address_space_memory, addr,
1375                                          MEMTXATTRS_UNSPECIFIED, NULL);
1376         /* BSD sum algorithm ('sum' Unix command) */
1377         sum = (sum >> 1) | (sum << 15);
1378         sum += val;
1379     }
1380     monitor_printf(mon, "%05d\n", sum);
1381 }
1382
1383 static int mouse_button_state;
1384
1385 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1386 {
1387     int dx, dy, dz, button;
1388     const char *dx_str = qdict_get_str(qdict, "dx_str");
1389     const char *dy_str = qdict_get_str(qdict, "dy_str");
1390     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1391
1392     dx = strtol(dx_str, NULL, 0);
1393     dy = strtol(dy_str, NULL, 0);
1394     qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1395     qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1396
1397     if (dz_str) {
1398         dz = strtol(dz_str, NULL, 0);
1399         if (dz != 0) {
1400             button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1401             qemu_input_queue_btn(NULL, button, true);
1402             qemu_input_event_sync();
1403             qemu_input_queue_btn(NULL, button, false);
1404         }
1405     }
1406     qemu_input_event_sync();
1407 }
1408
1409 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1410 {
1411     static uint32_t bmap[INPUT_BUTTON__MAX] = {
1412         [INPUT_BUTTON_LEFT]       = MOUSE_EVENT_LBUTTON,
1413         [INPUT_BUTTON_MIDDLE]     = MOUSE_EVENT_MBUTTON,
1414         [INPUT_BUTTON_RIGHT]      = MOUSE_EVENT_RBUTTON,
1415     };
1416     int button_state = qdict_get_int(qdict, "button_state");
1417
1418     if (mouse_button_state == button_state) {
1419         return;
1420     }
1421     qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1422     qemu_input_event_sync();
1423     mouse_button_state = button_state;
1424 }
1425
1426 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1427 {
1428     int size = qdict_get_int(qdict, "size");
1429     int addr = qdict_get_int(qdict, "addr");
1430     int has_index = qdict_haskey(qdict, "index");
1431     uint32_t val;
1432     int suffix;
1433
1434     if (has_index) {
1435         int index = qdict_get_int(qdict, "index");
1436         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1437         addr++;
1438     }
1439     addr &= 0xffff;
1440
1441     switch(size) {
1442     default:
1443     case 1:
1444         val = cpu_inb(addr);
1445         suffix = 'b';
1446         break;
1447     case 2:
1448         val = cpu_inw(addr);
1449         suffix = 'w';
1450         break;
1451     case 4:
1452         val = cpu_inl(addr);
1453         suffix = 'l';
1454         break;
1455     }
1456     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1457                    suffix, addr, size * 2, val);
1458 }
1459
1460 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1461 {
1462     int size = qdict_get_int(qdict, "size");
1463     int addr = qdict_get_int(qdict, "addr");
1464     int val = qdict_get_int(qdict, "val");
1465
1466     addr &= IOPORTS_MASK;
1467
1468     switch (size) {
1469     default:
1470     case 1:
1471         cpu_outb(addr, val);
1472         break;
1473     case 2:
1474         cpu_outw(addr, val);
1475         break;
1476     case 4:
1477         cpu_outl(addr, val);
1478         break;
1479     }
1480 }
1481
1482 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1483 {
1484     Error *local_err = NULL;
1485     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1486
1487     qemu_boot_set(bootdevice, &local_err);
1488     if (local_err) {
1489         error_report_err(local_err);
1490     } else {
1491         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1492     }
1493 }
1494
1495 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1496 {
1497     mtree_info((fprintf_function)monitor_printf, mon);
1498 }
1499
1500 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1501 {
1502     int i;
1503     CPUState *cpu;
1504     uint64_t *node_mem;
1505
1506     node_mem = g_new0(uint64_t, nb_numa_nodes);
1507     query_numa_node_mem(node_mem);
1508     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1509     for (i = 0; i < nb_numa_nodes; i++) {
1510         monitor_printf(mon, "node %d cpus:", i);
1511         CPU_FOREACH(cpu) {
1512             if (cpu->numa_node == i) {
1513                 monitor_printf(mon, " %d", cpu->cpu_index);
1514             }
1515         }
1516         monitor_printf(mon, "\n");
1517         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1518                        node_mem[i] >> 20);
1519     }
1520     g_free(node_mem);
1521 }
1522
1523 #ifdef CONFIG_PROFILER
1524
1525 int64_t tcg_time;
1526 int64_t dev_time;
1527
1528 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1529 {
1530     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
1531                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1532     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
1533                    tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
1534     tcg_time = 0;
1535     dev_time = 0;
1536 }
1537 #else
1538 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1539 {
1540     monitor_printf(mon, "Internal profiler not compiled\n");
1541 }
1542 #endif
1543
1544 /* Capture support */
1545 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1546
1547 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1548 {
1549     int i;
1550     CaptureState *s;
1551
1552     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1553         monitor_printf(mon, "[%d]: ", i);
1554         s->ops.info (s->opaque);
1555     }
1556 }
1557
1558 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1559 {
1560     int i;
1561     int n = qdict_get_int(qdict, "n");
1562     CaptureState *s;
1563
1564     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1565         if (i == n) {
1566             s->ops.destroy (s->opaque);
1567             QLIST_REMOVE (s, entries);
1568             g_free (s);
1569             return;
1570         }
1571     }
1572 }
1573
1574 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1575 {
1576     const char *path = qdict_get_str(qdict, "path");
1577     int has_freq = qdict_haskey(qdict, "freq");
1578     int freq = qdict_get_try_int(qdict, "freq", -1);
1579     int has_bits = qdict_haskey(qdict, "bits");
1580     int bits = qdict_get_try_int(qdict, "bits", -1);
1581     int has_channels = qdict_haskey(qdict, "nchannels");
1582     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1583     CaptureState *s;
1584
1585     s = g_malloc0 (sizeof (*s));
1586
1587     freq = has_freq ? freq : 44100;
1588     bits = has_bits ? bits : 16;
1589     nchannels = has_channels ? nchannels : 2;
1590
1591     if (wav_start_capture (s, path, freq, bits, nchannels)) {
1592         monitor_printf(mon, "Failed to add wave capture\n");
1593         g_free (s);
1594         return;
1595     }
1596     QLIST_INSERT_HEAD (&capture_head, s, entries);
1597 }
1598
1599 static qemu_acl *find_acl(Monitor *mon, const char *name)
1600 {
1601     qemu_acl *acl = qemu_acl_find(name);
1602
1603     if (!acl) {
1604         monitor_printf(mon, "acl: unknown list '%s'\n", name);
1605     }
1606     return acl;
1607 }
1608
1609 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1610 {
1611     const char *aclname = qdict_get_str(qdict, "aclname");
1612     qemu_acl *acl = find_acl(mon, aclname);
1613     qemu_acl_entry *entry;
1614     int i = 0;
1615
1616     if (acl) {
1617         monitor_printf(mon, "policy: %s\n",
1618                        acl->defaultDeny ? "deny" : "allow");
1619         QTAILQ_FOREACH(entry, &acl->entries, next) {
1620             i++;
1621             monitor_printf(mon, "%d: %s %s\n", i,
1622                            entry->deny ? "deny" : "allow", entry->match);
1623         }
1624     }
1625 }
1626
1627 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1628 {
1629     const char *aclname = qdict_get_str(qdict, "aclname");
1630     qemu_acl *acl = find_acl(mon, aclname);
1631
1632     if (acl) {
1633         qemu_acl_reset(acl);
1634         monitor_printf(mon, "acl: removed all rules\n");
1635     }
1636 }
1637
1638 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1639 {
1640     const char *aclname = qdict_get_str(qdict, "aclname");
1641     const char *policy = qdict_get_str(qdict, "policy");
1642     qemu_acl *acl = find_acl(mon, aclname);
1643
1644     if (acl) {
1645         if (strcmp(policy, "allow") == 0) {
1646             acl->defaultDeny = 0;
1647             monitor_printf(mon, "acl: policy set to 'allow'\n");
1648         } else if (strcmp(policy, "deny") == 0) {
1649             acl->defaultDeny = 1;
1650             monitor_printf(mon, "acl: policy set to 'deny'\n");
1651         } else {
1652             monitor_printf(mon, "acl: unknown policy '%s', "
1653                            "expected 'deny' or 'allow'\n", policy);
1654         }
1655     }
1656 }
1657
1658 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1659 {
1660     const char *aclname = qdict_get_str(qdict, "aclname");
1661     const char *match = qdict_get_str(qdict, "match");
1662     const char *policy = qdict_get_str(qdict, "policy");
1663     int has_index = qdict_haskey(qdict, "index");
1664     int index = qdict_get_try_int(qdict, "index", -1);
1665     qemu_acl *acl = find_acl(mon, aclname);
1666     int deny, ret;
1667
1668     if (acl) {
1669         if (strcmp(policy, "allow") == 0) {
1670             deny = 0;
1671         } else if (strcmp(policy, "deny") == 0) {
1672             deny = 1;
1673         } else {
1674             monitor_printf(mon, "acl: unknown policy '%s', "
1675                            "expected 'deny' or 'allow'\n", policy);
1676             return;
1677         }
1678         if (has_index)
1679             ret = qemu_acl_insert(acl, deny, match, index);
1680         else
1681             ret = qemu_acl_append(acl, deny, match);
1682         if (ret < 0)
1683             monitor_printf(mon, "acl: unable to add acl entry\n");
1684         else
1685             monitor_printf(mon, "acl: added rule at position %d\n", ret);
1686     }
1687 }
1688
1689 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1690 {
1691     const char *aclname = qdict_get_str(qdict, "aclname");
1692     const char *match = qdict_get_str(qdict, "match");
1693     qemu_acl *acl = find_acl(mon, aclname);
1694     int ret;
1695
1696     if (acl) {
1697         ret = qemu_acl_remove(acl, match);
1698         if (ret < 0)
1699             monitor_printf(mon, "acl: no matching acl entry\n");
1700         else
1701             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
1702     }
1703 }
1704
1705 void qmp_getfd(const char *fdname, Error **errp)
1706 {
1707     mon_fd_t *monfd;
1708     int fd;
1709
1710     fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
1711     if (fd == -1) {
1712         error_setg(errp, QERR_FD_NOT_SUPPLIED);
1713         return;
1714     }
1715
1716     if (qemu_isdigit(fdname[0])) {
1717         close(fd);
1718         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1719                    "a name not starting with a digit");
1720         return;
1721     }
1722
1723     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1724         if (strcmp(monfd->name, fdname) != 0) {
1725             continue;
1726         }
1727
1728         close(monfd->fd);
1729         monfd->fd = fd;
1730         return;
1731     }
1732
1733     monfd = g_malloc0(sizeof(mon_fd_t));
1734     monfd->name = g_strdup(fdname);
1735     monfd->fd = fd;
1736
1737     QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1738 }
1739
1740 void qmp_closefd(const char *fdname, Error **errp)
1741 {
1742     mon_fd_t *monfd;
1743
1744     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1745         if (strcmp(monfd->name, fdname) != 0) {
1746             continue;
1747         }
1748
1749         QLIST_REMOVE(monfd, next);
1750         close(monfd->fd);
1751         g_free(monfd->name);
1752         g_free(monfd);
1753         return;
1754     }
1755
1756     error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1757 }
1758
1759 static void hmp_loadvm(Monitor *mon, const QDict *qdict)
1760 {
1761     int saved_vm_running  = runstate_is_running();
1762     const char *name = qdict_get_str(qdict, "name");
1763
1764     vm_stop(RUN_STATE_RESTORE_VM);
1765
1766     if (load_vmstate(name) == 0 && saved_vm_running) {
1767         vm_start();
1768     }
1769 }
1770
1771 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1772 {
1773     mon_fd_t *monfd;
1774
1775     QLIST_FOREACH(monfd, &mon->fds, next) {
1776         int fd;
1777
1778         if (strcmp(monfd->name, fdname) != 0) {
1779             continue;
1780         }
1781
1782         fd = monfd->fd;
1783
1784         /* caller takes ownership of fd */
1785         QLIST_REMOVE(monfd, next);
1786         g_free(monfd->name);
1787         g_free(monfd);
1788
1789         return fd;
1790     }
1791
1792     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1793     return -1;
1794 }
1795
1796 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1797 {
1798     MonFdsetFd *mon_fdset_fd;
1799     MonFdsetFd *mon_fdset_fd_next;
1800
1801     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1802         if ((mon_fdset_fd->removed ||
1803                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1804                 runstate_is_running()) {
1805             close(mon_fdset_fd->fd);
1806             g_free(mon_fdset_fd->opaque);
1807             QLIST_REMOVE(mon_fdset_fd, next);
1808             g_free(mon_fdset_fd);
1809         }
1810     }
1811
1812     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
1813         QLIST_REMOVE(mon_fdset, next);
1814         g_free(mon_fdset);
1815     }
1816 }
1817
1818 static void monitor_fdsets_cleanup(void)
1819 {
1820     MonFdset *mon_fdset;
1821     MonFdset *mon_fdset_next;
1822
1823     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1824         monitor_fdset_cleanup(mon_fdset);
1825     }
1826 }
1827
1828 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1829                       const char *opaque, Error **errp)
1830 {
1831     int fd;
1832     Monitor *mon = cur_mon;
1833     AddfdInfo *fdinfo;
1834
1835     fd = qemu_chr_fe_get_msgfd(mon->chr);
1836     if (fd == -1) {
1837         error_setg(errp, QERR_FD_NOT_SUPPLIED);
1838         goto error;
1839     }
1840
1841     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1842                                   has_opaque, opaque, errp);
1843     if (fdinfo) {
1844         return fdinfo;
1845     }
1846
1847 error:
1848     if (fd != -1) {
1849         close(fd);
1850     }
1851     return NULL;
1852 }
1853
1854 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1855 {
1856     MonFdset *mon_fdset;
1857     MonFdsetFd *mon_fdset_fd;
1858     char fd_str[60];
1859
1860     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1861         if (mon_fdset->id != fdset_id) {
1862             continue;
1863         }
1864         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1865             if (has_fd) {
1866                 if (mon_fdset_fd->fd != fd) {
1867                     continue;
1868                 }
1869                 mon_fdset_fd->removed = true;
1870                 break;
1871             } else {
1872                 mon_fdset_fd->removed = true;
1873             }
1874         }
1875         if (has_fd && !mon_fdset_fd) {
1876             goto error;
1877         }
1878         monitor_fdset_cleanup(mon_fdset);
1879         return;
1880     }
1881
1882 error:
1883     if (has_fd) {
1884         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1885                  fdset_id, fd);
1886     } else {
1887         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1888     }
1889     error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
1890 }
1891
1892 FdsetInfoList *qmp_query_fdsets(Error **errp)
1893 {
1894     MonFdset *mon_fdset;
1895     MonFdsetFd *mon_fdset_fd;
1896     FdsetInfoList *fdset_list = NULL;
1897
1898     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1899         FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
1900         FdsetFdInfoList *fdsetfd_list = NULL;
1901
1902         fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
1903         fdset_info->value->fdset_id = mon_fdset->id;
1904
1905         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1906             FdsetFdInfoList *fdsetfd_info;
1907
1908             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
1909             fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
1910             fdsetfd_info->value->fd = mon_fdset_fd->fd;
1911             if (mon_fdset_fd->opaque) {
1912                 fdsetfd_info->value->has_opaque = true;
1913                 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
1914             } else {
1915                 fdsetfd_info->value->has_opaque = false;
1916             }
1917
1918             fdsetfd_info->next = fdsetfd_list;
1919             fdsetfd_list = fdsetfd_info;
1920         }
1921
1922         fdset_info->value->fds = fdsetfd_list;
1923
1924         fdset_info->next = fdset_list;
1925         fdset_list = fdset_info;
1926     }
1927
1928     return fdset_list;
1929 }
1930
1931 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
1932                                 bool has_opaque, const char *opaque,
1933                                 Error **errp)
1934 {
1935     MonFdset *mon_fdset = NULL;
1936     MonFdsetFd *mon_fdset_fd;
1937     AddfdInfo *fdinfo;
1938
1939     if (has_fdset_id) {
1940         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1941             /* Break if match found or match impossible due to ordering by ID */
1942             if (fdset_id <= mon_fdset->id) {
1943                 if (fdset_id < mon_fdset->id) {
1944                     mon_fdset = NULL;
1945                 }
1946                 break;
1947             }
1948         }
1949     }
1950
1951     if (mon_fdset == NULL) {
1952         int64_t fdset_id_prev = -1;
1953         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
1954
1955         if (has_fdset_id) {
1956             if (fdset_id < 0) {
1957                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
1958                            "a non-negative value");
1959                 return NULL;
1960             }
1961             /* Use specified fdset ID */
1962             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1963                 mon_fdset_cur = mon_fdset;
1964                 if (fdset_id < mon_fdset_cur->id) {
1965                     break;
1966                 }
1967             }
1968         } else {
1969             /* Use first available fdset ID */
1970             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1971                 mon_fdset_cur = mon_fdset;
1972                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
1973                     fdset_id_prev = mon_fdset_cur->id;
1974                     continue;
1975                 }
1976                 break;
1977             }
1978         }
1979
1980         mon_fdset = g_malloc0(sizeof(*mon_fdset));
1981         if (has_fdset_id) {
1982             mon_fdset->id = fdset_id;
1983         } else {
1984             mon_fdset->id = fdset_id_prev + 1;
1985         }
1986
1987         /* The fdset list is ordered by fdset ID */
1988         if (!mon_fdset_cur) {
1989             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
1990         } else if (mon_fdset->id < mon_fdset_cur->id) {
1991             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
1992         } else {
1993             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
1994         }
1995     }
1996
1997     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
1998     mon_fdset_fd->fd = fd;
1999     mon_fdset_fd->removed = false;
2000     if (has_opaque) {
2001         mon_fdset_fd->opaque = g_strdup(opaque);
2002     }
2003     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2004
2005     fdinfo = g_malloc0(sizeof(*fdinfo));
2006     fdinfo->fdset_id = mon_fdset->id;
2007     fdinfo->fd = mon_fdset_fd->fd;
2008
2009     return fdinfo;
2010 }
2011
2012 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2013 {
2014 #ifndef _WIN32
2015     MonFdset *mon_fdset;
2016     MonFdsetFd *mon_fdset_fd;
2017     int mon_fd_flags;
2018
2019     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2020         if (mon_fdset->id != fdset_id) {
2021             continue;
2022         }
2023         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2024             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2025             if (mon_fd_flags == -1) {
2026                 return -1;
2027             }
2028
2029             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2030                 return mon_fdset_fd->fd;
2031             }
2032         }
2033         errno = EACCES;
2034         return -1;
2035     }
2036 #endif
2037
2038     errno = ENOENT;
2039     return -1;
2040 }
2041
2042 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2043 {
2044     MonFdset *mon_fdset;
2045     MonFdsetFd *mon_fdset_fd_dup;
2046
2047     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2048         if (mon_fdset->id != fdset_id) {
2049             continue;
2050         }
2051         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2052             if (mon_fdset_fd_dup->fd == dup_fd) {
2053                 return -1;
2054             }
2055         }
2056         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2057         mon_fdset_fd_dup->fd = dup_fd;
2058         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2059         return 0;
2060     }
2061     return -1;
2062 }
2063
2064 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2065 {
2066     MonFdset *mon_fdset;
2067     MonFdsetFd *mon_fdset_fd_dup;
2068
2069     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2070         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2071             if (mon_fdset_fd_dup->fd == dup_fd) {
2072                 if (remove) {
2073                     QLIST_REMOVE(mon_fdset_fd_dup, next);
2074                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2075                         monitor_fdset_cleanup(mon_fdset);
2076                     }
2077                     return -1;
2078                 } else {
2079                     return mon_fdset->id;
2080                 }
2081             }
2082         }
2083     }
2084     return -1;
2085 }
2086
2087 int monitor_fdset_dup_fd_find(int dup_fd)
2088 {
2089     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2090 }
2091
2092 void monitor_fdset_dup_fd_remove(int dup_fd)
2093 {
2094     monitor_fdset_dup_fd_find_remove(dup_fd, true);
2095 }
2096
2097 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2098 {
2099     int fd;
2100     Error *local_err = NULL;
2101
2102     if (!qemu_isdigit(fdname[0]) && mon) {
2103         fd = monitor_get_fd(mon, fdname, &local_err);
2104     } else {
2105         fd = qemu_parse_fd(fdname);
2106         if (fd == -1) {
2107             error_setg(&local_err, "Invalid file descriptor number '%s'",
2108                        fdname);
2109         }
2110     }
2111     if (local_err) {
2112         error_propagate(errp, local_err);
2113         assert(fd == -1);
2114     } else {
2115         assert(fd != -1);
2116     }
2117
2118     return fd;
2119 }
2120
2121 /* Please update hmp-commands.hx when adding or changing commands */
2122 static mon_cmd_t info_cmds[] = {
2123 #include "hmp-commands-info.h"
2124     { NULL, NULL, },
2125 };
2126
2127 /* mon_cmds and info_cmds would be sorted at runtime */
2128 static mon_cmd_t mon_cmds[] = {
2129 #include "hmp-commands.h"
2130     { NULL, NULL, },
2131 };
2132
2133 static const mon_cmd_t qmp_cmds[] = {
2134 #include "qmp-commands-old.h"
2135     { /* NULL */ },
2136 };
2137
2138 /*******************************************************************/
2139
2140 static const char *pch;
2141 static sigjmp_buf expr_env;
2142
2143
2144 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2145 expr_error(Monitor *mon, const char *fmt, ...)
2146 {
2147     va_list ap;
2148     va_start(ap, fmt);
2149     monitor_vprintf(mon, fmt, ap);
2150     monitor_printf(mon, "\n");
2151     va_end(ap);
2152     siglongjmp(expr_env, 1);
2153 }
2154
2155 /* return 0 if OK, -1 if not found */
2156 static int get_monitor_def(target_long *pval, const char *name)
2157 {
2158     const MonitorDef *md = target_monitor_defs();
2159     void *ptr;
2160     uint64_t tmp = 0;
2161     int ret;
2162
2163     if (md == NULL) {
2164         return -1;
2165     }
2166
2167     for(; md->name != NULL; md++) {
2168         if (compare_cmd(name, md->name)) {
2169             if (md->get_value) {
2170                 *pval = md->get_value(md, md->offset);
2171             } else {
2172                 CPUArchState *env = mon_get_cpu_env();
2173                 ptr = (uint8_t *)env + md->offset;
2174                 switch(md->type) {
2175                 case MD_I32:
2176                     *pval = *(int32_t *)ptr;
2177                     break;
2178                 case MD_TLONG:
2179                     *pval = *(target_long *)ptr;
2180                     break;
2181                 default:
2182                     *pval = 0;
2183                     break;
2184                 }
2185             }
2186             return 0;
2187         }
2188     }
2189
2190     ret = target_get_monitor_def(mon_get_cpu(), name, &tmp);
2191     if (!ret) {
2192         *pval = (target_long) tmp;
2193     }
2194
2195     return ret;
2196 }
2197
2198 static void next(void)
2199 {
2200     if (*pch != '\0') {
2201         pch++;
2202         while (qemu_isspace(*pch))
2203             pch++;
2204     }
2205 }
2206
2207 static int64_t expr_sum(Monitor *mon);
2208
2209 static int64_t expr_unary(Monitor *mon)
2210 {
2211     int64_t n;
2212     char *p;
2213     int ret;
2214
2215     switch(*pch) {
2216     case '+':
2217         next();
2218         n = expr_unary(mon);
2219         break;
2220     case '-':
2221         next();
2222         n = -expr_unary(mon);
2223         break;
2224     case '~':
2225         next();
2226         n = ~expr_unary(mon);
2227         break;
2228     case '(':
2229         next();
2230         n = expr_sum(mon);
2231         if (*pch != ')') {
2232             expr_error(mon, "')' expected");
2233         }
2234         next();
2235         break;
2236     case '\'':
2237         pch++;
2238         if (*pch == '\0')
2239             expr_error(mon, "character constant expected");
2240         n = *pch;
2241         pch++;
2242         if (*pch != '\'')
2243             expr_error(mon, "missing terminating \' character");
2244         next();
2245         break;
2246     case '$':
2247         {
2248             char buf[128], *q;
2249             target_long reg=0;
2250
2251             pch++;
2252             q = buf;
2253             while ((*pch >= 'a' && *pch <= 'z') ||
2254                    (*pch >= 'A' && *pch <= 'Z') ||
2255                    (*pch >= '0' && *pch <= '9') ||
2256                    *pch == '_' || *pch == '.') {
2257                 if ((q - buf) < sizeof(buf) - 1)
2258                     *q++ = *pch;
2259                 pch++;
2260             }
2261             while (qemu_isspace(*pch))
2262                 pch++;
2263             *q = 0;
2264             ret = get_monitor_def(&reg, buf);
2265             if (ret < 0)
2266                 expr_error(mon, "unknown register");
2267             n = reg;
2268         }
2269         break;
2270     case '\0':
2271         expr_error(mon, "unexpected end of expression");
2272         n = 0;
2273         break;
2274     default:
2275         errno = 0;
2276         n = strtoull(pch, &p, 0);
2277         if (errno == ERANGE) {
2278             expr_error(mon, "number too large");
2279         }
2280         if (pch == p) {
2281             expr_error(mon, "invalid char '%c' in expression", *p);
2282         }
2283         pch = p;
2284         while (qemu_isspace(*pch))
2285             pch++;
2286         break;
2287     }
2288     return n;
2289 }
2290
2291
2292 static int64_t expr_prod(Monitor *mon)
2293 {
2294     int64_t val, val2;
2295     int op;
2296
2297     val = expr_unary(mon);
2298     for(;;) {
2299         op = *pch;
2300         if (op != '*' && op != '/' && op != '%')
2301             break;
2302         next();
2303         val2 = expr_unary(mon);
2304         switch(op) {
2305         default:
2306         case '*':
2307             val *= val2;
2308             break;
2309         case '/':
2310         case '%':
2311             if (val2 == 0)
2312                 expr_error(mon, "division by zero");
2313             if (op == '/')
2314                 val /= val2;
2315             else
2316                 val %= val2;
2317             break;
2318         }
2319     }
2320     return val;
2321 }
2322
2323 static int64_t expr_logic(Monitor *mon)
2324 {
2325     int64_t val, val2;
2326     int op;
2327
2328     val = expr_prod(mon);
2329     for(;;) {
2330         op = *pch;
2331         if (op != '&' && op != '|' && op != '^')
2332             break;
2333         next();
2334         val2 = expr_prod(mon);
2335         switch(op) {
2336         default:
2337         case '&':
2338             val &= val2;
2339             break;
2340         case '|':
2341             val |= val2;
2342             break;
2343         case '^':
2344             val ^= val2;
2345             break;
2346         }
2347     }
2348     return val;
2349 }
2350
2351 static int64_t expr_sum(Monitor *mon)
2352 {
2353     int64_t val, val2;
2354     int op;
2355
2356     val = expr_logic(mon);
2357     for(;;) {
2358         op = *pch;
2359         if (op != '+' && op != '-')
2360             break;
2361         next();
2362         val2 = expr_logic(mon);
2363         if (op == '+')
2364             val += val2;
2365         else
2366             val -= val2;
2367     }
2368     return val;
2369 }
2370
2371 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2372 {
2373     pch = *pp;
2374     if (sigsetjmp(expr_env, 0)) {
2375         *pp = pch;
2376         return -1;
2377     }
2378     while (qemu_isspace(*pch))
2379         pch++;
2380     *pval = expr_sum(mon);
2381     *pp = pch;
2382     return 0;
2383 }
2384
2385 static int get_double(Monitor *mon, double *pval, const char **pp)
2386 {
2387     const char *p = *pp;
2388     char *tailp;
2389     double d;
2390
2391     d = strtod(p, &tailp);
2392     if (tailp == p) {
2393         monitor_printf(mon, "Number expected\n");
2394         return -1;
2395     }
2396     if (d != d || d - d != 0) {
2397         /* NaN or infinity */
2398         monitor_printf(mon, "Bad number\n");
2399         return -1;
2400     }
2401     *pval = d;
2402     *pp = tailp;
2403     return 0;
2404 }
2405
2406 /*
2407  * Store the command-name in cmdname, and return a pointer to
2408  * the remaining of the command string.
2409  */
2410 static const char *get_command_name(const char *cmdline,
2411                                     char *cmdname, size_t nlen)
2412 {
2413     size_t len;
2414     const char *p, *pstart;
2415
2416     p = cmdline;
2417     while (qemu_isspace(*p))
2418         p++;
2419     if (*p == '\0')
2420         return NULL;
2421     pstart = p;
2422     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2423         p++;
2424     len = p - pstart;
2425     if (len > nlen - 1)
2426         len = nlen - 1;
2427     memcpy(cmdname, pstart, len);
2428     cmdname[len] = '\0';
2429     return p;
2430 }
2431
2432 /**
2433  * Read key of 'type' into 'key' and return the current
2434  * 'type' pointer.
2435  */
2436 static char *key_get_info(const char *type, char **key)
2437 {
2438     size_t len;
2439     char *p, *str;
2440
2441     if (*type == ',')
2442         type++;
2443
2444     p = strchr(type, ':');
2445     if (!p) {
2446         *key = NULL;
2447         return NULL;
2448     }
2449     len = p - type;
2450
2451     str = g_malloc(len + 1);
2452     memcpy(str, type, len);
2453     str[len] = '\0';
2454
2455     *key = str;
2456     return ++p;
2457 }
2458
2459 static int default_fmt_format = 'x';
2460 static int default_fmt_size = 4;
2461
2462 static int is_valid_option(const char *c, const char *typestr)
2463 {
2464     char option[3];
2465
2466     option[0] = '-';
2467     option[1] = *c;
2468     option[2] = '\0';
2469
2470     typestr = strstr(typestr, option);
2471     return (typestr != NULL);
2472 }
2473
2474 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2475                                               const char *cmdname)
2476 {
2477     const mon_cmd_t *cmd;
2478
2479     for (cmd = disp_table; cmd->name != NULL; cmd++) {
2480         if (compare_cmd(cmdname, cmd->name)) {
2481             return cmd;
2482         }
2483     }
2484
2485     return NULL;
2486 }
2487
2488 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
2489 {
2490     return search_dispatch_table(qmp_cmds, cmdname);
2491 }
2492
2493 /*
2494  * Parse command name from @cmdp according to command table @table.
2495  * If blank, return NULL.
2496  * Else, if no valid command can be found, report to @mon, and return
2497  * NULL.
2498  * Else, change @cmdp to point right behind the name, and return its
2499  * command table entry.
2500  * Do not assume the return value points into @table!  It doesn't when
2501  * the command is found in a sub-command table.
2502  */
2503 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2504                                               const char **cmdp,
2505                                               mon_cmd_t *table)
2506 {
2507     const char *p;
2508     const mon_cmd_t *cmd;
2509     char cmdname[256];
2510
2511     /* extract the command name */
2512     p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2513     if (!p)
2514         return NULL;
2515
2516     cmd = search_dispatch_table(table, cmdname);
2517     if (!cmd) {
2518         monitor_printf(mon, "unknown command: '%.*s'\n",
2519                        (int)(p - *cmdp), *cmdp);
2520         return NULL;
2521     }
2522
2523     /* filter out following useless space */
2524     while (qemu_isspace(*p)) {
2525         p++;
2526     }
2527
2528     *cmdp = p;
2529     /* search sub command */
2530     if (cmd->sub_table != NULL && *p != '\0') {
2531         return monitor_parse_command(mon, cmdp, cmd->sub_table);
2532     }
2533
2534     return cmd;
2535 }
2536
2537 /*
2538  * Parse arguments for @cmd.
2539  * If it can't be parsed, report to @mon, and return NULL.
2540  * Else, insert command arguments into a QDict, and return it.
2541  * Note: On success, caller has to free the QDict structure.
2542  */
2543
2544 static QDict *monitor_parse_arguments(Monitor *mon,
2545                                       const char **endp,
2546                                       const mon_cmd_t *cmd)
2547 {
2548     const char *typestr;
2549     char *key;
2550     int c;
2551     const char *p = *endp;
2552     char buf[1024];
2553     QDict *qdict = qdict_new();
2554
2555     /* parse the parameters */
2556     typestr = cmd->args_type;
2557     for(;;) {
2558         typestr = key_get_info(typestr, &key);
2559         if (!typestr)
2560             break;
2561         c = *typestr;
2562         typestr++;
2563         switch(c) {
2564         case 'F':
2565         case 'B':
2566         case 's':
2567             {
2568                 int ret;
2569
2570                 while (qemu_isspace(*p))
2571                     p++;
2572                 if (*typestr == '?') {
2573                     typestr++;
2574                     if (*p == '\0') {
2575                         /* no optional string: NULL argument */
2576                         break;
2577                     }
2578                 }
2579                 ret = get_str(buf, sizeof(buf), &p);
2580                 if (ret < 0) {
2581                     switch(c) {
2582                     case 'F':
2583                         monitor_printf(mon, "%s: filename expected\n",
2584                                        cmd->name);
2585                         break;
2586                     case 'B':
2587                         monitor_printf(mon, "%s: block device name expected\n",
2588                                        cmd->name);
2589                         break;
2590                     default:
2591                         monitor_printf(mon, "%s: string expected\n", cmd->name);
2592                         break;
2593                     }
2594                     goto fail;
2595                 }
2596                 qdict_put(qdict, key, qstring_from_str(buf));
2597             }
2598             break;
2599         case 'O':
2600             {
2601                 QemuOptsList *opts_list;
2602                 QemuOpts *opts;
2603
2604                 opts_list = qemu_find_opts(key);
2605                 if (!opts_list || opts_list->desc->name) {
2606                     goto bad_type;
2607                 }
2608                 while (qemu_isspace(*p)) {
2609                     p++;
2610                 }
2611                 if (!*p)
2612                     break;
2613                 if (get_str(buf, sizeof(buf), &p) < 0) {
2614                     goto fail;
2615                 }
2616                 opts = qemu_opts_parse_noisily(opts_list, buf, true);
2617                 if (!opts) {
2618                     goto fail;
2619                 }
2620                 qemu_opts_to_qdict(opts, qdict);
2621                 qemu_opts_del(opts);
2622             }
2623             break;
2624         case '/':
2625             {
2626                 int count, format, size;
2627
2628                 while (qemu_isspace(*p))
2629                     p++;
2630                 if (*p == '/') {
2631                     /* format found */
2632                     p++;
2633                     count = 1;
2634                     if (qemu_isdigit(*p)) {
2635                         count = 0;
2636                         while (qemu_isdigit(*p)) {
2637                             count = count * 10 + (*p - '0');
2638                             p++;
2639                         }
2640                     }
2641                     size = -1;
2642                     format = -1;
2643                     for(;;) {
2644                         switch(*p) {
2645                         case 'o':
2646                         case 'd':
2647                         case 'u':
2648                         case 'x':
2649                         case 'i':
2650                         case 'c':
2651                             format = *p++;
2652                             break;
2653                         case 'b':
2654                             size = 1;
2655                             p++;
2656                             break;
2657                         case 'h':
2658                             size = 2;
2659                             p++;
2660                             break;
2661                         case 'w':
2662                             size = 4;
2663                             p++;
2664                             break;
2665                         case 'g':
2666                         case 'L':
2667                             size = 8;
2668                             p++;
2669                             break;
2670                         default:
2671                             goto next;
2672                         }
2673                     }
2674                 next:
2675                     if (*p != '\0' && !qemu_isspace(*p)) {
2676                         monitor_printf(mon, "invalid char in format: '%c'\n",
2677                                        *p);
2678                         goto fail;
2679                     }
2680                     if (format < 0)
2681                         format = default_fmt_format;
2682                     if (format != 'i') {
2683                         /* for 'i', not specifying a size gives -1 as size */
2684                         if (size < 0)
2685                             size = default_fmt_size;
2686                         default_fmt_size = size;
2687                     }
2688                     default_fmt_format = format;
2689                 } else {
2690                     count = 1;
2691                     format = default_fmt_format;
2692                     if (format != 'i') {
2693                         size = default_fmt_size;
2694                     } else {
2695                         size = -1;
2696                     }
2697                 }
2698                 qdict_put(qdict, "count", qint_from_int(count));
2699                 qdict_put(qdict, "format", qint_from_int(format));
2700                 qdict_put(qdict, "size", qint_from_int(size));
2701             }
2702             break;
2703         case 'i':
2704         case 'l':
2705         case 'M':
2706             {
2707                 int64_t val;
2708
2709                 while (qemu_isspace(*p))
2710                     p++;
2711                 if (*typestr == '?' || *typestr == '.') {
2712                     if (*typestr == '?') {
2713                         if (*p == '\0') {
2714                             typestr++;
2715                             break;
2716                         }
2717                     } else {
2718                         if (*p == '.') {
2719                             p++;
2720                             while (qemu_isspace(*p))
2721                                 p++;
2722                         } else {
2723                             typestr++;
2724                             break;
2725                         }
2726                     }
2727                     typestr++;
2728                 }
2729                 if (get_expr(mon, &val, &p))
2730                     goto fail;
2731                 /* Check if 'i' is greater than 32-bit */
2732                 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2733                     monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
2734                     monitor_printf(mon, "integer is for 32-bit values\n");
2735                     goto fail;
2736                 } else if (c == 'M') {
2737                     if (val < 0) {
2738                         monitor_printf(mon, "enter a positive value\n");
2739                         goto fail;
2740                     }
2741                     val <<= 20;
2742                 }
2743                 qdict_put(qdict, key, qint_from_int(val));
2744             }
2745             break;
2746         case 'o':
2747             {
2748                 int64_t val;
2749                 char *end;
2750
2751                 while (qemu_isspace(*p)) {
2752                     p++;
2753                 }
2754                 if (*typestr == '?') {
2755                     typestr++;
2756                     if (*p == '\0') {
2757                         break;
2758                     }
2759                 }
2760                 val = qemu_strtosz(p, &end);
2761                 if (val < 0) {
2762                     monitor_printf(mon, "invalid size\n");
2763                     goto fail;
2764                 }
2765                 qdict_put(qdict, key, qint_from_int(val));
2766                 p = end;
2767             }
2768             break;
2769         case 'T':
2770             {
2771                 double val;
2772
2773                 while (qemu_isspace(*p))
2774                     p++;
2775                 if (*typestr == '?') {
2776                     typestr++;
2777                     if (*p == '\0') {
2778                         break;
2779                     }
2780                 }
2781                 if (get_double(mon, &val, &p) < 0) {
2782                     goto fail;
2783                 }
2784                 if (p[0] && p[1] == 's') {
2785                     switch (*p) {
2786                     case 'm':
2787                         val /= 1e3; p += 2; break;
2788                     case 'u':
2789                         val /= 1e6; p += 2; break;
2790                     case 'n':
2791                         val /= 1e9; p += 2; break;
2792                     }
2793                 }
2794                 if (*p && !qemu_isspace(*p)) {
2795                     monitor_printf(mon, "Unknown unit suffix\n");
2796                     goto fail;
2797                 }
2798                 qdict_put(qdict, key, qfloat_from_double(val));
2799             }
2800             break;
2801         case 'b':
2802             {
2803                 const char *beg;
2804                 bool val;
2805
2806                 while (qemu_isspace(*p)) {
2807                     p++;
2808                 }
2809                 beg = p;
2810                 while (qemu_isgraph(*p)) {
2811                     p++;
2812                 }
2813                 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
2814                     val = true;
2815                 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
2816                     val = false;
2817                 } else {
2818                     monitor_printf(mon, "Expected 'on' or 'off'\n");
2819                     goto fail;
2820                 }
2821                 qdict_put(qdict, key, qbool_from_bool(val));
2822             }
2823             break;
2824         case '-':
2825             {
2826                 const char *tmp = p;
2827                 int skip_key = 0;
2828                 /* option */
2829
2830                 c = *typestr++;
2831                 if (c == '\0')
2832                     goto bad_type;
2833                 while (qemu_isspace(*p))
2834                     p++;
2835                 if (*p == '-') {
2836                     p++;
2837                     if(c != *p) {
2838                         if(!is_valid_option(p, typestr)) {
2839
2840                             monitor_printf(mon, "%s: unsupported option -%c\n",
2841                                            cmd->name, *p);
2842                             goto fail;
2843                         } else {
2844                             skip_key = 1;
2845                         }
2846                     }
2847                     if(skip_key) {
2848                         p = tmp;
2849                     } else {
2850                         /* has option */
2851                         p++;
2852                         qdict_put(qdict, key, qbool_from_bool(true));
2853                     }
2854                 }
2855             }
2856             break;
2857         case 'S':
2858             {
2859                 /* package all remaining string */
2860                 int len;
2861
2862                 while (qemu_isspace(*p)) {
2863                     p++;
2864                 }
2865                 if (*typestr == '?') {
2866                     typestr++;
2867                     if (*p == '\0') {
2868                         /* no remaining string: NULL argument */
2869                         break;
2870                     }
2871                 }
2872                 len = strlen(p);
2873                 if (len <= 0) {
2874                     monitor_printf(mon, "%s: string expected\n",
2875                                    cmd->name);
2876                     goto fail;
2877                 }
2878                 qdict_put(qdict, key, qstring_from_str(p));
2879                 p += len;
2880             }
2881             break;
2882         default:
2883         bad_type:
2884             monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
2885             goto fail;
2886         }
2887         g_free(key);
2888         key = NULL;
2889     }
2890     /* check that all arguments were parsed */
2891     while (qemu_isspace(*p))
2892         p++;
2893     if (*p != '\0') {
2894         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
2895                        cmd->name);
2896         goto fail;
2897     }
2898
2899     return qdict;
2900
2901 fail:
2902     QDECREF(qdict);
2903     g_free(key);
2904     return NULL;
2905 }
2906
2907 static void handle_hmp_command(Monitor *mon, const char *cmdline)
2908 {
2909     QDict *qdict;
2910     const mon_cmd_t *cmd;
2911
2912     cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
2913     if (!cmd) {
2914         return;
2915     }
2916
2917     qdict = monitor_parse_arguments(mon, &cmdline, cmd);
2918     if (!qdict) {
2919         monitor_printf(mon, "Try \"help %s\" for more information\n",
2920                        cmd->name);
2921         return;
2922     }
2923
2924     cmd->mhandler.cmd(mon, qdict);
2925     QDECREF(qdict);
2926 }
2927
2928 static void cmd_completion(Monitor *mon, const char *name, const char *list)
2929 {
2930     const char *p, *pstart;
2931     char cmd[128];
2932     int len;
2933
2934     p = list;
2935     for(;;) {
2936         pstart = p;
2937         p = strchr(p, '|');
2938         if (!p)
2939             p = pstart + strlen(pstart);
2940         len = p - pstart;
2941         if (len > sizeof(cmd) - 2)
2942             len = sizeof(cmd) - 2;
2943         memcpy(cmd, pstart, len);
2944         cmd[len] = '\0';
2945         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
2946             readline_add_completion(mon->rs, cmd);
2947         }
2948         if (*p == '\0')
2949             break;
2950         p++;
2951     }
2952 }
2953
2954 static void file_completion(Monitor *mon, const char *input)
2955 {
2956     DIR *ffs;
2957     struct dirent *d;
2958     char path[1024];
2959     char file[1024], file_prefix[1024];
2960     int input_path_len;
2961     const char *p;
2962
2963     p = strrchr(input, '/');
2964     if (!p) {
2965         input_path_len = 0;
2966         pstrcpy(file_prefix, sizeof(file_prefix), input);
2967         pstrcpy(path, sizeof(path), ".");
2968     } else {
2969         input_path_len = p - input + 1;
2970         memcpy(path, input, input_path_len);
2971         if (input_path_len > sizeof(path) - 1)
2972             input_path_len = sizeof(path) - 1;
2973         path[input_path_len] = '\0';
2974         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
2975     }
2976
2977     ffs = opendir(path);
2978     if (!ffs)
2979         return;
2980     for(;;) {
2981         struct stat sb;
2982         d = readdir(ffs);
2983         if (!d)
2984             break;
2985
2986         if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
2987             continue;
2988         }
2989
2990         if (strstart(d->d_name, file_prefix, NULL)) {
2991             memcpy(file, input, input_path_len);
2992             if (input_path_len < sizeof(file))
2993                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
2994                         d->d_name);
2995             /* stat the file to find out if it's a directory.
2996              * In that case add a slash to speed up typing long paths
2997              */
2998             if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
2999                 pstrcat(file, sizeof(file), "/");
3000             }
3001             readline_add_completion(mon->rs, file);
3002         }
3003     }
3004     closedir(ffs);
3005 }
3006
3007 static const char *next_arg_type(const char *typestr)
3008 {
3009     const char *p = strchr(typestr, ':');
3010     return (p != NULL ? ++p : typestr);
3011 }
3012
3013 static void add_completion_option(ReadLineState *rs, const char *str,
3014                                   const char *option)
3015 {
3016     if (!str || !option) {
3017         return;
3018     }
3019     if (!strncmp(option, str, strlen(str))) {
3020         readline_add_completion(rs, option);
3021     }
3022 }
3023
3024 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3025 {
3026     size_t len;
3027     ChardevBackendInfoList *list, *start;
3028
3029     if (nb_args != 2) {
3030         return;
3031     }
3032     len = strlen(str);
3033     readline_set_completion_index(rs, len);
3034
3035     start = list = qmp_query_chardev_backends(NULL);
3036     while (list) {
3037         const char *chr_name = list->value->name;
3038
3039         if (!strncmp(chr_name, str, len)) {
3040             readline_add_completion(rs, chr_name);
3041         }
3042         list = list->next;
3043     }
3044     qapi_free_ChardevBackendInfoList(start);
3045 }
3046
3047 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3048 {
3049     size_t len;
3050     int i;
3051
3052     if (nb_args != 2) {
3053         return;
3054     }
3055     len = strlen(str);
3056     readline_set_completion_index(rs, len);
3057     for (i = 0; NetClientOptionsKind_lookup[i]; i++) {
3058         add_completion_option(rs, str, NetClientOptionsKind_lookup[i]);
3059     }
3060 }
3061
3062 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3063 {
3064     GSList *list, *elt;
3065     size_t len;
3066
3067     if (nb_args != 2) {
3068         return;
3069     }
3070
3071     len = strlen(str);
3072     readline_set_completion_index(rs, len);
3073     list = elt = object_class_get_list(TYPE_DEVICE, false);
3074     while (elt) {
3075         const char *name;
3076         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3077                                              TYPE_DEVICE);
3078         name = object_class_get_name(OBJECT_CLASS(dc));
3079
3080         if (!dc->cannot_instantiate_with_device_add_yet
3081             && !strncmp(name, str, len)) {
3082             readline_add_completion(rs, name);
3083         }
3084         elt = elt->next;
3085     }
3086     g_slist_free(list);
3087 }
3088
3089 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3090 {
3091     GSList *list, *elt;
3092     size_t len;
3093
3094     if (nb_args != 2) {
3095         return;
3096     }
3097
3098     len = strlen(str);
3099     readline_set_completion_index(rs, len);
3100     list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3101     while (elt) {
3102         const char *name;
3103
3104         name = object_class_get_name(OBJECT_CLASS(elt->data));
3105         if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3106             readline_add_completion(rs, name);
3107         }
3108         elt = elt->next;
3109     }
3110     g_slist_free(list);
3111 }
3112
3113 static void peripheral_device_del_completion(ReadLineState *rs,
3114                                              const char *str, size_t len)
3115 {
3116     Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3117     GSList *list, *item;
3118
3119     list = qdev_build_hotpluggable_device_list(peripheral);
3120     if (!list) {
3121         return;
3122     }
3123
3124     for (item = list; item; item = g_slist_next(item)) {
3125         DeviceState *dev = item->data;
3126
3127         if (dev->id && !strncmp(str, dev->id, len)) {
3128             readline_add_completion(rs, dev->id);
3129         }
3130     }
3131
3132     g_slist_free(list);
3133 }
3134
3135 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3136 {
3137     size_t len;
3138     ChardevInfoList *list, *start;
3139
3140     if (nb_args != 2) {
3141         return;
3142     }
3143     len = strlen(str);
3144     readline_set_completion_index(rs, len);
3145
3146     start = list = qmp_query_chardev(NULL);
3147     while (list) {
3148         ChardevInfo *chr = list->value;
3149
3150         if (!strncmp(chr->label, str, len)) {
3151             readline_add_completion(rs, chr->label);
3152         }
3153         list = list->next;
3154     }
3155     qapi_free_ChardevInfoList(start);
3156 }
3157
3158 static void ringbuf_completion(ReadLineState *rs, const char *str)
3159 {
3160     size_t len;
3161     ChardevInfoList *list, *start;
3162
3163     len = strlen(str);
3164     readline_set_completion_index(rs, len);
3165
3166     start = list = qmp_query_chardev(NULL);
3167     while (list) {
3168         ChardevInfo *chr_info = list->value;
3169
3170         if (!strncmp(chr_info->label, str, len)) {
3171             CharDriverState *chr = qemu_chr_find(chr_info->label);
3172             if (chr && chr_is_ringbuf(chr)) {
3173                 readline_add_completion(rs, chr_info->label);
3174             }
3175         }
3176         list = list->next;
3177     }
3178     qapi_free_ChardevInfoList(start);
3179 }
3180
3181 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3182 {
3183     if (nb_args != 2) {
3184         return;
3185     }
3186     ringbuf_completion(rs, str);
3187 }
3188
3189 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3190 {
3191     size_t len;
3192
3193     if (nb_args != 2) {
3194         return;
3195     }
3196
3197     len = strlen(str);
3198     readline_set_completion_index(rs, len);
3199     peripheral_device_del_completion(rs, str, len);
3200 }
3201
3202 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3203 {
3204     ObjectPropertyInfoList *list, *start;
3205     size_t len;
3206
3207     if (nb_args != 2) {
3208         return;
3209     }
3210     len = strlen(str);
3211     readline_set_completion_index(rs, len);
3212
3213     start = list = qmp_qom_list("/objects", NULL);
3214     while (list) {
3215         ObjectPropertyInfo *info = list->value;
3216
3217         if (!strncmp(info->type, "child<", 5)
3218             && !strncmp(info->name, str, len)) {
3219             readline_add_completion(rs, info->name);
3220         }
3221         list = list->next;
3222     }
3223     qapi_free_ObjectPropertyInfoList(start);
3224 }
3225
3226 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3227 {
3228     int i;
3229     char *sep;
3230     size_t len;
3231
3232     if (nb_args != 2) {
3233         return;
3234     }
3235     sep = strrchr(str, '-');
3236     if (sep) {
3237         str = sep + 1;
3238     }
3239     len = strlen(str);
3240     readline_set_completion_index(rs, len);
3241     for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3242         if (!strncmp(str, QKeyCode_lookup[i], len)) {
3243             readline_add_completion(rs, QKeyCode_lookup[i]);
3244         }
3245     }
3246 }
3247
3248 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3249 {
3250     size_t len;
3251
3252     len = strlen(str);
3253     readline_set_completion_index(rs, len);
3254     if (nb_args == 2) {
3255         NetClientState *ncs[MAX_QUEUE_NUM];
3256         int count, i;
3257         count = qemu_find_net_clients_except(NULL, ncs,
3258                                              NET_CLIENT_OPTIONS_KIND_NONE,
3259                                              MAX_QUEUE_NUM);
3260         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3261             const char *name = ncs[i]->name;
3262             if (!strncmp(str, name, len)) {
3263                 readline_add_completion(rs, name);
3264             }
3265         }
3266     } else if (nb_args == 3) {
3267         add_completion_option(rs, str, "on");
3268         add_completion_option(rs, str, "off");
3269     }
3270 }
3271
3272 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3273 {
3274     int len, count, i;
3275     NetClientState *ncs[MAX_QUEUE_NUM];
3276
3277     if (nb_args != 2) {
3278         return;
3279     }
3280
3281     len = strlen(str);
3282     readline_set_completion_index(rs, len);
3283     count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC,
3284                                          MAX_QUEUE_NUM);
3285     for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3286         QemuOpts *opts;
3287         const char *name = ncs[i]->name;
3288         if (strncmp(str, name, len)) {
3289             continue;
3290         }
3291         opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3292         if (opts) {
3293             readline_add_completion(rs, name);
3294         }
3295     }
3296 }
3297
3298 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3299 {
3300     size_t len;
3301
3302     len = strlen(str);
3303     readline_set_completion_index(rs, len);
3304     if (nb_args == 2) {
3305         TraceEventID id;
3306         for (id = 0; id < trace_event_count(); id++) {
3307             const char *event_name = trace_event_get_name(trace_event_id(id));
3308             if (!strncmp(str, event_name, len)) {
3309                 readline_add_completion(rs, event_name);
3310             }
3311         }
3312     } else if (nb_args == 3) {
3313         add_completion_option(rs, str, "on");
3314         add_completion_option(rs, str, "off");
3315     }
3316 }
3317
3318 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3319 {
3320     int i;
3321
3322     if (nb_args != 2) {
3323         return;
3324     }
3325     readline_set_completion_index(rs, strlen(str));
3326     for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
3327         add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
3328     }
3329 }
3330
3331 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3332                                        const char *str)
3333 {
3334     size_t len;
3335
3336     len = strlen(str);
3337     readline_set_completion_index(rs, len);
3338     if (nb_args == 2) {
3339         int i;
3340         for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3341             const char *name = MigrationCapability_lookup[i];
3342             if (!strncmp(str, name, len)) {
3343                 readline_add_completion(rs, name);
3344             }
3345         }
3346     } else if (nb_args == 3) {
3347         add_completion_option(rs, str, "on");
3348         add_completion_option(rs, str, "off");
3349     }
3350 }
3351
3352 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3353                                       const char *str)
3354 {
3355     size_t len;
3356
3357     len = strlen(str);
3358     readline_set_completion_index(rs, len);
3359     if (nb_args == 2) {
3360         int i;
3361         for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3362             const char *name = MigrationParameter_lookup[i];
3363             if (!strncmp(str, name, len)) {
3364                 readline_add_completion(rs, name);
3365             }
3366         }
3367     }
3368 }
3369
3370 void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3371 {
3372     int i;
3373     size_t len;
3374     if (nb_args != 2) {
3375         return;
3376     }
3377     len = strlen(str);
3378     readline_set_completion_index(rs, len);
3379     for (i = 0; host_net_devices[i]; i++) {
3380         if (!strncmp(host_net_devices[i], str, len)) {
3381             readline_add_completion(rs, host_net_devices[i]);
3382         }
3383     }
3384 }
3385
3386 void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3387 {
3388     NetClientState *ncs[MAX_QUEUE_NUM];
3389     int count, i, len;
3390
3391     len = strlen(str);
3392     readline_set_completion_index(rs, len);
3393     if (nb_args == 2) {
3394         count = qemu_find_net_clients_except(NULL, ncs,
3395                                              NET_CLIENT_OPTIONS_KIND_NONE,
3396                                              MAX_QUEUE_NUM);
3397         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3398             int id;
3399             char name[16];
3400
3401             if (net_hub_id_for_client(ncs[i], &id)) {
3402                 continue;
3403             }
3404             snprintf(name, sizeof(name), "%d", id);
3405             if (!strncmp(str, name, len)) {
3406                 readline_add_completion(rs, name);
3407             }
3408         }
3409         return;
3410     } else if (nb_args == 3) {
3411         count = qemu_find_net_clients_except(NULL, ncs,
3412                                              NET_CLIENT_OPTIONS_KIND_NIC,
3413                                              MAX_QUEUE_NUM);
3414         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3415             int id;
3416             const char *name;
3417
3418             if (ncs[i]->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT ||
3419                 net_hub_id_for_client(ncs[i], &id)) {
3420                 continue;
3421             }
3422             name = ncs[i]->name;
3423             if (!strncmp(str, name, len)) {
3424                 readline_add_completion(rs, name);
3425             }
3426         }
3427         return;
3428     }
3429 }
3430
3431 static void vm_completion(ReadLineState *rs, const char *str)
3432 {
3433     size_t len;
3434     BlockDriverState *bs;
3435     BdrvNextIterator *it = NULL;
3436
3437     len = strlen(str);
3438     readline_set_completion_index(rs, len);
3439
3440     while ((it = bdrv_next(it, &bs))) {
3441         SnapshotInfoList *snapshots, *snapshot;
3442         AioContext *ctx = bdrv_get_aio_context(bs);
3443         bool ok = false;
3444
3445         aio_context_acquire(ctx);
3446         if (bdrv_can_snapshot(bs)) {
3447             ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3448         }
3449         aio_context_release(ctx);
3450         if (!ok) {
3451             continue;
3452         }
3453
3454         snapshot = snapshots;
3455         while (snapshot) {
3456             char *completion = snapshot->value->name;
3457             if (!strncmp(str, completion, len)) {
3458                 readline_add_completion(rs, completion);
3459             }
3460             completion = snapshot->value->id;
3461             if (!strncmp(str, completion, len)) {
3462                 readline_add_completion(rs, completion);
3463             }
3464             snapshot = snapshot->next;
3465         }
3466         qapi_free_SnapshotInfoList(snapshots);
3467     }
3468
3469 }
3470
3471 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3472 {
3473     if (nb_args == 2) {
3474         vm_completion(rs, str);
3475     }
3476 }
3477
3478 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3479 {
3480     if (nb_args == 2) {
3481         vm_completion(rs, str);
3482     }
3483 }
3484
3485 static void monitor_find_completion_by_table(Monitor *mon,
3486                                              const mon_cmd_t *cmd_table,
3487                                              char **args,
3488                                              int nb_args)
3489 {
3490     const char *cmdname;
3491     int i;
3492     const char *ptype, *str, *name;
3493     const mon_cmd_t *cmd;
3494     BlockBackend *blk = NULL;
3495
3496     if (nb_args <= 1) {
3497         /* command completion */
3498         if (nb_args == 0)
3499             cmdname = "";
3500         else
3501             cmdname = args[0];
3502         readline_set_completion_index(mon->rs, strlen(cmdname));
3503         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3504             cmd_completion(mon, cmdname, cmd->name);
3505         }
3506     } else {
3507         /* find the command */
3508         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3509             if (compare_cmd(args[0], cmd->name)) {
3510                 break;
3511             }
3512         }
3513         if (!cmd->name) {
3514             return;
3515         }
3516
3517         if (cmd->sub_table) {
3518             /* do the job again */
3519             monitor_find_completion_by_table(mon, cmd->sub_table,
3520                                              &args[1], nb_args - 1);
3521             return;
3522         }
3523         if (cmd->command_completion) {
3524             cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3525             return;
3526         }
3527
3528         ptype = next_arg_type(cmd->args_type);
3529         for(i = 0; i < nb_args - 2; i++) {
3530             if (*ptype != '\0') {
3531                 ptype = next_arg_type(ptype);
3532                 while (*ptype == '?')
3533                     ptype = next_arg_type(ptype);
3534             }
3535         }
3536         str = args[nb_args - 1];
3537         while (*ptype == '-' && ptype[1] != '\0') {
3538             ptype = next_arg_type(ptype);
3539         }
3540         switch(*ptype) {
3541         case 'F':
3542             /* file completion */
3543             readline_set_completion_index(mon->rs, strlen(str));
3544             file_completion(mon, str);
3545             break;
3546         case 'B':
3547             /* block device name completion */
3548             readline_set_completion_index(mon->rs, strlen(str));
3549             while ((blk = blk_next(blk)) != NULL) {
3550                 name = blk_name(blk);
3551                 if (str[0] == '\0' ||
3552                     !strncmp(name, str, strlen(str))) {
3553                     readline_add_completion(mon->rs, name);
3554                 }
3555             }
3556             break;
3557         case 's':
3558         case 'S':
3559             if (!strcmp(cmd->name, "help|?")) {
3560                 monitor_find_completion_by_table(mon, cmd_table,
3561                                                  &args[1], nb_args - 1);
3562             }
3563             break;
3564         default:
3565             break;
3566         }
3567     }
3568 }
3569
3570 static void monitor_find_completion(void *opaque,
3571                                     const char *cmdline)
3572 {
3573     Monitor *mon = opaque;
3574     char *args[MAX_ARGS];
3575     int nb_args, len;
3576
3577     /* 1. parse the cmdline */
3578     if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3579         return;
3580     }
3581
3582     /* if the line ends with a space, it means we want to complete the
3583        next arg */
3584     len = strlen(cmdline);
3585     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3586         if (nb_args >= MAX_ARGS) {
3587             goto cleanup;
3588         }
3589         args[nb_args++] = g_strdup("");
3590     }
3591
3592     /* 2. auto complete according to args */
3593     monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
3594
3595 cleanup:
3596     free_cmdline_args(args, nb_args);
3597 }
3598
3599 static int monitor_can_read(void *opaque)
3600 {
3601     Monitor *mon = opaque;
3602
3603     return (mon->suspend_cnt == 0) ? 1 : 0;
3604 }
3605
3606 static bool invalid_qmp_mode(const Monitor *mon, const mon_cmd_t *cmd,
3607                              Error **errp)
3608 {
3609     bool is_cap = cmd->mhandler.cmd_new == qmp_capabilities;
3610
3611     if (is_cap && mon->qmp.in_command_mode) {
3612         error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3613                   "Capabilities negotiation is already complete, command "
3614                   "'%s' ignored", cmd->name);
3615         return true;
3616     }
3617     if (!is_cap && !mon->qmp.in_command_mode) {
3618         error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
3619                   "Expecting capabilities negotiation with "
3620                   "'qmp_capabilities' before command '%s'", cmd->name);
3621         return true;
3622     }
3623     return false;
3624 }
3625
3626 /*
3627  * Argument validation rules:
3628  *
3629  * 1. The argument must exist in cmd_args qdict
3630  * 2. The argument type must be the expected one
3631  *
3632  * Special case: If the argument doesn't exist in cmd_args and
3633  *               the QMP_ACCEPT_UNKNOWNS flag is set, then the
3634  *               checking is skipped for it.
3635  */
3636 static void check_client_args_type(const QDict *client_args,
3637                                    const QDict *cmd_args, int flags,
3638                                    Error **errp)
3639 {
3640     const QDictEntry *ent;
3641
3642     for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
3643         QObject *obj;
3644         QString *arg_type;
3645         const QObject *client_arg = qdict_entry_value(ent);
3646         const char *client_arg_name = qdict_entry_key(ent);
3647
3648         obj = qdict_get(cmd_args, client_arg_name);
3649         if (!obj) {
3650             if (flags & QMP_ACCEPT_UNKNOWNS) {
3651                 /* handler accepts unknowns */
3652                 continue;
3653             }
3654             /* client arg doesn't exist */
3655             error_setg(errp, QERR_INVALID_PARAMETER, client_arg_name);
3656             return;
3657         }
3658
3659         arg_type = qobject_to_qstring(obj);
3660         assert(arg_type != NULL);
3661
3662         /* check if argument's type is correct */
3663         switch (qstring_get_str(arg_type)[0]) {
3664         case 'F':
3665         case 'B':
3666         case 's':
3667             if (qobject_type(client_arg) != QTYPE_QSTRING) {
3668                 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3669                            client_arg_name, "string");
3670                 return;
3671             }
3672         break;
3673         case 'i':
3674         case 'l':
3675         case 'M':
3676         case 'o':
3677             if (qobject_type(client_arg) != QTYPE_QINT) {
3678                 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3679                            client_arg_name, "int");
3680                 return;
3681             }
3682             break;
3683         case 'T':
3684             if (qobject_type(client_arg) != QTYPE_QINT &&
3685                 qobject_type(client_arg) != QTYPE_QFLOAT) {
3686                 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3687                            client_arg_name, "number");
3688                 return;
3689             }
3690             break;
3691         case 'b':
3692         case '-':
3693             if (qobject_type(client_arg) != QTYPE_QBOOL) {
3694                 error_setg(errp, QERR_INVALID_PARAMETER_TYPE,
3695                            client_arg_name, "bool");
3696                 return;
3697             }
3698             break;
3699         case 'O':
3700             assert(flags & QMP_ACCEPT_UNKNOWNS);
3701             break;
3702         case 'q':
3703             /* Any QObject can be passed.  */
3704             break;
3705         case '/':
3706         case '.':
3707             /*
3708              * These types are not supported by QMP and thus are not
3709              * handled here. Fall through.
3710              */
3711         default:
3712             abort();
3713         }
3714     }
3715 }
3716
3717 /*
3718  * - Check if the client has passed all mandatory args
3719  * - Set special flags for argument validation
3720  */
3721 static void check_mandatory_args(const QDict *cmd_args,
3722                                  const QDict *client_args, int *flags,
3723                                  Error **errp)
3724 {
3725     const QDictEntry *ent;
3726
3727     for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
3728         const char *cmd_arg_name = qdict_entry_key(ent);
3729         QString *type = qobject_to_qstring(qdict_entry_value(ent));
3730         assert(type != NULL);
3731
3732         if (qstring_get_str(type)[0] == 'O') {
3733             assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
3734             *flags |= QMP_ACCEPT_UNKNOWNS;
3735         } else if (qstring_get_str(type)[0] != '-' &&
3736                    qstring_get_str(type)[1] != '?' &&
3737                    !qdict_haskey(client_args, cmd_arg_name)) {
3738             error_setg(errp, QERR_MISSING_PARAMETER, cmd_arg_name);
3739             return;
3740         }
3741     }
3742 }
3743
3744 static QDict *qdict_from_args_type(const char *args_type)
3745 {
3746     int i;
3747     QDict *qdict;
3748     QString *key, *type, *cur_qs;
3749
3750     assert(args_type != NULL);
3751
3752     qdict = qdict_new();
3753
3754     if (args_type == NULL || args_type[0] == '\0') {
3755         /* no args, empty qdict */
3756         goto out;
3757     }
3758
3759     key = qstring_new();
3760     type = qstring_new();
3761
3762     cur_qs = key;
3763
3764     for (i = 0;; i++) {
3765         switch (args_type[i]) {
3766             case ',':
3767             case '\0':
3768                 qdict_put(qdict, qstring_get_str(key), type);
3769                 QDECREF(key);
3770                 if (args_type[i] == '\0') {
3771                     goto out;
3772                 }
3773                 type = qstring_new(); /* qdict has ref */
3774                 cur_qs = key = qstring_new();
3775                 break;
3776             case ':':
3777                 cur_qs = type;
3778                 break;
3779             default:
3780                 qstring_append_chr(cur_qs, args_type[i]);
3781                 break;
3782         }
3783     }
3784
3785 out:
3786     return qdict;
3787 }
3788
3789 /*
3790  * Client argument checking rules:
3791  *
3792  * 1. Client must provide all mandatory arguments
3793  * 2. Each argument provided by the client must be expected
3794  * 3. Each argument provided by the client must have the type expected
3795  *    by the command
3796  */
3797 static void qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args,
3798                                   Error **errp)
3799 {
3800     Error *err = NULL;
3801     int flags;
3802     QDict *cmd_args;
3803
3804     cmd_args = qdict_from_args_type(cmd->args_type);
3805
3806     flags = 0;
3807     check_mandatory_args(cmd_args, client_args, &flags, &err);
3808     if (err) {
3809         goto out;
3810     }
3811
3812     check_client_args_type(client_args, cmd_args, flags, &err);
3813
3814 out:
3815     error_propagate(errp, err);
3816     QDECREF(cmd_args);
3817 }
3818
3819 /*
3820  * Input object checking rules
3821  *
3822  * 1. Input object must be a dict
3823  * 2. The "execute" key must exist
3824  * 3. The "execute" key must be a string
3825  * 4. If the "arguments" key exists, it must be a dict
3826  * 5. If the "id" key exists, it can be anything (ie. json-value)
3827  * 6. Any argument not listed above is considered invalid
3828  */
3829 static QDict *qmp_check_input_obj(QObject *input_obj, Error **errp)
3830 {
3831     const QDictEntry *ent;
3832     int has_exec_key = 0;
3833     QDict *input_dict;
3834
3835     if (qobject_type(input_obj) != QTYPE_QDICT) {
3836         error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "object");
3837         return NULL;
3838     }
3839
3840     input_dict = qobject_to_qdict(input_obj);
3841
3842     for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
3843         const char *arg_name = qdict_entry_key(ent);
3844         const QObject *arg_obj = qdict_entry_value(ent);
3845
3846         if (!strcmp(arg_name, "execute")) {
3847             if (qobject_type(arg_obj) != QTYPE_QSTRING) {
3848                 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3849                            "execute", "string");
3850                 return NULL;
3851             }
3852             has_exec_key = 1;
3853         } else if (!strcmp(arg_name, "arguments")) {
3854             if (qobject_type(arg_obj) != QTYPE_QDICT) {
3855                 error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
3856                            "arguments", "object");
3857                 return NULL;
3858             }
3859         } else if (!strcmp(arg_name, "id")) {
3860             /* Any string is acceptable as "id", so nothing to check */
3861         } else {
3862             error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
3863             return NULL;
3864         }
3865     }
3866
3867     if (!has_exec_key) {
3868         error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
3869         return NULL;
3870     }
3871
3872     return input_dict;
3873 }
3874
3875 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
3876 {
3877     Error *local_err = NULL;
3878     QObject *obj, *data;
3879     QDict *input, *args;
3880     const mon_cmd_t *cmd;
3881     const char *cmd_name;
3882     Monitor *mon = cur_mon;
3883
3884     args = input = NULL;
3885     data = NULL;
3886
3887     obj = json_parser_parse(tokens, NULL);
3888     if (!obj) {
3889         // FIXME: should be triggered in json_parser_parse()
3890         error_setg(&local_err, QERR_JSON_PARSING);
3891         goto err_out;
3892     }
3893
3894     input = qmp_check_input_obj(obj, &local_err);
3895     if (!input) {
3896         qobject_decref(obj);
3897         goto err_out;
3898     }
3899
3900     mon->qmp.id = qdict_get(input, "id");
3901     qobject_incref(mon->qmp.id);
3902
3903     cmd_name = qdict_get_str(input, "execute");
3904     trace_handle_qmp_command(mon, cmd_name);
3905     cmd = qmp_find_cmd(cmd_name);
3906     if (!cmd) {
3907         error_set(&local_err, ERROR_CLASS_COMMAND_NOT_FOUND,
3908                   "The command %s has not been found", cmd_name);
3909         goto err_out;
3910     }
3911     if (invalid_qmp_mode(mon, cmd, &local_err)) {
3912         goto err_out;
3913     }
3914
3915     obj = qdict_get(input, "arguments");
3916     if (!obj) {
3917         args = qdict_new();
3918     } else {
3919         args = qobject_to_qdict(obj);
3920         QINCREF(args);
3921     }
3922
3923     qmp_check_client_args(cmd, args, &local_err);
3924     if (local_err) {
3925         goto err_out;
3926     }
3927
3928     cmd->mhandler.cmd_new(args, &data, &local_err);
3929
3930 err_out:
3931     monitor_protocol_emitter(mon, data, local_err);
3932     qobject_decref(data);
3933     error_free(local_err);
3934     QDECREF(input);
3935     QDECREF(args);
3936 }
3937
3938 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
3939 {
3940     Monitor *old_mon = cur_mon;
3941
3942     cur_mon = opaque;
3943
3944     json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
3945
3946     cur_mon = old_mon;
3947 }
3948
3949 static void monitor_read(void *opaque, const uint8_t *buf, int size)
3950 {
3951     Monitor *old_mon = cur_mon;
3952     int i;
3953
3954     cur_mon = opaque;
3955
3956     if (cur_mon->rs) {
3957         for (i = 0; i < size; i++)
3958             readline_handle_byte(cur_mon->rs, buf[i]);
3959     } else {
3960         if (size == 0 || buf[size - 1] != 0)
3961             monitor_printf(cur_mon, "corrupted command\n");
3962         else
3963             handle_hmp_command(cur_mon, (char *)buf);
3964     }
3965
3966     cur_mon = old_mon;
3967 }
3968
3969 static void monitor_command_cb(void *opaque, const char *cmdline,
3970                                void *readline_opaque)
3971 {
3972     Monitor *mon = opaque;
3973
3974     monitor_suspend(mon);
3975     handle_hmp_command(mon, cmdline);
3976     monitor_resume(mon);
3977 }
3978
3979 int monitor_suspend(Monitor *mon)
3980 {
3981     if (!mon->rs)
3982         return -ENOTTY;
3983     mon->suspend_cnt++;
3984     return 0;
3985 }
3986
3987 void monitor_resume(Monitor *mon)
3988 {
3989     if (!mon->rs)
3990         return;
3991     if (--mon->suspend_cnt == 0)
3992         readline_show_prompt(mon->rs);
3993 }
3994
3995 static QObject *get_qmp_greeting(void)
3996 {
3997     QObject *ver = NULL;
3998
3999     qmp_marshal_query_version(NULL, &ver, NULL);
4000     return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4001 }
4002
4003 static void monitor_qmp_event(void *opaque, int event)
4004 {
4005     QObject *data;
4006     Monitor *mon = opaque;
4007
4008     switch (event) {
4009     case CHR_EVENT_OPENED:
4010         mon->qmp.in_command_mode = false;
4011         data = get_qmp_greeting();
4012         monitor_json_emitter(mon, data);
4013         qobject_decref(data);
4014         mon_refcount++;
4015         break;
4016     case CHR_EVENT_CLOSED:
4017         json_message_parser_destroy(&mon->qmp.parser);
4018         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4019         mon_refcount--;
4020         monitor_fdsets_cleanup();
4021         break;
4022     }
4023 }
4024
4025 static void monitor_event(void *opaque, int event)
4026 {
4027     Monitor *mon = opaque;
4028
4029     switch (event) {
4030     case CHR_EVENT_MUX_IN:
4031         qemu_mutex_lock(&mon->out_lock);
4032         mon->mux_out = 0;
4033         qemu_mutex_unlock(&mon->out_lock);
4034         if (mon->reset_seen) {
4035             readline_restart(mon->rs);
4036             monitor_resume(mon);
4037             monitor_flush(mon);
4038         } else {
4039             mon->suspend_cnt = 0;
4040         }
4041         break;
4042
4043     case CHR_EVENT_MUX_OUT:
4044         if (mon->reset_seen) {
4045             if (mon->suspend_cnt == 0) {
4046                 monitor_printf(mon, "\n");
4047             }
4048             monitor_flush(mon);
4049             monitor_suspend(mon);
4050         } else {
4051             mon->suspend_cnt++;
4052         }
4053         qemu_mutex_lock(&mon->out_lock);
4054         mon->mux_out = 1;
4055         qemu_mutex_unlock(&mon->out_lock);
4056         break;
4057
4058     case CHR_EVENT_OPENED:
4059         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4060                        "information\n", QEMU_VERSION);
4061         if (!mon->mux_out) {
4062             readline_restart(mon->rs);
4063             readline_show_prompt(mon->rs);
4064         }
4065         mon->reset_seen = 1;
4066         mon_refcount++;
4067         break;
4068
4069     case CHR_EVENT_CLOSED:
4070         mon_refcount--;
4071         monitor_fdsets_cleanup();
4072         break;
4073     }
4074 }
4075
4076 static int
4077 compare_mon_cmd(const void *a, const void *b)
4078 {
4079     return strcmp(((const mon_cmd_t *)a)->name,
4080             ((const mon_cmd_t *)b)->name);
4081 }
4082
4083 static void sortcmdlist(void)
4084 {
4085     int array_num;
4086     int elem_size = sizeof(mon_cmd_t);
4087
4088     array_num = sizeof(mon_cmds)/elem_size-1;
4089     qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4090
4091     array_num = sizeof(info_cmds)/elem_size-1;
4092     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4093 }
4094
4095
4096 /*
4097  * Local variables:
4098  *  c-indent-level: 4
4099  *  c-basic-offset: 4
4100  *  tab-width: 8
4101  * End:
4102  */
4103
4104 /* These functions just adapt the readline interface in a typesafe way.  We
4105  * could cast function pointers but that discards compiler checks.
4106  */
4107 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4108                                                        const char *fmt, ...)
4109 {
4110     va_list ap;
4111     va_start(ap, fmt);
4112     monitor_vprintf(opaque, fmt, ap);
4113     va_end(ap);
4114 }
4115
4116 static void monitor_readline_flush(void *opaque)
4117 {
4118     monitor_flush(opaque);
4119 }
4120
4121 static void __attribute__((constructor)) monitor_lock_init(void)
4122 {
4123     qemu_mutex_init(&monitor_lock);
4124 }
4125
4126 void monitor_init(CharDriverState *chr, int flags)
4127 {
4128     static int is_first_init = 1;
4129     Monitor *mon;
4130
4131     if (is_first_init) {
4132         monitor_qapi_event_init();
4133         sortcmdlist();
4134         is_first_init = 0;
4135     }
4136
4137     mon = g_malloc(sizeof(*mon));
4138     monitor_data_init(mon);
4139
4140     mon->chr = chr;
4141     mon->flags = flags;
4142     if (flags & MONITOR_USE_READLINE) {
4143         mon->rs = readline_init(monitor_readline_printf,
4144                                 monitor_readline_flush,
4145                                 mon,
4146                                 monitor_find_completion);
4147         monitor_read_command(mon, 0);
4148     }
4149
4150     if (monitor_is_qmp(mon)) {
4151         qemu_chr_add_handlers(chr, monitor_can_read, monitor_qmp_read,
4152                               monitor_qmp_event, mon);
4153         qemu_chr_fe_set_echo(chr, true);
4154         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4155     } else {
4156         qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4157                               monitor_event, mon);
4158     }
4159
4160     qemu_mutex_lock(&monitor_lock);
4161     QLIST_INSERT_HEAD(&mon_list, mon, entry);
4162     qemu_mutex_unlock(&monitor_lock);
4163 }
4164
4165 static void bdrv_password_cb(void *opaque, const char *password,
4166                              void *readline_opaque)
4167 {
4168     Monitor *mon = opaque;
4169     BlockDriverState *bs = readline_opaque;
4170     int ret = 0;
4171     Error *local_err = NULL;
4172
4173     bdrv_add_key(bs, password, &local_err);
4174     if (local_err) {
4175         error_report_err(local_err);
4176         ret = -EPERM;
4177     }
4178     if (mon->password_completion_cb)
4179         mon->password_completion_cb(mon->password_opaque, ret);
4180
4181     monitor_read_command(mon, 1);
4182 }
4183
4184 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4185                                 BlockCompletionFunc *completion_cb,
4186                                 void *opaque)
4187 {
4188     int err;
4189
4190     monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4191                    bdrv_get_encrypted_filename(bs));
4192
4193     mon->password_completion_cb = completion_cb;
4194     mon->password_opaque = opaque;
4195
4196     err = monitor_read_password(mon, bdrv_password_cb, bs);
4197
4198     if (err && completion_cb)
4199         completion_cb(opaque, err);
4200
4201     return err;
4202 }
4203
4204 int monitor_read_block_device_key(Monitor *mon, const char *device,
4205                                   BlockCompletionFunc *completion_cb,
4206                                   void *opaque)
4207 {
4208     Error *err = NULL;
4209     BlockBackend *blk;
4210
4211     blk = blk_by_name(device);
4212     if (!blk) {
4213         monitor_printf(mon, "Device not found %s\n", device);
4214         return -1;
4215     }
4216     if (!blk_bs(blk)) {
4217         monitor_printf(mon, "Device '%s' has no medium\n", device);
4218         return -1;
4219     }
4220
4221     bdrv_add_key(blk_bs(blk), NULL, &err);
4222     if (err) {
4223         error_free(err);
4224         return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
4225     }
4226
4227     if (completion_cb) {
4228         completion_cb(opaque, 0);
4229     }
4230     return 0;
4231 }
4232
4233 QemuOptsList qemu_mon_opts = {
4234     .name = "mon",
4235     .implied_opt_name = "chardev",
4236     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4237     .desc = {
4238         {
4239             .name = "mode",
4240             .type = QEMU_OPT_STRING,
4241         },{
4242             .name = "chardev",
4243             .type = QEMU_OPT_STRING,
4244         },{
4245             .name = "default",
4246             .type = QEMU_OPT_BOOL,
4247         },{
4248             .name = "pretty",
4249             .type = QEMU_OPT_BOOL,
4250         },
4251         { /* end of list */ }
4252     },
4253 };
4254
4255 #ifndef TARGET_I386
4256 void qmp_rtc_reset_reinjection(Error **errp)
4257 {
4258     error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4259 }
4260 #endif
4261
4262 #ifndef TARGET_S390X
4263 void qmp_dump_skeys(const char *filename, Error **errp)
4264 {
4265     error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4266 }
4267 #endif
4268
4269 #ifndef TARGET_ARM
4270 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4271 {
4272     error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4273     return NULL;
4274 }
4275 #endif