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