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