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