monitor.c

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