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