monitor.c

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