monitor.c

   1 /*
   2  * QEMU monitor
   3  *
   4  * Copyright (c) 2003-2004 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include <dirent.h>
  25 #include "hw/hw.h"
  26 #include "monitor/qdev.h"
  27 #include "hw/usb.h"
  28 #include "hw/pcmcia.h"
  29 #include "hw/i386/pc.h"
  30 #include "hw/pci/pci.h"
  31 #include "sysemu/watchdog.h"
  32 #include "hw/loader.h"
  33 #include "exec/gdbstub.h"
  34 #include "net/net.h"
  35 #include "net/slirp.h"
  36 #include "sysemu/char.h"
  37 #include "ui/qemu-spice.h"
  38 #include "sysemu/sysemu.h"
  39 #include "monitor/monitor.h"
  40 #include "monitor/readline.h"
  41 #include "ui/console.h"
  42 #include "sysemu/blockdev.h"
  43 #include "audio/audio.h"
  44 #include "disas/disas.h"
  45 #include "sysemu/balloon.h"
  46 #include "qemu/timer.h"
  47 #include "migration/migration.h"
  48 #include "sysemu/kvm.h"
  49 #include "qemu/acl.h"
  50 #include "sysemu/tpm.h"
  51 #include "qapi/qmp/qint.h"
  52 #include "qapi/qmp/qfloat.h"
  53 #include "qapi/qmp/qlist.h"
  54 #include "qapi/qmp/qbool.h"
  55 #include "qapi/qmp/qstring.h"
  56 #include "qapi/qmp/qjson.h"
  57 #include "qapi/qmp/json-streamer.h"
  58 #include "qapi/qmp/json-parser.h"
  59 #include "qemu/osdep.h"
  60 #include "cpu.h"
  61 #include "trace.h"
  62 #include "trace/control.h"
  63 #ifdef CONFIG_TRACE_SIMPLE
  64 #include "trace/simple.h"
  65 #endif
  66 #include "exec/memory.h"
  67 #include "qmp-commands.h"
  68 #include "hmp.h"
  69 #include "qemu/thread.h"
  70
  71 /* for pic/irq_info */
  72 #if defined(TARGET_SPARC)
  73 #include "hw/sparc/sun4m.h"
  74 #endif
  75 #include "hw/lm32/lm32_pic.h"
  76
  77 //#define DEBUG
  78 //#define DEBUG_COMPLETION
  79
  80 /*
  81  * Supported types:
  82  *
  83  * 'F'          filename
  84  * 'B'          block device name
  85  * 's'          string (accept optional quote)
  86  * 'S'          it just appends the rest of the string (accept optional quote)
  87  * 'O'          option string of the form NAME=VALUE,...
  88  *              parsed according to QemuOptsList given by its name
  89  *              Example: 'device:O' uses qemu_device_opts.
  90  *              Restriction: only lists with empty desc are supported
  91  *              TODO lift the restriction
  92  * 'i'          32 bit integer
  93  * 'l'          target long (32 or 64 bit)
  94  * 'M'          Non-negative target long (32 or 64 bit), in user mode the
  95  *              value is multiplied by 2^20 (think Mebibyte)
  96  * 'o'          octets (aka bytes)
  97  *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
  98  *              K, k suffix, which multiplies the value by 2^60 for suffixes E
  99  *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
 100  *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
 101  * 'T'          double
 102  *              user mode accepts an optional ms, us, ns suffix,
 103  *              which divides the value by 1e3, 1e6, 1e9, respectively
 104  * '/'          optional gdb-like print format (like "/10x")
 105  *
 106  * '?'          optional type (for all types, except '/')
 107  * '.'          other form of optional type (for 'i' and 'l')
 108  * 'b'          boolean
 109  *              user mode accepts "on" or "off"
 110  * '-'          optional parameter (eg. '-f')
 111  *
 112  */
 113
 114 typedef struct MonitorCompletionData MonitorCompletionData;
 115 struct MonitorCompletionData {
 116     Monitor *mon;
 117     void (*user_print)(Monitor *mon, const QObject *data);
 118 };
 119
 120 typedef struct mon_cmd_t {
 121     const char *name;
 122     const char *args_type;
 123     const char *params;
 124     const char *help;
 125     void (*user_print)(Monitor *mon, const QObject *data);
 126     union {
 127         void (*cmd)(Monitor *mon, const QDict *qdict);
 128         int  (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
 129         int  (*cmd_async)(Monitor *mon, const QDict *params,
 130                           MonitorCompletion *cb, void *opaque);
 131     } mhandler;
 132     int flags;
 133     /* @sub_table is a list of 2nd level of commands. If it do not exist,
 134      * mhandler should be used. If it exist, sub_table[?].mhandler should be
 135      * used, and mhandler of 1st level plays the role of help function.
 136      */
 137     struct mon_cmd_t *sub_table;
 138 } mon_cmd_t;
 139
 140 /* file descriptors passed via SCM_RIGHTS */
 141 typedef struct mon_fd_t mon_fd_t;
 142 struct mon_fd_t {
 143     char *name;
 144     int fd;
 145     QLIST_ENTRY(mon_fd_t) next;
 146 };
 147
 148 /* file descriptor associated with a file descriptor set */
 149 typedef struct MonFdsetFd MonFdsetFd;
 150 struct MonFdsetFd {
 151     int fd;
 152     bool removed;
 153     char *opaque;
 154     QLIST_ENTRY(MonFdsetFd) next;
 155 };
 156
 157 /* file descriptor set containing fds passed via SCM_RIGHTS */
 158 typedef struct MonFdset MonFdset;
 159 struct MonFdset {
 160     int64_t id;
 161     QLIST_HEAD(, MonFdsetFd) fds;
 162     QLIST_HEAD(, MonFdsetFd) dup_fds;
 163     QLIST_ENTRY(MonFdset) next;
 164 };
 165
 166 typedef struct MonitorControl {
 167     QObject *id;
 168     JSONMessageParser parser;
 169     int command_mode;
 170 } MonitorControl;
 171
 172 /*
 173  * To prevent flooding clients, events can be throttled. The
 174  * throttling is calculated globally, rather than per-Monitor
 175  * instance.
 176  */
 177 typedef struct MonitorEventState {
 178     MonitorEvent event; /* Event being tracked */
 179     int64_t rate;       /* Period over which to throttle. 0 to disable */
 180     int64_t last;       /* Time at which event was last emitted */
 181     QEMUTimer *timer;   /* Timer for handling delayed events */
 182     QObject *data;      /* Event pending delayed dispatch */
 183 } MonitorEventState;
 184
 185 struct Monitor {
 186     CharDriverState *chr;
 187     int mux_out;
 188     int reset_seen;
 189     int flags;
 190     int suspend_cnt;
 191     bool skip_flush;
 192     QString *outbuf;
 193     guint watch;
 194     ReadLineState *rs;
 195     MonitorControl *mc;
 196     CPUState *mon_cpu;
 197     BlockDriverCompletionFunc *password_completion_cb;
 198     void *password_opaque;
 199     mon_cmd_t *cmd_table;
 200     QError *error;
 201     QLIST_HEAD(,mon_fd_t) fds;
 202     QLIST_ENTRY(Monitor) entry;
 203 };
 204
 205 /* QMP checker flags */
 206 #define QMP_ACCEPT_UNKNOWNS 1
 207
 208 static QLIST_HEAD(mon_list, Monitor) mon_list;
 209 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
 210 static int mon_refcount;
 211
 212 static mon_cmd_t mon_cmds[];
 213 static mon_cmd_t info_cmds[];
 214
 215 static const mon_cmd_t qmp_cmds[];
 216
 217 Monitor *cur_mon;
 218 Monitor *default_mon;
 219
 220 static void monitor_command_cb(void *opaque, const char *cmdline,
 221                                void *readline_opaque);
 222
 223 static inline int qmp_cmd_mode(const Monitor *mon)
 224 {
 225     return (mon->mc ? mon->mc->command_mode : 0);
 226 }
 227
 228 /* Return true if in control mode, false otherwise */
 229 static inline int monitor_ctrl_mode(const Monitor *mon)
 230 {
 231     return (mon->flags & MONITOR_USE_CONTROL);
 232 }
 233
 234 /* Return non-zero iff we have a current monitor, and it is in QMP mode.  */
 235 int monitor_cur_is_qmp(void)
 236 {
 237     return cur_mon && monitor_ctrl_mode(cur_mon);
 238 }
 239
 240 void monitor_read_command(Monitor *mon, int show_prompt)
 241 {
 242     if (!mon->rs)
 243         return;
 244
 245     readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
 246     if (show_prompt)
 247         readline_show_prompt(mon->rs);
 248 }
 249
 250 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
 251                           void *opaque)
 252 {
 253     if (monitor_ctrl_mode(mon)) {
 254         qerror_report(QERR_MISSING_PARAMETER, "password");
 255         return -EINVAL;
 256     } else if (mon->rs) {
 257         readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
 258         /* prompt is printed on return from the command handler */
 259         return 0;
 260     } else {
 261         monitor_printf(mon, "terminal does not support password prompting\n");
 262         return -ENOTTY;
 263     }
 264 }
 265
 266 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
 267                                   void *opaque)
 268 {
 269     Monitor *mon = opaque;
 270
 271     mon->watch = 0;
 272     monitor_flush(mon);
 273     return FALSE;
 274 }
 275
 276 void monitor_flush(Monitor *mon)
 277 {
 278     int rc;
 279     size_t len;
 280     const char *buf;
 281
 282     if (mon->skip_flush) {
 283         return;
 284     }
 285
 286     buf = qstring_get_str(mon->outbuf);
 287     len = qstring_get_length(mon->outbuf);
 288
 289     if (len && !mon->mux_out) {
 290         rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
 291         if (rc == len) {
 292             /* all flushed */
 293             QDECREF(mon->outbuf);
 294             mon->outbuf = qstring_new();
 295             return;
 296         }
 297         if (rc > 0) {
 298             /* partinal write */
 299             QString *tmp = qstring_from_str(buf + rc);
 300             QDECREF(mon->outbuf);
 301             mon->outbuf = tmp;
 302         }
 303         if (mon->watch == 0) {
 304             mon->watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT,
 305                                                monitor_unblocked, mon);
 306         }
 307     }
 308 }
 309
 310 /* flush at every end of line */
 311 static void monitor_puts(Monitor *mon, const char *str)
 312 {
 313     char c;
 314
 315     for(;;) {
 316         c = *str++;
 317         if (c == '\0')
 318             break;
 319         if (c == '\n') {
 320             qstring_append_chr(mon->outbuf, '\r');
 321         }
 322         qstring_append_chr(mon->outbuf, c);
 323         if (c == '\n') {
 324             monitor_flush(mon);
 325         }
 326     }
 327 }
 328
 329 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
 330 {
 331     char *buf;
 332
 333     if (!mon)
 334         return;
 335
 336     if (monitor_ctrl_mode(mon)) {
 337         return;
 338     }
 339
 340     buf = g_strdup_vprintf(fmt, ap);
 341     monitor_puts(mon, buf);
 342     g_free(buf);
 343 }
 344
 345 void monitor_printf(Monitor *mon, const char *fmt, ...)
 346 {
 347     va_list ap;
 348     va_start(ap, fmt);
 349     monitor_vprintf(mon, fmt, ap);
 350     va_end(ap);
 351 }
 352
 353 void monitor_print_filename(Monitor *mon, const char *filename)
 354 {
 355     int i;
 356
 357     for (i = 0; filename[i]; i++) {
 358         switch (filename[i]) {
 359         case ' ':
 360         case '"':
 361         case '\\':
 362             monitor_printf(mon, "\\%c", filename[i]);
 363             break;
 364         case '\t':
 365             monitor_printf(mon, "\\t");
 366             break;
 367         case '\r':
 368             monitor_printf(mon, "\\r");
 369             break;
 370         case '\n':
 371             monitor_printf(mon, "\\n");
 372             break;
 373         default:
 374             monitor_printf(mon, "%c", filename[i]);
 375             break;
 376         }
 377     }
 378 }
 379
 380 static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
 381                                               const char *fmt, ...)
 382 {
 383     va_list ap;
 384     va_start(ap, fmt);
 385     monitor_vprintf((Monitor *)stream, fmt, ap);
 386     va_end(ap);
 387     return 0;
 388 }
 389
 390 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
 391
 392 static inline int handler_is_qobject(const mon_cmd_t *cmd)
 393 {
 394     return cmd->user_print != NULL;
 395 }
 396
 397 static inline bool handler_is_async(const mon_cmd_t *cmd)
 398 {
 399     return cmd->flags & MONITOR_CMD_ASYNC;
 400 }
 401
 402 static inline int monitor_has_error(const Monitor *mon)
 403 {
 404     return mon->error != NULL;
 405 }
 406
 407 static void monitor_json_emitter(Monitor *mon, const QObject *data)
 408 {
 409     QString *json;
 410
 411     json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
 412                                              qobject_to_json(data);
 413     assert(json != NULL);
 414
 415     qstring_append_chr(json, '\n');
 416     monitor_puts(mon, qstring_get_str(json));
 417
 418     QDECREF(json);
 419 }
 420
 421 static QDict *build_qmp_error_dict(const QError *err)
 422 {
 423     QObject *obj;
 424
 425     obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
 426                              ErrorClass_lookup[err->err_class],
 427                              qerror_human(err));
 428
 429     return qobject_to_qdict(obj);
 430 }
 431
 432 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
 433 {
 434     QDict *qmp;
 435
 436     trace_monitor_protocol_emitter(mon);
 437
 438     if (!monitor_has_error(mon)) {
 439         /* success response */
 440         qmp = qdict_new();
 441         if (data) {
 442             qobject_incref(data);
 443             qdict_put_obj(qmp, "return", data);
 444         } else {
 445             /* return an empty QDict by default */
 446             qdict_put(qmp, "return", qdict_new());
 447         }
 448     } else {
 449         /* error response */
 450         qmp = build_qmp_error_dict(mon->error);
 451         QDECREF(mon->error);
 452         mon->error = NULL;
 453     }
 454
 455     if (mon->mc->id) {
 456         qdict_put_obj(qmp, "id", mon->mc->id);
 457         mon->mc->id = NULL;
 458     }
 459
 460     monitor_json_emitter(mon, QOBJECT(qmp));
 461     QDECREF(qmp);
 462 }
 463
 464 static void timestamp_put(QDict *qdict)
 465 {
 466     int err;
 467     QObject *obj;
 468     qemu_timeval tv;
 469
 470     err = qemu_gettimeofday(&tv);
 471     if (err < 0)
 472         return;
 473
 474     obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
 475                                 "'microseconds': %" PRId64 " }",
 476                                 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
 477     qdict_put_obj(qdict, "timestamp", obj);
 478 }
 479
 480
 481 static const char *monitor_event_names[] = {
 482     [QEVENT_SHUTDOWN] = "SHUTDOWN",
 483     [QEVENT_RESET] = "RESET",
 484     [QEVENT_POWERDOWN] = "POWERDOWN",
 485     [QEVENT_STOP] = "STOP",
 486     [QEVENT_RESUME] = "RESUME",
 487     [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
 488     [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
 489     [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
 490     [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
 491     [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
 492     [QEVENT_WATCHDOG] = "WATCHDOG",
 493     [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
 494     [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
 495     [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
 496     [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
 497     [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
 498     [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",
 499     [QEVENT_BLOCK_JOB_READY] = "BLOCK_JOB_READY",
 500     [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",
 501     [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
 502     [QEVENT_NIC_RX_FILTER_CHANGED] = "NIC_RX_FILTER_CHANGED",
 503     [QEVENT_SUSPEND] = "SUSPEND",
 504     [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
 505     [QEVENT_WAKEUP] = "WAKEUP",
 506     [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
 507     [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
 508     [QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",
 509     [QEVENT_BLOCK_IMAGE_CORRUPTED] = "BLOCK_IMAGE_CORRUPTED",
 510 };
 511 QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
 512
 513 MonitorEventState monitor_event_state[QEVENT_MAX];
 514
 515 /*
 516  * Emits the event to every monitor instance
 517  */
 518 static void
 519 monitor_protocol_event_emit(MonitorEvent event,
 520                             QObject *data)
 521 {
 522     Monitor *mon;
 523
 524     trace_monitor_protocol_event_emit(event, data);
 525     QLIST_FOREACH(mon, &mon_list, entry) {
 526         if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
 527             monitor_json_emitter(mon, data);
 528         }
 529     }
 530 }
 531
 532
 533 /*
 534  * Queue a new event for emission to Monitor instances,
 535  * applying any rate limiting if required.
 536  */
 537 static void
 538 monitor_protocol_event_queue(MonitorEvent event,
 539                              QObject *data)
 540 {
 541     MonitorEventState *evstate;
 542     int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
 543     assert(event < QEVENT_MAX);
 544
 545     evstate = &(monitor_event_state[event]);
 546     trace_monitor_protocol_event_queue(event,
 547                                        data,
 548                                        evstate->rate,
 549                                        evstate->last,
 550                                        now);
 551
 552     /* Rate limit of 0 indicates no throttling */
 553     if (!evstate->rate) {
 554         monitor_protocol_event_emit(event, data);
 555         evstate->last = now;
 556     } else {
 557         int64_t delta = now - evstate->last;
 558         if (evstate->data ||
 559             delta < evstate->rate) {
 560             /* If there's an existing event pending, replace
 561              * it with the new event, otherwise schedule a
 562              * timer for delayed emission
 563              */
 564             if (evstate->data) {
 565                 qobject_decref(evstate->data);
 566             } else {
 567                 int64_t then = evstate->last + evstate->rate;
 568                 timer_mod_ns(evstate->timer, then);
 569             }
 570             evstate->data = data;
 571             qobject_incref(evstate->data);
 572         } else {
 573             monitor_protocol_event_emit(event, data);
 574             evstate->last = now;
 575         }
 576     }
 577 }
 578
 579
 580 /*
 581  * The callback invoked by QemuTimer when a delayed
 582  * event is ready to be emitted
 583  */
 584 static void monitor_protocol_event_handler(void *opaque)
 585 {
 586     MonitorEventState *evstate = opaque;
 587     int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
 588
 589
 590     trace_monitor_protocol_event_handler(evstate->event,
 591                                          evstate->data,
 592                                          evstate->last,
 593                                          now);
 594     if (evstate->data) {
 595         monitor_protocol_event_emit(evstate->event, evstate->data);
 596         qobject_decref(evstate->data);
 597         evstate->data = NULL;
 598     }
 599     evstate->last = now;
 600 }
 601
 602
 603 /*
 604  * @event: the event ID to be limited
 605  * @rate: the rate limit in milliseconds
 606  *
 607  * Sets a rate limit on a particular event, so no
 608  * more than 1 event will be emitted within @rate
 609  * milliseconds
 610  */
 611 static void
 612 monitor_protocol_event_throttle(MonitorEvent event,
 613                                 int64_t rate)
 614 {
 615     MonitorEventState *evstate;
 616     assert(event < QEVENT_MAX);
 617
 618     evstate = &(monitor_event_state[event]);
 619
 620     trace_monitor_protocol_event_throttle(event, rate);
 621     evstate->event = event;
 622     evstate->rate = rate * SCALE_MS;
 623     evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
 624                                     SCALE_MS,
 625                                     monitor_protocol_event_handler,
 626                                     evstate);
 627     evstate->last = 0;
 628     evstate->data = NULL;
 629 }
 630
 631
 632 /* Global, one-time initializer to configure the rate limiting
 633  * and initialize state */
 634 static void monitor_protocol_event_init(void)
 635 {
 636     /* Limit RTC & BALLOON events to 1 per second */
 637     monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
 638     monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
 639     monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
 640 }
 641
 642 /**
 643  * monitor_protocol_event(): Generate a Monitor event
 644  *
 645  * Event-specific data can be emitted through the (optional) 'data' parameter.
 646  */
 647 void monitor_protocol_event(MonitorEvent event, QObject *data)
 648 {
 649     QDict *qmp;
 650     const char *event_name;
 651
 652     assert(event < QEVENT_MAX);
 653
 654     event_name = monitor_event_names[event];
 655     assert(event_name != NULL);
 656
 657     qmp = qdict_new();
 658     timestamp_put(qmp);
 659     qdict_put(qmp, "event", qstring_from_str(event_name));
 660     if (data) {
 661         qobject_incref(data);
 662         qdict_put_obj(qmp, "data", data);
 663     }
 664
 665     trace_monitor_protocol_event(event, event_name, qmp);
 666     monitor_protocol_event_queue(event, QOBJECT(qmp));
 667     QDECREF(qmp);
 668 }
 669
 670 static int do_qmp_capabilities(Monitor *mon, const QDict *params,
 671                                QObject **ret_data)
 672 {
 673     /* Will setup QMP capabilities in the future */
 674     if (monitor_ctrl_mode(mon)) {
 675         mon->mc->command_mode = 1;
 676     }
 677
 678     return 0;
 679 }
 680
 681 static void handle_user_command(Monitor *mon, const char *cmdline);
 682
 683 static void monitor_data_init(Monitor *mon)
 684 {
 685     memset(mon, 0, sizeof(Monitor));
 686     mon->outbuf = qstring_new();
 687     /* Use *mon_cmds by default. */
 688     mon->cmd_table = mon_cmds;
 689 }
 690
 691 static void monitor_data_destroy(Monitor *mon)
 692 {
 693     QDECREF(mon->outbuf);
 694 }
 695
 696 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
 697                                 int64_t cpu_index, Error **errp)
 698 {
 699     char *output = NULL;
 700     Monitor *old_mon, hmp;
 701
 702     monitor_data_init(&hmp);
 703     hmp.skip_flush = true;
 704
 705     old_mon = cur_mon;
 706     cur_mon = &hmp;
 707
 708     if (has_cpu_index) {
 709         int ret = monitor_set_cpu(cpu_index);
 710         if (ret < 0) {
 711             cur_mon = old_mon;
 712             error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
 713                       "a CPU number");
 714             goto out;
 715         }
 716     }
 717
 718     handle_user_command(&hmp, command_line);
 719     cur_mon = old_mon;
 720
 721     if (qstring_get_length(hmp.outbuf) > 0) {
 722         output = g_strdup(qstring_get_str(hmp.outbuf));
 723     } else {
 724         output = g_strdup("");
 725     }
 726
 727 out:
 728     monitor_data_destroy(&hmp);
 729     return output;
 730 }
 731
 732 static int compare_cmd(const char *name, const char *list)
 733 {
 734     const char *p, *pstart;
 735     int len;
 736     len = strlen(name);
 737     p = list;
 738     for(;;) {
 739         pstart = p;
 740         p = strchr(p, '|');
 741         if (!p)
 742             p = pstart + strlen(pstart);
 743         if ((p - pstart) == len && !memcmp(pstart, name, len))
 744             return 1;
 745         if (*p == '\0')
 746             break;
 747         p++;
 748     }
 749     return 0;
 750 }
 751
 752 static int get_str(char *buf, int buf_size, const char **pp)
 753 {
 754     const char *p;
 755     char *q;
 756     int c;
 757
 758     q = buf;
 759     p = *pp;
 760     while (qemu_isspace(*p)) {
 761         p++;
 762     }
 763     if (*p == '\0') {
 764     fail:
 765         *q = '\0';
 766         *pp = p;
 767         return -1;
 768     }
 769     if (*p == '\"') {
 770         p++;
 771         while (*p != '\0' && *p != '\"') {
 772             if (*p == '\\') {
 773                 p++;
 774                 c = *p++;
 775                 switch (c) {
 776                 case 'n':
 777                     c = '\n';
 778                     break;
 779                 case 'r':
 780                     c = '\r';
 781                     break;
 782                 case '\\':
 783                 case '\'':
 784                 case '\"':
 785                     break;
 786                 default:
 787                     qemu_printf("unsupported escape code: '\\%c'\n", c);
 788                     goto fail;
 789                 }
 790                 if ((q - buf) < buf_size - 1) {
 791                     *q++ = c;
 792                 }
 793             } else {
 794                 if ((q - buf) < buf_size - 1) {
 795                     *q++ = *p;
 796                 }
 797                 p++;
 798             }
 799         }
 800         if (*p != '\"') {
 801             qemu_printf("unterminated string\n");
 802             goto fail;
 803         }
 804         p++;
 805     } else {
 806         while (*p != '\0' && !qemu_isspace(*p)) {
 807             if ((q - buf) < buf_size - 1) {
 808                 *q++ = *p;
 809             }
 810             p++;
 811         }
 812     }
 813     *q = '\0';
 814     *pp = p;
 815     return 0;
 816 }
 817
 818 #define MAX_ARGS 16
 819
 820 static void free_cmdline_args(char **args, int nb_args)
 821 {
 822     int i;
 823
 824     assert(nb_args <= MAX_ARGS);
 825
 826     for (i = 0; i < nb_args; i++) {
 827         g_free(args[i]);
 828     }
 829
 830 }
 831
 832 /*
 833  * Parse the command line to get valid args.
 834  * @cmdline: command line to be parsed.
 835  * @pnb_args: location to store the number of args, must NOT be NULL.
 836  * @args: location to store the args, which should be freed by caller, must
 837  *        NOT be NULL.
 838  *
 839  * Returns 0 on success, negative on failure.
 840  *
 841  * NOTE: this parser is an approximate form of the real command parser. Number
 842  *       of args have a limit of MAX_ARGS. If cmdline contains more, it will
 843  *       return with failure.
 844  */
 845 static int parse_cmdline(const char *cmdline,
 846                          int *pnb_args, char **args)
 847 {
 848     const char *p;
 849     int nb_args, ret;
 850     char buf[1024];
 851
 852     p = cmdline;
 853     nb_args = 0;
 854     for (;;) {
 855         while (qemu_isspace(*p)) {
 856             p++;
 857         }
 858         if (*p == '\0') {
 859             break;
 860         }
 861         if (nb_args >= MAX_ARGS) {
 862             goto fail;
 863         }
 864         ret = get_str(buf, sizeof(buf), &p);
 865         if (ret < 0) {
 866             goto fail;
 867         }
 868         args[nb_args] = g_strdup(buf);
 869         nb_args++;
 870     }
 871     *pnb_args = nb_args;
 872     return 0;
 873
 874  fail:
 875     free_cmdline_args(args, nb_args);
 876     return -1;
 877 }
 878
 879 static void help_cmd_dump_one(Monitor *mon,
 880                               const mon_cmd_t *cmd,
 881                               char **prefix_args,
 882                               int prefix_args_nb)
 883 {
 884     int i;
 885
 886     for (i = 0; i < prefix_args_nb; i++) {
 887         monitor_printf(mon, "%s ", prefix_args[i]);
 888     }
 889     monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
 890 }
 891
 892 /* @args[@arg_index] is the valid command need to find in @cmds */
 893 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
 894                           char **args, int nb_args, int arg_index)
 895 {
 896     const mon_cmd_t *cmd;
 897
 898     /* No valid arg need to compare with, dump all in *cmds */
 899     if (arg_index >= nb_args) {
 900         for (cmd = cmds; cmd->name != NULL; cmd++) {
 901             help_cmd_dump_one(mon, cmd, args, arg_index);
 902         }
 903         return;
 904     }
 905
 906     /* Find one entry to dump */
 907     for (cmd = cmds; cmd->name != NULL; cmd++) {
 908         if (compare_cmd(args[arg_index], cmd->name)) {
 909             if (cmd->sub_table) {
 910                 /* continue with next arg */
 911                 help_cmd_dump(mon, cmd->sub_table,
 912                               args, nb_args, arg_index + 1);
 913             } else {
 914                 help_cmd_dump_one(mon, cmd, args, arg_index);
 915             }
 916             break;
 917         }
 918     }
 919 }
 920
 921 static void help_cmd(Monitor *mon, const char *name)
 922 {
 923     char *args[MAX_ARGS];
 924     int nb_args = 0;
 925
 926     /* 1. parse user input */
 927     if (name) {
 928         /* special case for log, directly dump and return */
 929         if (!strcmp(name, "log")) {
 930             const QEMULogItem *item;
 931             monitor_printf(mon, "Log items (comma separated):\n");
 932             monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
 933             for (item = qemu_log_items; item->mask != 0; item++) {
 934                 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
 935             }
 936             return;
 937         }
 938
 939         if (parse_cmdline(name, &nb_args, args) < 0) {
 940             return;
 941         }
 942     }
 943
 944     /* 2. dump the contents according to parsed args */
 945     help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
 946
 947     free_cmdline_args(args, nb_args);
 948 }
 949
 950 static void do_help_cmd(Monitor *mon, const QDict *qdict)
 951 {
 952     help_cmd(mon, qdict_get_try_str(qdict, "name"));
 953 }
 954
 955 static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
 956 {
 957     const char *tp_name = qdict_get_str(qdict, "name");
 958     bool new_state = qdict_get_bool(qdict, "option");
 959
 960     bool found = false;
 961     TraceEvent *ev = NULL;
 962     while ((ev = trace_event_pattern(tp_name, ev)) != NULL) {
 963         found = true;
 964         if (!trace_event_get_state_static(ev)) {
 965             monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);
 966         } else {
 967             trace_event_set_state_dynamic(ev, new_state);
 968         }
 969     }
 970     if (!trace_event_is_pattern(tp_name) && !found) {
 971         monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
 972     }
 973 }
 974
 975 #ifdef CONFIG_TRACE_SIMPLE
 976 static void do_trace_file(Monitor *mon, const QDict *qdict)
 977 {
 978     const char *op = qdict_get_try_str(qdict, "op");
 979     const char *arg = qdict_get_try_str(qdict, "arg");
 980
 981     if (!op) {
 982         st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
 983     } else if (!strcmp(op, "on")) {
 984         st_set_trace_file_enabled(true);
 985     } else if (!strcmp(op, "off")) {
 986         st_set_trace_file_enabled(false);
 987     } else if (!strcmp(op, "flush")) {
 988         st_flush_trace_buffer();
 989     } else if (!strcmp(op, "set")) {
 990         if (arg) {
 991             st_set_trace_file(arg);
 992         }
 993     } else {
 994         monitor_printf(mon, "unexpected argument \"%s\"\n", op);
 995         help_cmd(mon, "trace-file");
 996     }
 997 }
 998 #endif
 999
1000 static void user_monitor_complete(void *opaque, QObject *ret_data)
1001 {
1002     MonitorCompletionData *data = (MonitorCompletionData *)opaque;
1003
1004     if (ret_data) {
1005         data->user_print(data->mon, ret_data);
1006     }
1007     monitor_resume(data->mon);
1008     g_free(data);
1009 }
1010
1011 static void qmp_monitor_complete(void *opaque, QObject *ret_data)
1012 {
1013     monitor_protocol_emitter(opaque, ret_data);
1014 }
1015
1016 static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1017                                  const QDict *params)
1018 {
1019     return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
1020 }
1021
1022 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1023                                    const QDict *params)
1024 {
1025     int ret;
1026
1027     MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
1028     cb_data->mon = mon;
1029     cb_data->user_print = cmd->user_print;
1030     monitor_suspend(mon);
1031     ret = cmd->mhandler.cmd_async(mon, params,
1032                                   user_monitor_complete, cb_data);
1033     if (ret < 0) {
1034         monitor_resume(mon);
1035         g_free(cb_data);
1036     }
1037 }
1038
1039 static void do_info_help(Monitor *mon, const QDict *qdict)
1040 {
1041     help_cmd(mon, "info");
1042 }
1043
1044 CommandInfoList *qmp_query_commands(Error **errp)
1045 {
1046     CommandInfoList *info, *cmd_list = NULL;
1047     const mon_cmd_t *cmd;
1048
1049     for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
1050         info = g_malloc0(sizeof(*info));
1051         info->value = g_malloc0(sizeof(*info->value));
1052         info->value->name = g_strdup(cmd->name);
1053
1054         info->next = cmd_list;
1055         cmd_list = info;
1056     }
1057
1058     return cmd_list;
1059 }
1060
1061 EventInfoList *qmp_query_events(Error **errp)
1062 {
1063     EventInfoList *info, *ev_list = NULL;
1064     MonitorEvent e;
1065
1066     for (e = 0 ; e < QEVENT_MAX ; e++) {
1067         const char *event_name = monitor_event_names[e];
1068         assert(event_name != NULL);
1069         info = g_malloc0(sizeof(*info));
1070         info->value = g_malloc0(sizeof(*info->value));
1071         info->value->name = g_strdup(event_name);
1072
1073         info->next = ev_list;
1074         ev_list = info;
1075     }
1076
1077     return ev_list;
1078 }
1079
1080 /* set the current CPU defined by the user */
1081 int monitor_set_cpu(int cpu_index)
1082 {
1083     CPUState *cpu;
1084
1085     cpu = qemu_get_cpu(cpu_index);
1086     if (cpu == NULL) {
1087         return -1;
1088     }
1089     cur_mon->mon_cpu = cpu;
1090     return 0;
1091 }
1092
1093 static CPUArchState *mon_get_cpu(void)
1094 {
1095     if (!cur_mon->mon_cpu) {
1096         monitor_set_cpu(0);
1097     }
1098     cpu_synchronize_state(cur_mon->mon_cpu);
1099     return cur_mon->mon_cpu->env_ptr;
1100 }
1101
1102 int monitor_get_cpu_index(void)
1103 {
1104     CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
1105     return cpu->cpu_index;
1106 }
1107
1108 static void do_info_registers(Monitor *mon, const QDict *qdict)
1109 {
1110     CPUState *cpu;
1111     CPUArchState *env;
1112     env = mon_get_cpu();
1113     cpu = ENV_GET_CPU(env);
1114     cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1115 }
1116
1117 static void do_info_jit(Monitor *mon, const QDict *qdict)
1118 {
1119     dump_exec_info((FILE *)mon, monitor_fprintf);
1120 }
1121
1122 static void do_info_history(Monitor *mon, const QDict *qdict)
1123 {
1124     int i;
1125     const char *str;
1126
1127     if (!mon->rs)
1128         return;
1129     i = 0;
1130     for(;;) {
1131         str = readline_get_history(mon->rs, i);
1132         if (!str)
1133             break;
1134         monitor_printf(mon, "%d: '%s'\n", i, str);
1135         i++;
1136     }
1137 }
1138
1139 static void do_info_cpu_stats(Monitor *mon, const QDict *qdict)
1140 {
1141     CPUState *cpu;
1142     CPUArchState *env;
1143
1144     env = mon_get_cpu();
1145     cpu = ENV_GET_CPU(env);
1146     cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
1147 }
1148
1149 static void do_trace_print_events(Monitor *mon, const QDict *qdict)
1150 {
1151     trace_print_events((FILE *)mon, &monitor_fprintf);
1152 }
1153
1154 static int client_migrate_info(Monitor *mon, const QDict *qdict,
1155                                MonitorCompletion cb, void *opaque)
1156 {
1157     const char *protocol = qdict_get_str(qdict, "protocol");
1158     const char *hostname = qdict_get_str(qdict, "hostname");
1159     const char *subject  = qdict_get_try_str(qdict, "cert-subject");
1160     int port             = qdict_get_try_int(qdict, "port", -1);
1161     int tls_port         = qdict_get_try_int(qdict, "tls-port", -1);
1162     int ret;
1163
1164     if (strcmp(protocol, "spice") == 0) {
1165         if (!using_spice) {
1166             qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1167             return -1;
1168         }
1169
1170         if (port == -1 && tls_port == -1) {
1171             qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1172             return -1;
1173         }
1174
1175         ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1176                                       cb, opaque);
1177         if (ret != 0) {
1178             qerror_report(QERR_UNDEFINED_ERROR);
1179             return -1;
1180         }
1181         return 0;
1182     }
1183
1184     qerror_report(QERR_INVALID_PARAMETER, "protocol");
1185     return -1;
1186 }
1187
1188 static void do_logfile(Monitor *mon, const QDict *qdict)
1189 {
1190     qemu_set_log_filename(qdict_get_str(qdict, "filename"));
1191 }
1192
1193 static void do_log(Monitor *mon, const QDict *qdict)
1194 {
1195     int mask;
1196     const char *items = qdict_get_str(qdict, "items");
1197
1198     if (!strcmp(items, "none")) {
1199         mask = 0;
1200     } else {
1201         mask = qemu_str_to_log_mask(items);
1202         if (!mask) {
1203             help_cmd(mon, "log");
1204             return;
1205         }
1206     }
1207     qemu_set_log(mask);
1208 }
1209
1210 static void do_singlestep(Monitor *mon, const QDict *qdict)
1211 {
1212     const char *option = qdict_get_try_str(qdict, "option");
1213     if (!option || !strcmp(option, "on")) {
1214         singlestep = 1;
1215     } else if (!strcmp(option, "off")) {
1216         singlestep = 0;
1217     } else {
1218         monitor_printf(mon, "unexpected option %s\n", option);
1219     }
1220 }
1221
1222 static void do_gdbserver(Monitor *mon, const QDict *qdict)
1223 {
1224     const char *device = qdict_get_try_str(qdict, "device");
1225     if (!device)
1226         device = "tcp::" DEFAULT_GDBSTUB_PORT;
1227     if (gdbserver_start(device) < 0) {
1228         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1229                        device);
1230     } else if (strcmp(device, "none") == 0) {
1231         monitor_printf(mon, "Disabled gdbserver\n");
1232     } else {
1233         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1234                        device);
1235     }
1236 }
1237
1238 static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1239 {
1240     const char *action = qdict_get_str(qdict, "action");
1241     if (select_watchdog_action(action) == -1) {
1242         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1243     }
1244 }
1245
1246 static void monitor_printc(Monitor *mon, int c)
1247 {
1248     monitor_printf(mon, "'");
1249     switch(c) {
1250     case '\'':
1251         monitor_printf(mon, "\\'");
1252         break;
1253     case '\\':
1254         monitor_printf(mon, "\\\\");
1255         break;
1256     case '\n':
1257         monitor_printf(mon, "\\n");
1258         break;
1259     case '\r':
1260         monitor_printf(mon, "\\r");
1261         break;
1262     default:
1263         if (c >= 32 && c <= 126) {
1264             monitor_printf(mon, "%c", c);
1265         } else {
1266             monitor_printf(mon, "\\x%02x", c);
1267         }
1268         break;
1269     }
1270     monitor_printf(mon, "'");
1271 }
1272
1273 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1274                         hwaddr addr, int is_physical)
1275 {
1276     CPUArchState *env;
1277     int l, line_size, i, max_digits, len;
1278     uint8_t buf[16];
1279     uint64_t v;
1280
1281     if (format == 'i') {
1282         int flags;
1283         flags = 0;
1284         env = mon_get_cpu();
1285 #ifdef TARGET_I386
1286         if (wsize == 2) {
1287             flags = 1;
1288         } else if (wsize == 4) {
1289             flags = 0;
1290         } else {
1291             /* as default we use the current CS size */
1292             flags = 0;
1293             if (env) {
1294 #ifdef TARGET_X86_64
1295                 if ((env->efer & MSR_EFER_LMA) &&
1296                     (env->segs[R_CS].flags & DESC_L_MASK))
1297                     flags = 2;
1298                 else
1299 #endif
1300                 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1301                     flags = 1;
1302             }
1303         }
1304 #endif
1305         monitor_disas(mon, env, addr, count, is_physical, flags);
1306         return;
1307     }
1308
1309     len = wsize * count;
1310     if (wsize == 1)
1311         line_size = 8;
1312     else
1313         line_size = 16;
1314     max_digits = 0;
1315
1316     switch(format) {
1317     case 'o':
1318         max_digits = (wsize * 8 + 2) / 3;
1319         break;
1320     default:
1321     case 'x':
1322         max_digits = (wsize * 8) / 4;
1323         break;
1324     case 'u':
1325     case 'd':
1326         max_digits = (wsize * 8 * 10 + 32) / 33;
1327         break;
1328     case 'c':
1329         wsize = 1;
1330         break;
1331     }
1332
1333     while (len > 0) {
1334         if (is_physical)
1335             monitor_printf(mon, TARGET_FMT_plx ":", addr);
1336         else
1337             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1338         l = len;
1339         if (l > line_size)
1340             l = line_size;
1341         if (is_physical) {
1342             cpu_physical_memory_read(addr, buf, l);
1343         } else {
1344             env = mon_get_cpu();
1345             if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
1346                 monitor_printf(mon, " Cannot access memory\n");
1347                 break;
1348             }
1349         }
1350         i = 0;
1351         while (i < l) {
1352             switch(wsize) {
1353             default:
1354             case 1:
1355                 v = ldub_raw(buf + i);
1356                 break;
1357             case 2:
1358                 v = lduw_raw(buf + i);
1359                 break;
1360             case 4:
1361                 v = (uint32_t)ldl_raw(buf + i);
1362                 break;
1363             case 8:
1364                 v = ldq_raw(buf + i);
1365                 break;
1366             }
1367             monitor_printf(mon, " ");
1368             switch(format) {
1369             case 'o':
1370                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1371                 break;
1372             case 'x':
1373                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1374                 break;
1375             case 'u':
1376                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1377                 break;
1378             case 'd':
1379                 monitor_printf(mon, "%*" PRId64, max_digits, v);
1380                 break;
1381             case 'c':
1382                 monitor_printc(mon, v);
1383                 break;
1384             }
1385             i += wsize;
1386         }
1387         monitor_printf(mon, "\n");
1388         addr += l;
1389         len -= l;
1390     }
1391 }
1392
1393 static void do_memory_dump(Monitor *mon, const QDict *qdict)
1394 {
1395     int count = qdict_get_int(qdict, "count");
1396     int format = qdict_get_int(qdict, "format");
1397     int size = qdict_get_int(qdict, "size");
1398     target_long addr = qdict_get_int(qdict, "addr");
1399
1400     memory_dump(mon, count, format, size, addr, 0);
1401 }
1402
1403 static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1404 {
1405     int count = qdict_get_int(qdict, "count");
1406     int format = qdict_get_int(qdict, "format");
1407     int size = qdict_get_int(qdict, "size");
1408     hwaddr addr = qdict_get_int(qdict, "addr");
1409
1410     memory_dump(mon, count, format, size, addr, 1);
1411 }
1412
1413 static void do_print(Monitor *mon, const QDict *qdict)
1414 {
1415     int format = qdict_get_int(qdict, "format");
1416     hwaddr val = qdict_get_int(qdict, "val");
1417
1418     switch(format) {
1419     case 'o':
1420         monitor_printf(mon, "%#" HWADDR_PRIo, val);
1421         break;
1422     case 'x':
1423         monitor_printf(mon, "%#" HWADDR_PRIx, val);
1424         break;
1425     case 'u':
1426         monitor_printf(mon, "%" HWADDR_PRIu, val);
1427         break;
1428     default:
1429     case 'd':
1430         monitor_printf(mon, "%" HWADDR_PRId, val);
1431         break;
1432     case 'c':
1433         monitor_printc(mon, val);
1434         break;
1435     }
1436     monitor_printf(mon, "\n");
1437 }
1438
1439 static void do_sum(Monitor *mon, const QDict *qdict)
1440 {
1441     uint32_t addr;
1442     uint16_t sum;
1443     uint32_t start = qdict_get_int(qdict, "start");
1444     uint32_t size = qdict_get_int(qdict, "size");
1445
1446     sum = 0;
1447     for(addr = start; addr < (start + size); addr++) {
1448         uint8_t val = ldub_phys(addr);
1449         /* BSD sum algorithm ('sum' Unix command) */
1450         sum = (sum >> 1) | (sum << 15);
1451         sum += val;
1452     }
1453     monitor_printf(mon, "%05d\n", sum);
1454 }
1455
1456 static int mouse_button_state;
1457
1458 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1459 {
1460     int dx, dy, dz;
1461     const char *dx_str = qdict_get_str(qdict, "dx_str");
1462     const char *dy_str = qdict_get_str(qdict, "dy_str");
1463     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1464     dx = strtol(dx_str, NULL, 0);
1465     dy = strtol(dy_str, NULL, 0);
1466     dz = 0;
1467     if (dz_str)
1468         dz = strtol(dz_str, NULL, 0);
1469     kbd_mouse_event(dx, dy, dz, mouse_button_state);
1470 }
1471
1472 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1473 {
1474     int button_state = qdict_get_int(qdict, "button_state");
1475     mouse_button_state = button_state;
1476     kbd_mouse_event(0, 0, 0, mouse_button_state);
1477 }
1478
1479 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1480 {
1481     int size = qdict_get_int(qdict, "size");
1482     int addr = qdict_get_int(qdict, "addr");
1483     int has_index = qdict_haskey(qdict, "index");
1484     uint32_t val;
1485     int suffix;
1486
1487     if (has_index) {
1488         int index = qdict_get_int(qdict, "index");
1489         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1490         addr++;
1491     }
1492     addr &= 0xffff;
1493
1494     switch(size) {
1495     default:
1496     case 1:
1497         val = cpu_inb(addr);
1498         suffix = 'b';
1499         break;
1500     case 2:
1501         val = cpu_inw(addr);
1502         suffix = 'w';
1503         break;
1504     case 4:
1505         val = cpu_inl(addr);
1506         suffix = 'l';
1507         break;
1508     }
1509     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1510                    suffix, addr, size * 2, val);
1511 }
1512
1513 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1514 {
1515     int size = qdict_get_int(qdict, "size");
1516     int addr = qdict_get_int(qdict, "addr");
1517     int val = qdict_get_int(qdict, "val");
1518
1519     addr &= IOPORTS_MASK;
1520
1521     switch (size) {
1522     default:
1523     case 1:
1524         cpu_outb(addr, val);
1525         break;
1526     case 2:
1527         cpu_outw(addr, val);
1528         break;
1529     case 4:
1530         cpu_outl(addr, val);
1531         break;
1532     }
1533 }
1534
1535 static void do_boot_set(Monitor *mon, const QDict *qdict)
1536 {
1537     int res;
1538     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1539
1540     res = qemu_boot_set(bootdevice);
1541     if (res == 0) {
1542         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1543     } else if (res > 0) {
1544         monitor_printf(mon, "setting boot device list failed\n");
1545     } else {
1546         monitor_printf(mon, "no function defined to set boot device list for "
1547                        "this architecture\n");
1548     }
1549 }
1550
1551 #if defined(TARGET_I386)
1552 static void print_pte(Monitor *mon, hwaddr addr,
1553                       hwaddr pte,
1554                       hwaddr mask)
1555 {
1556 #ifdef TARGET_X86_64
1557     if (addr & (1ULL << 47)) {
1558         addr |= -1LL << 48;
1559     }
1560 #endif
1561     monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1562                    " %c%c%c%c%c%c%c%c%c\n",
1563                    addr,
1564                    pte & mask,
1565                    pte & PG_NX_MASK ? 'X' : '-',
1566                    pte & PG_GLOBAL_MASK ? 'G' : '-',
1567                    pte & PG_PSE_MASK ? 'P' : '-',
1568                    pte & PG_DIRTY_MASK ? 'D' : '-',
1569                    pte & PG_ACCESSED_MASK ? 'A' : '-',
1570                    pte & PG_PCD_MASK ? 'C' : '-',
1571                    pte & PG_PWT_MASK ? 'T' : '-',
1572                    pte & PG_USER_MASK ? 'U' : '-',
1573                    pte & PG_RW_MASK ? 'W' : '-');
1574 }
1575
1576 static void tlb_info_32(Monitor *mon, CPUArchState *env)
1577 {
1578     unsigned int l1, l2;
1579     uint32_t pgd, pde, pte;
1580
1581     pgd = env->cr[3] & ~0xfff;
1582     for(l1 = 0; l1 < 1024; l1++) {
1583         cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1584         pde = le32_to_cpu(pde);
1585         if (pde & PG_PRESENT_MASK) {
1586             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1587                 /* 4M pages */
1588                 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
1589             } else {
1590                 for(l2 = 0; l2 < 1024; l2++) {
1591                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1592                     pte = le32_to_cpu(pte);
1593                     if (pte & PG_PRESENT_MASK) {
1594                         print_pte(mon, (l1 << 22) + (l2 << 12),
1595                                   pte & ~PG_PSE_MASK,
1596                                   ~0xfff);
1597                     }
1598                 }
1599             }
1600         }
1601     }
1602 }
1603
1604 static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
1605 {
1606     unsigned int l1, l2, l3;
1607     uint64_t pdpe, pde, pte;
1608     uint64_t pdp_addr, pd_addr, pt_addr;
1609
1610     pdp_addr = env->cr[3] & ~0x1f;
1611     for (l1 = 0; l1 < 4; l1++) {
1612         cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1613         pdpe = le64_to_cpu(pdpe);
1614         if (pdpe & PG_PRESENT_MASK) {
1615             pd_addr = pdpe & 0x3fffffffff000ULL;
1616             for (l2 = 0; l2 < 512; l2++) {
1617                 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1618                 pde = le64_to_cpu(pde);
1619                 if (pde & PG_PRESENT_MASK) {
1620                     if (pde & PG_PSE_MASK) {
1621                         /* 2M pages with PAE, CR4.PSE is ignored */
1622                         print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
1623                                   ~((hwaddr)(1 << 20) - 1));
1624                     } else {
1625                         pt_addr = pde & 0x3fffffffff000ULL;
1626                         for (l3 = 0; l3 < 512; l3++) {
1627                             cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1628                             pte = le64_to_cpu(pte);
1629                             if (pte & PG_PRESENT_MASK) {
1630                                 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1631                                           + (l3 << 12),
1632                                           pte & ~PG_PSE_MASK,
1633                                           ~(hwaddr)0xfff);
1634                             }
1635                         }
1636                     }
1637                 }
1638             }
1639         }
1640     }
1641 }
1642
1643 #ifdef TARGET_X86_64
1644 static void tlb_info_64(Monitor *mon, CPUArchState *env)
1645 {
1646     uint64_t l1, l2, l3, l4;
1647     uint64_t pml4e, pdpe, pde, pte;
1648     uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1649
1650     pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1651     for (l1 = 0; l1 < 512; l1++) {
1652         cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1653         pml4e = le64_to_cpu(pml4e);
1654         if (pml4e & PG_PRESENT_MASK) {
1655             pdp_addr = pml4e & 0x3fffffffff000ULL;
1656             for (l2 = 0; l2 < 512; l2++) {
1657                 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1658                 pdpe = le64_to_cpu(pdpe);
1659                 if (pdpe & PG_PRESENT_MASK) {
1660                     if (pdpe & PG_PSE_MASK) {
1661                         /* 1G pages, CR4.PSE is ignored */
1662                         print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1663                                   0x3ffffc0000000ULL);
1664                     } else {
1665                         pd_addr = pdpe & 0x3fffffffff000ULL;
1666                         for (l3 = 0; l3 < 512; l3++) {
1667                             cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1668                             pde = le64_to_cpu(pde);
1669                             if (pde & PG_PRESENT_MASK) {
1670                                 if (pde & PG_PSE_MASK) {
1671                                     /* 2M pages, CR4.PSE is ignored */
1672                                     print_pte(mon, (l1 << 39) + (l2 << 30) +
1673                                               (l3 << 21), pde,
1674                                               0x3ffffffe00000ULL);
1675                                 } else {
1676                                     pt_addr = pde & 0x3fffffffff000ULL;
1677                                     for (l4 = 0; l4 < 512; l4++) {
1678                                         cpu_physical_memory_read(pt_addr
1679                                                                  + l4 * 8,
1680                                                                  &pte, 8);
1681                                         pte = le64_to_cpu(pte);
1682                                         if (pte & PG_PRESENT_MASK) {
1683                                             print_pte(mon, (l1 << 39) +
1684                                                       (l2 << 30) +
1685                                                       (l3 << 21) + (l4 << 12),
1686                                                       pte & ~PG_PSE_MASK,
1687                                                       0x3fffffffff000ULL);
1688                                         }
1689                                     }
1690                                 }
1691                             }
1692                         }
1693                     }
1694                 }
1695             }
1696         }
1697     }
1698 }
1699 #endif
1700
1701 static void tlb_info(Monitor *mon, const QDict *qdict)
1702 {
1703     CPUArchState *env;
1704
1705     env = mon_get_cpu();
1706
1707     if (!(env->cr[0] & CR0_PG_MASK)) {
1708         monitor_printf(mon, "PG disabled\n");
1709         return;
1710     }
1711     if (env->cr[4] & CR4_PAE_MASK) {
1712 #ifdef TARGET_X86_64
1713         if (env->hflags & HF_LMA_MASK) {
1714             tlb_info_64(mon, env);
1715         } else
1716 #endif
1717         {
1718             tlb_info_pae32(mon, env);
1719         }
1720     } else {
1721         tlb_info_32(mon, env);
1722     }
1723 }
1724
1725 static void mem_print(Monitor *mon, hwaddr *pstart,
1726                       int *plast_prot,
1727                       hwaddr end, int prot)
1728 {
1729     int prot1;
1730     prot1 = *plast_prot;
1731     if (prot != prot1) {
1732         if (*pstart != -1) {
1733             monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1734                            TARGET_FMT_plx " %c%c%c\n",
1735                            *pstart, end, end - *pstart,
1736                            prot1 & PG_USER_MASK ? 'u' : '-',
1737                            'r',
1738                            prot1 & PG_RW_MASK ? 'w' : '-');
1739         }
1740         if (prot != 0)
1741             *pstart = end;
1742         else
1743             *pstart = -1;
1744         *plast_prot = prot;
1745     }
1746 }
1747
1748 static void mem_info_32(Monitor *mon, CPUArchState *env)
1749 {
1750     unsigned int l1, l2;
1751     int prot, last_prot;
1752     uint32_t pgd, pde, pte;
1753     hwaddr start, end;
1754
1755     pgd = env->cr[3] & ~0xfff;
1756     last_prot = 0;
1757     start = -1;
1758     for(l1 = 0; l1 < 1024; l1++) {
1759         cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
1760         pde = le32_to_cpu(pde);
1761         end = l1 << 22;
1762         if (pde & PG_PRESENT_MASK) {
1763             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1764                 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1765                 mem_print(mon, &start, &last_prot, end, prot);
1766             } else {
1767                 for(l2 = 0; l2 < 1024; l2++) {
1768                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
1769                     pte = le32_to_cpu(pte);
1770                     end = (l1 << 22) + (l2 << 12);
1771                     if (pte & PG_PRESENT_MASK) {
1772                         prot = pte & pde &
1773                             (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1774                     } else {
1775                         prot = 0;
1776                     }
1777                     mem_print(mon, &start, &last_prot, end, prot);
1778                 }
1779             }
1780         } else {
1781             prot = 0;
1782             mem_print(mon, &start, &last_prot, end, prot);
1783         }
1784     }
1785     /* Flush last range */
1786     mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1787 }
1788
1789 static void mem_info_pae32(Monitor *mon, CPUArchState *env)
1790 {
1791     unsigned int l1, l2, l3;
1792     int prot, last_prot;
1793     uint64_t pdpe, pde, pte;
1794     uint64_t pdp_addr, pd_addr, pt_addr;
1795     hwaddr start, end;
1796
1797     pdp_addr = env->cr[3] & ~0x1f;
1798     last_prot = 0;
1799     start = -1;
1800     for (l1 = 0; l1 < 4; l1++) {
1801         cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1802         pdpe = le64_to_cpu(pdpe);
1803         end = l1 << 30;
1804         if (pdpe & PG_PRESENT_MASK) {
1805             pd_addr = pdpe & 0x3fffffffff000ULL;
1806             for (l2 = 0; l2 < 512; l2++) {
1807                 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1808                 pde = le64_to_cpu(pde);
1809                 end = (l1 << 30) + (l2 << 21);
1810                 if (pde & PG_PRESENT_MASK) {
1811                     if (pde & PG_PSE_MASK) {
1812                         prot = pde & (PG_USER_MASK | PG_RW_MASK |
1813                                       PG_PRESENT_MASK);
1814                         mem_print(mon, &start, &last_prot, end, prot);
1815                     } else {
1816                         pt_addr = pde & 0x3fffffffff000ULL;
1817                         for (l3 = 0; l3 < 512; l3++) {
1818                             cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1819                             pte = le64_to_cpu(pte);
1820                             end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1821                             if (pte & PG_PRESENT_MASK) {
1822                                 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1823                                                     PG_PRESENT_MASK);
1824                             } else {
1825                                 prot = 0;
1826                             }
1827                             mem_print(mon, &start, &last_prot, end, prot);
1828                         }
1829                     }
1830                 } else {
1831                     prot = 0;
1832                     mem_print(mon, &start, &last_prot, end, prot);
1833                 }
1834             }
1835         } else {
1836             prot = 0;
1837             mem_print(mon, &start, &last_prot, end, prot);
1838         }
1839     }
1840     /* Flush last range */
1841     mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1842 }
1843
1844
1845 #ifdef TARGET_X86_64
1846 static void mem_info_64(Monitor *mon, CPUArchState *env)
1847 {
1848     int prot, last_prot;
1849     uint64_t l1, l2, l3, l4;
1850     uint64_t pml4e, pdpe, pde, pte;
1851     uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1852
1853     pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1854     last_prot = 0;
1855     start = -1;
1856     for (l1 = 0; l1 < 512; l1++) {
1857         cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1858         pml4e = le64_to_cpu(pml4e);
1859         end = l1 << 39;
1860         if (pml4e & PG_PRESENT_MASK) {
1861             pdp_addr = pml4e & 0x3fffffffff000ULL;
1862             for (l2 = 0; l2 < 512; l2++) {
1863                 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1864                 pdpe = le64_to_cpu(pdpe);
1865                 end = (l1 << 39) + (l2 << 30);
1866                 if (pdpe & PG_PRESENT_MASK) {
1867                     if (pdpe & PG_PSE_MASK) {
1868                         prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1869                                        PG_PRESENT_MASK);
1870                         prot &= pml4e;
1871                         mem_print(mon, &start, &last_prot, end, prot);
1872                     } else {
1873                         pd_addr = pdpe & 0x3fffffffff000ULL;
1874                         for (l3 = 0; l3 < 512; l3++) {
1875                             cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1876                             pde = le64_to_cpu(pde);
1877                             end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1878                             if (pde & PG_PRESENT_MASK) {
1879                                 if (pde & PG_PSE_MASK) {
1880                                     prot = pde & (PG_USER_MASK | PG_RW_MASK |
1881                                                   PG_PRESENT_MASK);
1882                                     prot &= pml4e & pdpe;
1883                                     mem_print(mon, &start, &last_prot, end, prot);
1884                                 } else {
1885                                     pt_addr = pde & 0x3fffffffff000ULL;
1886                                     for (l4 = 0; l4 < 512; l4++) {
1887                                         cpu_physical_memory_read(pt_addr
1888                                                                  + l4 * 8,
1889                                                                  &pte, 8);
1890                                         pte = le64_to_cpu(pte);
1891                                         end = (l1 << 39) + (l2 << 30) +
1892                                             (l3 << 21) + (l4 << 12);
1893                                         if (pte & PG_PRESENT_MASK) {
1894                                             prot = pte & (PG_USER_MASK | PG_RW_MASK |
1895                                                           PG_PRESENT_MASK);
1896                                             prot &= pml4e & pdpe & pde;
1897                                         } else {
1898                                             prot = 0;
1899                                         }
1900                                         mem_print(mon, &start, &last_prot, end, prot);
1901                                     }
1902                                 }
1903                             } else {
1904                                 prot = 0;
1905                                 mem_print(mon, &start, &last_prot, end, prot);
1906                             }
1907                         }
1908                     }
1909                 } else {
1910                     prot = 0;
1911                     mem_print(mon, &start, &last_prot, end, prot);
1912                 }
1913             }
1914         } else {
1915             prot = 0;
1916             mem_print(mon, &start, &last_prot, end, prot);
1917         }
1918     }
1919     /* Flush last range */
1920     mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
1921 }
1922 #endif
1923
1924 static void mem_info(Monitor *mon, const QDict *qdict)
1925 {
1926     CPUArchState *env;
1927
1928     env = mon_get_cpu();
1929
1930     if (!(env->cr[0] & CR0_PG_MASK)) {
1931         monitor_printf(mon, "PG disabled\n");
1932         return;
1933     }
1934     if (env->cr[4] & CR4_PAE_MASK) {
1935 #ifdef TARGET_X86_64
1936         if (env->hflags & HF_LMA_MASK) {
1937             mem_info_64(mon, env);
1938         } else
1939 #endif
1940         {
1941             mem_info_pae32(mon, env);
1942         }
1943     } else {
1944         mem_info_32(mon, env);
1945     }
1946 }
1947 #endif
1948
1949 #if defined(TARGET_SH4)
1950
1951 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1952 {
1953     monitor_printf(mon, " tlb%i:\t"
1954                    "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1955                    "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1956                    "dirty=%hhu writethrough=%hhu\n",
1957                    idx,
1958                    tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1959                    tlb->v, tlb->sh, tlb->c, tlb->pr,
1960                    tlb->d, tlb->wt);
1961 }
1962
1963 static void tlb_info(Monitor *mon, const QDict *qdict)
1964 {
1965     CPUArchState *env = mon_get_cpu();
1966     int i;
1967
1968     monitor_printf (mon, "ITLB:\n");
1969     for (i = 0 ; i < ITLB_SIZE ; i++)
1970         print_tlb (mon, i, &env->itlb[i]);
1971     monitor_printf (mon, "UTLB:\n");
1972     for (i = 0 ; i < UTLB_SIZE ; i++)
1973         print_tlb (mon, i, &env->utlb[i]);
1974 }
1975
1976 #endif
1977
1978 #if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
1979 static void tlb_info(Monitor *mon, const QDict *qdict)
1980 {
1981     CPUArchState *env1 = mon_get_cpu();
1982
1983     dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1984 }
1985 #endif
1986
1987 static void do_info_mtree(Monitor *mon, const QDict *qdict)
1988 {
1989     mtree_info((fprintf_function)monitor_printf, mon);
1990 }
1991
1992 static void do_info_numa(Monitor *mon, const QDict *qdict)
1993 {
1994     int i;
1995     CPUState *cpu;
1996
1997     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1998     for (i = 0; i < nb_numa_nodes; i++) {
1999         monitor_printf(mon, "node %d cpus:", i);
2000         CPU_FOREACH(cpu) {
2001             if (cpu->numa_node == i) {
2002                 monitor_printf(mon, " %d", cpu->cpu_index);
2003             }
2004         }
2005         monitor_printf(mon, "\n");
2006         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2007             node_mem[i] >> 20);
2008     }
2009 }
2010
2011 #ifdef CONFIG_PROFILER
2012
2013 int64_t qemu_time;
2014 int64_t dev_time;
2015
2016 static void do_info_profile(Monitor *mon, const QDict *qdict)
2017 {
2018     int64_t total;
2019     total = qemu_time;
2020     if (total == 0)
2021         total = 1;
2022     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
2023                    dev_time, dev_time / (double)get_ticks_per_sec());
2024     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
2025                    qemu_time, qemu_time / (double)get_ticks_per_sec());
2026     qemu_time = 0;
2027     dev_time = 0;
2028 }
2029 #else
2030 static void do_info_profile(Monitor *mon, const QDict *qdict)
2031 {
2032     monitor_printf(mon, "Internal profiler not compiled\n");
2033 }
2034 #endif
2035
2036 /* Capture support */
2037 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2038
2039 static void do_info_capture(Monitor *mon, const QDict *qdict)
2040 {
2041     int i;
2042     CaptureState *s;
2043
2044     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2045         monitor_printf(mon, "[%d]: ", i);
2046         s->ops.info (s->opaque);
2047     }
2048 }
2049
2050 static void do_stop_capture(Monitor *mon, const QDict *qdict)
2051 {
2052     int i;
2053     int n = qdict_get_int(qdict, "n");
2054     CaptureState *s;
2055
2056     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2057         if (i == n) {
2058             s->ops.destroy (s->opaque);
2059             QLIST_REMOVE (s, entries);
2060             g_free (s);
2061             return;
2062         }
2063     }
2064 }
2065
2066 static void do_wav_capture(Monitor *mon, const QDict *qdict)
2067 {
2068     const char *path = qdict_get_str(qdict, "path");
2069     int has_freq = qdict_haskey(qdict, "freq");
2070     int freq = qdict_get_try_int(qdict, "freq", -1);
2071     int has_bits = qdict_haskey(qdict, "bits");
2072     int bits = qdict_get_try_int(qdict, "bits", -1);
2073     int has_channels = qdict_haskey(qdict, "nchannels");
2074     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2075     CaptureState *s;
2076
2077     s = g_malloc0 (sizeof (*s));
2078
2079     freq = has_freq ? freq : 44100;
2080     bits = has_bits ? bits : 16;
2081     nchannels = has_channels ? nchannels : 2;
2082
2083     if (wav_start_capture (s, path, freq, bits, nchannels)) {
2084         monitor_printf(mon, "Failed to add wave capture\n");
2085         g_free (s);
2086         return;
2087     }
2088     QLIST_INSERT_HEAD (&capture_head, s, entries);
2089 }
2090
2091 static qemu_acl *find_acl(Monitor *mon, const char *name)
2092 {
2093     qemu_acl *acl = qemu_acl_find(name);
2094
2095     if (!acl) {
2096         monitor_printf(mon, "acl: unknown list '%s'\n", name);
2097     }
2098     return acl;
2099 }
2100
2101 static void do_acl_show(Monitor *mon, const QDict *qdict)
2102 {
2103     const char *aclname = qdict_get_str(qdict, "aclname");
2104     qemu_acl *acl = find_acl(mon, aclname);
2105     qemu_acl_entry *entry;
2106     int i = 0;
2107
2108     if (acl) {
2109         monitor_printf(mon, "policy: %s\n",
2110                        acl->defaultDeny ? "deny" : "allow");
2111         QTAILQ_FOREACH(entry, &acl->entries, next) {
2112             i++;
2113             monitor_printf(mon, "%d: %s %s\n", i,
2114                            entry->deny ? "deny" : "allow", entry->match);
2115         }
2116     }
2117 }
2118
2119 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2120 {
2121     const char *aclname = qdict_get_str(qdict, "aclname");
2122     qemu_acl *acl = find_acl(mon, aclname);
2123
2124     if (acl) {
2125         qemu_acl_reset(acl);
2126         monitor_printf(mon, "acl: removed all rules\n");
2127     }
2128 }
2129
2130 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2131 {
2132     const char *aclname = qdict_get_str(qdict, "aclname");
2133     const char *policy = qdict_get_str(qdict, "policy");
2134     qemu_acl *acl = find_acl(mon, aclname);
2135
2136     if (acl) {
2137         if (strcmp(policy, "allow") == 0) {
2138             acl->defaultDeny = 0;
2139             monitor_printf(mon, "acl: policy set to 'allow'\n");
2140         } else if (strcmp(policy, "deny") == 0) {
2141             acl->defaultDeny = 1;
2142             monitor_printf(mon, "acl: policy set to 'deny'\n");
2143         } else {
2144             monitor_printf(mon, "acl: unknown policy '%s', "
2145                            "expected 'deny' or 'allow'\n", policy);
2146         }
2147     }
2148 }
2149
2150 static void do_acl_add(Monitor *mon, const QDict *qdict)
2151 {
2152     const char *aclname = qdict_get_str(qdict, "aclname");
2153     const char *match = qdict_get_str(qdict, "match");
2154     const char *policy = qdict_get_str(qdict, "policy");
2155     int has_index = qdict_haskey(qdict, "index");
2156     int index = qdict_get_try_int(qdict, "index", -1);
2157     qemu_acl *acl = find_acl(mon, aclname);
2158     int deny, ret;
2159
2160     if (acl) {
2161         if (strcmp(policy, "allow") == 0) {
2162             deny = 0;
2163         } else if (strcmp(policy, "deny") == 0) {
2164             deny = 1;
2165         } else {
2166             monitor_printf(mon, "acl: unknown policy '%s', "
2167                            "expected 'deny' or 'allow'\n", policy);
2168             return;
2169         }
2170         if (has_index)
2171             ret = qemu_acl_insert(acl, deny, match, index);
2172         else
2173             ret = qemu_acl_append(acl, deny, match);
2174         if (ret < 0)
2175             monitor_printf(mon, "acl: unable to add acl entry\n");
2176         else
2177             monitor_printf(mon, "acl: added rule at position %d\n", ret);
2178     }
2179 }
2180
2181 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2182 {
2183     const char *aclname = qdict_get_str(qdict, "aclname");
2184     const char *match = qdict_get_str(qdict, "match");
2185     qemu_acl *acl = find_acl(mon, aclname);
2186     int ret;
2187
2188     if (acl) {
2189         ret = qemu_acl_remove(acl, match);
2190         if (ret < 0)
2191             monitor_printf(mon, "acl: no matching acl entry\n");
2192         else
2193             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2194     }
2195 }
2196
2197 #if defined(TARGET_I386)
2198 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2199 {
2200     X86CPU *cpu;
2201     CPUState *cs;
2202     int cpu_index = qdict_get_int(qdict, "cpu_index");
2203     int bank = qdict_get_int(qdict, "bank");
2204     uint64_t status = qdict_get_int(qdict, "status");
2205     uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2206     uint64_t addr = qdict_get_int(qdict, "addr");
2207     uint64_t misc = qdict_get_int(qdict, "misc");
2208     int flags = MCE_INJECT_UNCOND_AO;
2209
2210     if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2211         flags |= MCE_INJECT_BROADCAST;
2212     }
2213     cs = qemu_get_cpu(cpu_index);
2214     if (cs != NULL) {
2215         cpu = X86_CPU(cs);
2216         cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2217                            flags);
2218     }
2219 }
2220 #endif
2221
2222 void qmp_getfd(const char *fdname, Error **errp)
2223 {
2224     mon_fd_t *monfd;
2225     int fd;
2226
2227     fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
2228     if (fd == -1) {
2229         error_set(errp, QERR_FD_NOT_SUPPLIED);
2230         return;
2231     }
2232
2233     if (qemu_isdigit(fdname[0])) {
2234         error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2235                   "a name not starting with a digit");
2236         return;
2237     }
2238
2239     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2240         if (strcmp(monfd->name, fdname) != 0) {
2241             continue;
2242         }
2243
2244         close(monfd->fd);
2245         monfd->fd = fd;
2246         return;
2247     }
2248
2249     monfd = g_malloc0(sizeof(mon_fd_t));
2250     monfd->name = g_strdup(fdname);
2251     monfd->fd = fd;
2252
2253     QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2254 }
2255
2256 void qmp_closefd(const char *fdname, Error **errp)
2257 {
2258     mon_fd_t *monfd;
2259
2260     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2261         if (strcmp(monfd->name, fdname) != 0) {
2262             continue;
2263         }
2264
2265         QLIST_REMOVE(monfd, next);
2266         close(monfd->fd);
2267         g_free(monfd->name);
2268         g_free(monfd);
2269         return;
2270     }
2271
2272     error_set(errp, QERR_FD_NOT_FOUND, fdname);
2273 }
2274
2275 static void do_loadvm(Monitor *mon, const QDict *qdict)
2276 {
2277     int saved_vm_running  = runstate_is_running();
2278     const char *name = qdict_get_str(qdict, "name");
2279
2280     vm_stop(RUN_STATE_RESTORE_VM);
2281
2282     if (load_vmstate(name) == 0 && saved_vm_running) {
2283         vm_start();
2284     }
2285 }
2286
2287 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2288 {
2289     mon_fd_t *monfd;
2290
2291     QLIST_FOREACH(monfd, &mon->fds, next) {
2292         int fd;
2293
2294         if (strcmp(monfd->name, fdname) != 0) {
2295             continue;
2296         }
2297
2298         fd = monfd->fd;
2299
2300         /* caller takes ownership of fd */
2301         QLIST_REMOVE(monfd, next);
2302         g_free(monfd->name);
2303         g_free(monfd);
2304
2305         return fd;
2306     }
2307
2308     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2309     return -1;
2310 }
2311
2312 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2313 {
2314     MonFdsetFd *mon_fdset_fd;
2315     MonFdsetFd *mon_fdset_fd_next;
2316
2317     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2318         if ((mon_fdset_fd->removed ||
2319                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2320                 runstate_is_running()) {
2321             close(mon_fdset_fd->fd);
2322             g_free(mon_fdset_fd->opaque);
2323             QLIST_REMOVE(mon_fdset_fd, next);
2324             g_free(mon_fdset_fd);
2325         }
2326     }
2327
2328     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2329         QLIST_REMOVE(mon_fdset, next);
2330         g_free(mon_fdset);
2331     }
2332 }
2333
2334 static void monitor_fdsets_cleanup(void)
2335 {
2336     MonFdset *mon_fdset;
2337     MonFdset *mon_fdset_next;
2338
2339     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2340         monitor_fdset_cleanup(mon_fdset);
2341     }
2342 }
2343
2344 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2345                       const char *opaque, Error **errp)
2346 {
2347     int fd;
2348     Monitor *mon = cur_mon;
2349     AddfdInfo *fdinfo;
2350
2351     fd = qemu_chr_fe_get_msgfd(mon->chr);
2352     if (fd == -1) {
2353         error_set(errp, QERR_FD_NOT_SUPPLIED);
2354         goto error;
2355     }
2356
2357     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2358                                   has_opaque, opaque, errp);
2359     if (fdinfo) {
2360         return fdinfo;
2361     }
2362
2363 error:
2364     if (fd != -1) {
2365         close(fd);
2366     }
2367     return NULL;
2368 }
2369
2370 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2371 {
2372     MonFdset *mon_fdset;
2373     MonFdsetFd *mon_fdset_fd;
2374     char fd_str[60];
2375
2376     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2377         if (mon_fdset->id != fdset_id) {
2378             continue;
2379         }
2380         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2381             if (has_fd) {
2382                 if (mon_fdset_fd->fd != fd) {
2383                     continue;
2384                 }
2385                 mon_fdset_fd->removed = true;
2386                 break;
2387             } else {
2388                 mon_fdset_fd->removed = true;
2389             }
2390         }
2391         if (has_fd && !mon_fdset_fd) {
2392             goto error;
2393         }
2394         monitor_fdset_cleanup(mon_fdset);
2395         return;
2396     }
2397
2398 error:
2399     if (has_fd) {
2400         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2401                  fdset_id, fd);
2402     } else {
2403         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2404     }
2405     error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2406 }
2407
2408 FdsetInfoList *qmp_query_fdsets(Error **errp)
2409 {
2410     MonFdset *mon_fdset;
2411     MonFdsetFd *mon_fdset_fd;
2412     FdsetInfoList *fdset_list = NULL;
2413
2414     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2415         FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2416         FdsetFdInfoList *fdsetfd_list = NULL;
2417
2418         fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2419         fdset_info->value->fdset_id = mon_fdset->id;
2420
2421         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2422             FdsetFdInfoList *fdsetfd_info;
2423
2424             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2425             fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2426             fdsetfd_info->value->fd = mon_fdset_fd->fd;
2427             if (mon_fdset_fd->opaque) {
2428                 fdsetfd_info->value->has_opaque = true;
2429                 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2430             } else {
2431                 fdsetfd_info->value->has_opaque = false;
2432             }
2433
2434             fdsetfd_info->next = fdsetfd_list;
2435             fdsetfd_list = fdsetfd_info;
2436         }
2437
2438         fdset_info->value->fds = fdsetfd_list;
2439
2440         fdset_info->next = fdset_list;
2441         fdset_list = fdset_info;
2442     }
2443
2444     return fdset_list;
2445 }
2446
2447 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2448                                 bool has_opaque, const char *opaque,
2449                                 Error **errp)
2450 {
2451     MonFdset *mon_fdset = NULL;
2452     MonFdsetFd *mon_fdset_fd;
2453     AddfdInfo *fdinfo;
2454
2455     if (has_fdset_id) {
2456         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2457             /* Break if match found or match impossible due to ordering by ID */
2458             if (fdset_id <= mon_fdset->id) {
2459                 if (fdset_id < mon_fdset->id) {
2460                     mon_fdset = NULL;
2461                 }
2462                 break;
2463             }
2464         }
2465     }
2466
2467     if (mon_fdset == NULL) {
2468         int64_t fdset_id_prev = -1;
2469         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2470
2471         if (has_fdset_id) {
2472             if (fdset_id < 0) {
2473                 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2474                           "a non-negative value");
2475                 return NULL;
2476             }
2477             /* Use specified fdset ID */
2478             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2479                 mon_fdset_cur = mon_fdset;
2480                 if (fdset_id < mon_fdset_cur->id) {
2481                     break;
2482                 }
2483             }
2484         } else {
2485             /* Use first available fdset ID */
2486             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2487                 mon_fdset_cur = mon_fdset;
2488                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2489                     fdset_id_prev = mon_fdset_cur->id;
2490                     continue;
2491                 }
2492                 break;
2493             }
2494         }
2495
2496         mon_fdset = g_malloc0(sizeof(*mon_fdset));
2497         if (has_fdset_id) {
2498             mon_fdset->id = fdset_id;
2499         } else {
2500             mon_fdset->id = fdset_id_prev + 1;
2501         }
2502
2503         /* The fdset list is ordered by fdset ID */
2504         if (!mon_fdset_cur) {
2505             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2506         } else if (mon_fdset->id < mon_fdset_cur->id) {
2507             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2508         } else {
2509             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2510         }
2511     }
2512
2513     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2514     mon_fdset_fd->fd = fd;
2515     mon_fdset_fd->removed = false;
2516     if (has_opaque) {
2517         mon_fdset_fd->opaque = g_strdup(opaque);
2518     }
2519     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2520
2521     fdinfo = g_malloc0(sizeof(*fdinfo));
2522     fdinfo->fdset_id = mon_fdset->id;
2523     fdinfo->fd = mon_fdset_fd->fd;
2524
2525     return fdinfo;
2526 }
2527
2528 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2529 {
2530 #ifndef _WIN32
2531     MonFdset *mon_fdset;
2532     MonFdsetFd *mon_fdset_fd;
2533     int mon_fd_flags;
2534
2535     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2536         if (mon_fdset->id != fdset_id) {
2537             continue;
2538         }
2539         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2540             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2541             if (mon_fd_flags == -1) {
2542                 return -1;
2543             }
2544
2545             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2546                 return mon_fdset_fd->fd;
2547             }
2548         }
2549         errno = EACCES;
2550         return -1;
2551     }
2552 #endif
2553
2554     errno = ENOENT;
2555     return -1;
2556 }
2557
2558 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2559 {
2560     MonFdset *mon_fdset;
2561     MonFdsetFd *mon_fdset_fd_dup;
2562
2563     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2564         if (mon_fdset->id != fdset_id) {
2565             continue;
2566         }
2567         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2568             if (mon_fdset_fd_dup->fd == dup_fd) {
2569                 return -1;
2570             }
2571         }
2572         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2573         mon_fdset_fd_dup->fd = dup_fd;
2574         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2575         return 0;
2576     }
2577     return -1;
2578 }
2579
2580 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2581 {
2582     MonFdset *mon_fdset;
2583     MonFdsetFd *mon_fdset_fd_dup;
2584
2585     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2586         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2587             if (mon_fdset_fd_dup->fd == dup_fd) {
2588                 if (remove) {
2589                     QLIST_REMOVE(mon_fdset_fd_dup, next);
2590                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2591                         monitor_fdset_cleanup(mon_fdset);
2592                     }
2593                 }
2594                 return mon_fdset->id;
2595             }
2596         }
2597     }
2598     return -1;
2599 }
2600
2601 int monitor_fdset_dup_fd_find(int dup_fd)
2602 {
2603     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2604 }
2605
2606 int monitor_fdset_dup_fd_remove(int dup_fd)
2607 {
2608     return monitor_fdset_dup_fd_find_remove(dup_fd, true);
2609 }
2610
2611 int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2612 {
2613     int fd;
2614     Error *local_err = NULL;
2615
2616     if (!qemu_isdigit(fdname[0]) && mon) {
2617
2618         fd = monitor_get_fd(mon, fdname, &local_err);
2619         if (fd == -1) {
2620             qerror_report_err(local_err);
2621             error_free(local_err);
2622             return -1;
2623         }
2624     } else {
2625         fd = qemu_parse_fd(fdname);
2626     }
2627
2628     return fd;
2629 }
2630
2631 /* Please update hmp-commands.hx when adding or changing commands */
2632 static mon_cmd_t info_cmds[] = {
2633     {
2634         .name       = "version",
2635         .args_type  = "",
2636         .params     = "",
2637         .help       = "show the version of QEMU",
2638         .mhandler.cmd = hmp_info_version,
2639     },
2640     {
2641         .name       = "network",
2642         .args_type  = "",
2643         .params     = "",
2644         .help       = "show the network state",
2645         .mhandler.cmd = do_info_network,
2646     },
2647     {
2648         .name       = "chardev",
2649         .args_type  = "",
2650         .params     = "",
2651         .help       = "show the character devices",
2652         .mhandler.cmd = hmp_info_chardev,
2653     },
2654     {
2655         .name       = "block",
2656         .args_type  = "verbose:-v,device:B?",
2657         .params     = "[-v] [device]",
2658         .help       = "show info of one block device or all block devices "
2659                       "(and details of images with -v option)",
2660         .mhandler.cmd = hmp_info_block,
2661     },
2662     {
2663         .name       = "blockstats",
2664         .args_type  = "",
2665         .params     = "",
2666         .help       = "show block device statistics",
2667         .mhandler.cmd = hmp_info_blockstats,
2668     },
2669     {
2670         .name       = "block-jobs",
2671         .args_type  = "",
2672         .params     = "",
2673         .help       = "show progress of ongoing block device operations",
2674         .mhandler.cmd = hmp_info_block_jobs,
2675     },
2676     {
2677         .name       = "registers",
2678         .args_type  = "",
2679         .params     = "",
2680         .help       = "show the cpu registers",
2681         .mhandler.cmd = do_info_registers,
2682     },
2683     {
2684         .name       = "cpus",
2685         .args_type  = "",
2686         .params     = "",
2687         .help       = "show infos for each CPU",
2688         .mhandler.cmd = hmp_info_cpus,
2689     },
2690     {
2691         .name       = "history",
2692         .args_type  = "",
2693         .params     = "",
2694         .help       = "show the command line history",
2695         .mhandler.cmd = do_info_history,
2696     },
2697 #if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2698     defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
2699     {
2700         .name       = "irq",
2701         .args_type  = "",
2702         .params     = "",
2703         .help       = "show the interrupts statistics (if available)",
2704 #ifdef TARGET_SPARC
2705         .mhandler.cmd = sun4m_irq_info,
2706 #elif defined(TARGET_LM32)
2707         .mhandler.cmd = lm32_irq_info,
2708 #else
2709         .mhandler.cmd = irq_info,
2710 #endif
2711     },
2712     {
2713         .name       = "pic",
2714         .args_type  = "",
2715         .params     = "",
2716         .help       = "show i8259 (PIC) state",
2717 #ifdef TARGET_SPARC
2718         .mhandler.cmd = sun4m_pic_info,
2719 #elif defined(TARGET_LM32)
2720         .mhandler.cmd = lm32_do_pic_info,
2721 #else
2722         .mhandler.cmd = pic_info,
2723 #endif
2724     },
2725 #endif
2726     {
2727         .name       = "pci",
2728         .args_type  = "",
2729         .params     = "",
2730         .help       = "show PCI info",
2731         .mhandler.cmd = hmp_info_pci,
2732     },
2733 #if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
2734     defined(TARGET_PPC) || defined(TARGET_XTENSA)
2735     {
2736         .name       = "tlb",
2737         .args_type  = "",
2738         .params     = "",
2739         .help       = "show virtual to physical memory mappings",
2740         .mhandler.cmd = tlb_info,
2741     },
2742 #endif
2743 #if defined(TARGET_I386)
2744     {
2745         .name       = "mem",
2746         .args_type  = "",
2747         .params     = "",
2748         .help       = "show the active virtual memory mappings",
2749         .mhandler.cmd = mem_info,
2750     },
2751 #endif
2752     {
2753         .name       = "mtree",
2754         .args_type  = "",
2755         .params     = "",
2756         .help       = "show memory tree",
2757         .mhandler.cmd = do_info_mtree,
2758     },
2759     {
2760         .name       = "jit",
2761         .args_type  = "",
2762         .params     = "",
2763         .help       = "show dynamic compiler info",
2764         .mhandler.cmd = do_info_jit,
2765     },
2766     {
2767         .name       = "kvm",
2768         .args_type  = "",
2769         .params     = "",
2770         .help       = "show KVM information",
2771         .mhandler.cmd = hmp_info_kvm,
2772     },
2773     {
2774         .name       = "numa",
2775         .args_type  = "",
2776         .params     = "",
2777         .help       = "show NUMA information",
2778         .mhandler.cmd = do_info_numa,
2779     },
2780     {
2781         .name       = "usb",
2782         .args_type  = "",
2783         .params     = "",
2784         .help       = "show guest USB devices",
2785         .mhandler.cmd = usb_info,
2786     },
2787     {
2788         .name       = "usbhost",
2789         .args_type  = "",
2790         .params     = "",
2791         .help       = "show host USB devices",
2792         .mhandler.cmd = usb_host_info,
2793     },
2794     {
2795         .name       = "profile",
2796         .args_type  = "",
2797         .params     = "",
2798         .help       = "show profiling information",
2799         .mhandler.cmd = do_info_profile,
2800     },
2801     {
2802         .name       = "capture",
2803         .args_type  = "",
2804         .params     = "",
2805         .help       = "show capture information",
2806         .mhandler.cmd = do_info_capture,
2807     },
2808     {
2809         .name       = "snapshots",
2810         .args_type  = "",
2811         .params     = "",
2812         .help       = "show the currently saved VM snapshots",
2813         .mhandler.cmd = do_info_snapshots,
2814     },
2815     {
2816         .name       = "status",
2817         .args_type  = "",
2818         .params     = "",
2819         .help       = "show the current VM status (running|paused)",
2820         .mhandler.cmd = hmp_info_status,
2821     },
2822     {
2823         .name       = "pcmcia",
2824         .args_type  = "",
2825         .params     = "",
2826         .help       = "show guest PCMCIA status",
2827         .mhandler.cmd = pcmcia_info,
2828     },
2829     {
2830         .name       = "mice",
2831         .args_type  = "",
2832         .params     = "",
2833         .help       = "show which guest mouse is receiving events",
2834         .mhandler.cmd = hmp_info_mice,
2835     },
2836     {
2837         .name       = "vnc",
2838         .args_type  = "",
2839         .params     = "",
2840         .help       = "show the vnc server status",
2841         .mhandler.cmd = hmp_info_vnc,
2842     },
2843 #if defined(CONFIG_SPICE)
2844     {
2845         .name       = "spice",
2846         .args_type  = "",
2847         .params     = "",
2848         .help       = "show the spice server status",
2849         .mhandler.cmd = hmp_info_spice,
2850     },
2851 #endif
2852     {
2853         .name       = "name",
2854         .args_type  = "",
2855         .params     = "",
2856         .help       = "show the current VM name",
2857         .mhandler.cmd = hmp_info_name,
2858     },
2859     {
2860         .name       = "uuid",
2861         .args_type  = "",
2862         .params     = "",
2863         .help       = "show the current VM UUID",
2864         .mhandler.cmd = hmp_info_uuid,
2865     },
2866     {
2867         .name       = "cpustats",
2868         .args_type  = "",
2869         .params     = "",
2870         .help       = "show CPU statistics",
2871         .mhandler.cmd = do_info_cpu_stats,
2872     },
2873 #if defined(CONFIG_SLIRP)
2874     {
2875         .name       = "usernet",
2876         .args_type  = "",
2877         .params     = "",
2878         .help       = "show user network stack connection states",
2879         .mhandler.cmd = do_info_usernet,
2880     },
2881 #endif
2882     {
2883         .name       = "migrate",
2884         .args_type  = "",
2885         .params     = "",
2886         .help       = "show migration status",
2887         .mhandler.cmd = hmp_info_migrate,
2888     },
2889     {
2890         .name       = "migrate_capabilities",
2891         .args_type  = "",
2892         .params     = "",
2893         .help       = "show current migration capabilities",
2894         .mhandler.cmd = hmp_info_migrate_capabilities,
2895     },
2896     {
2897         .name       = "migrate_cache_size",
2898         .args_type  = "",
2899         .params     = "",
2900         .help       = "show current migration xbzrle cache size",
2901         .mhandler.cmd = hmp_info_migrate_cache_size,
2902     },
2903     {
2904         .name       = "balloon",
2905         .args_type  = "",
2906         .params     = "",
2907         .help       = "show balloon information",
2908         .mhandler.cmd = hmp_info_balloon,
2909     },
2910     {
2911         .name       = "qtree",
2912         .args_type  = "",
2913         .params     = "",
2914         .help       = "show device tree",
2915         .mhandler.cmd = do_info_qtree,
2916     },
2917     {
2918         .name       = "qdm",
2919         .args_type  = "",
2920         .params     = "",
2921         .help       = "show qdev device model list",
2922         .mhandler.cmd = do_info_qdm,
2923     },
2924     {
2925         .name       = "roms",
2926         .args_type  = "",
2927         .params     = "",
2928         .help       = "show roms",
2929         .mhandler.cmd = do_info_roms,
2930     },
2931     {
2932         .name       = "trace-events",
2933         .args_type  = "",
2934         .params     = "",
2935         .help       = "show available trace-events & their state",
2936         .mhandler.cmd = do_trace_print_events,
2937     },
2938     {
2939         .name       = "tpm",
2940         .args_type  = "",
2941         .params     = "",
2942         .help       = "show the TPM device",
2943         .mhandler.cmd = hmp_info_tpm,
2944     },
2945     {
2946         .name       = NULL,
2947     },
2948 };
2949
2950 /* mon_cmds and info_cmds would be sorted at runtime */
2951 static mon_cmd_t mon_cmds[] = {
2952 #include "hmp-commands.h"
2953     { NULL, NULL, },
2954 };
2955
2956 static const mon_cmd_t qmp_cmds[] = {
2957 #include "qmp-commands-old.h"
2958     { /* NULL */ },
2959 };
2960
2961 /*******************************************************************/
2962
2963 static const char *pch;
2964 static sigjmp_buf expr_env;
2965
2966 #define MD_TLONG 0
2967 #define MD_I32   1
2968
2969 typedef struct MonitorDef {
2970     const char *name;
2971     int offset;
2972     target_long (*get_value)(const struct MonitorDef *md, int val);
2973     int type;
2974 } MonitorDef;
2975
2976 #if defined(TARGET_I386)
2977 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2978 {
2979     CPUArchState *env = mon_get_cpu();
2980     return env->eip + env->segs[R_CS].base;
2981 }
2982 #endif
2983
2984 #if defined(TARGET_PPC)
2985 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2986 {
2987     CPUArchState *env = mon_get_cpu();
2988     unsigned int u;
2989     int i;
2990
2991     u = 0;
2992     for (i = 0; i < 8; i++)
2993         u |= env->crf[i] << (32 - (4 * i));
2994
2995     return u;
2996 }
2997
2998 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2999 {
3000     CPUArchState *env = mon_get_cpu();
3001     return env->msr;
3002 }
3003
3004 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
3005 {
3006     CPUArchState *env = mon_get_cpu();
3007     return env->xer;
3008 }
3009
3010 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
3011 {
3012     CPUArchState *env = mon_get_cpu();
3013     return cpu_ppc_load_decr(env);
3014 }
3015
3016 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
3017 {
3018     CPUArchState *env = mon_get_cpu();
3019     return cpu_ppc_load_tbu(env);
3020 }
3021
3022 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
3023 {
3024     CPUArchState *env = mon_get_cpu();
3025     return cpu_ppc_load_tbl(env);
3026 }
3027 #endif
3028
3029 #if defined(TARGET_SPARC)
3030 #ifndef TARGET_SPARC64
3031 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
3032 {
3033     CPUArchState *env = mon_get_cpu();
3034
3035     return cpu_get_psr(env);
3036 }
3037 #endif
3038
3039 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
3040 {
3041     CPUArchState *env = mon_get_cpu();
3042     return env->regwptr[val];
3043 }
3044 #endif
3045
3046 static const MonitorDef monitor_defs[] = {
3047 #ifdef TARGET_I386
3048
3049 #define SEG(name, seg) \
3050     { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
3051     { name ".base", offsetof(CPUX86State, segs[seg].base) },\
3052     { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
3053
3054     { "eax", offsetof(CPUX86State, regs[0]) },
3055     { "ecx", offsetof(CPUX86State, regs[1]) },
3056     { "edx", offsetof(CPUX86State, regs[2]) },
3057     { "ebx", offsetof(CPUX86State, regs[3]) },
3058     { "esp|sp", offsetof(CPUX86State, regs[4]) },
3059     { "ebp|fp", offsetof(CPUX86State, regs[5]) },
3060     { "esi", offsetof(CPUX86State, regs[6]) },
3061     { "edi", offsetof(CPUX86State, regs[7]) },
3062 #ifdef TARGET_X86_64
3063     { "r8", offsetof(CPUX86State, regs[8]) },
3064     { "r9", offsetof(CPUX86State, regs[9]) },
3065     { "r10", offsetof(CPUX86State, regs[10]) },
3066     { "r11", offsetof(CPUX86State, regs[11]) },
3067     { "r12", offsetof(CPUX86State, regs[12]) },
3068     { "r13", offsetof(CPUX86State, regs[13]) },
3069     { "r14", offsetof(CPUX86State, regs[14]) },
3070     { "r15", offsetof(CPUX86State, regs[15]) },
3071 #endif
3072     { "eflags", offsetof(CPUX86State, eflags) },
3073     { "eip", offsetof(CPUX86State, eip) },
3074     SEG("cs", R_CS)
3075     SEG("ds", R_DS)
3076     SEG("es", R_ES)
3077     SEG("ss", R_SS)
3078     SEG("fs", R_FS)
3079     SEG("gs", R_GS)
3080     { "pc", 0, monitor_get_pc, },
3081 #elif defined(TARGET_PPC)
3082     /* General purpose registers */
3083     { "r0", offsetof(CPUPPCState, gpr[0]) },
3084     { "r1", offsetof(CPUPPCState, gpr[1]) },
3085     { "r2", offsetof(CPUPPCState, gpr[2]) },
3086     { "r3", offsetof(CPUPPCState, gpr[3]) },
3087     { "r4", offsetof(CPUPPCState, gpr[4]) },
3088     { "r5", offsetof(CPUPPCState, gpr[5]) },
3089     { "r6", offsetof(CPUPPCState, gpr[6]) },
3090     { "r7", offsetof(CPUPPCState, gpr[7]) },
3091     { "r8", offsetof(CPUPPCState, gpr[8]) },
3092     { "r9", offsetof(CPUPPCState, gpr[9]) },
3093     { "r10", offsetof(CPUPPCState, gpr[10]) },
3094     { "r11", offsetof(CPUPPCState, gpr[11]) },
3095     { "r12", offsetof(CPUPPCState, gpr[12]) },
3096     { "r13", offsetof(CPUPPCState, gpr[13]) },
3097     { "r14", offsetof(CPUPPCState, gpr[14]) },
3098     { "r15", offsetof(CPUPPCState, gpr[15]) },
3099     { "r16", offsetof(CPUPPCState, gpr[16]) },
3100     { "r17", offsetof(CPUPPCState, gpr[17]) },
3101     { "r18", offsetof(CPUPPCState, gpr[18]) },
3102     { "r19", offsetof(CPUPPCState, gpr[19]) },
3103     { "r20", offsetof(CPUPPCState, gpr[20]) },
3104     { "r21", offsetof(CPUPPCState, gpr[21]) },
3105     { "r22", offsetof(CPUPPCState, gpr[22]) },
3106     { "r23", offsetof(CPUPPCState, gpr[23]) },
3107     { "r24", offsetof(CPUPPCState, gpr[24]) },
3108     { "r25", offsetof(CPUPPCState, gpr[25]) },
3109     { "r26", offsetof(CPUPPCState, gpr[26]) },
3110     { "r27", offsetof(CPUPPCState, gpr[27]) },
3111     { "r28", offsetof(CPUPPCState, gpr[28]) },
3112     { "r29", offsetof(CPUPPCState, gpr[29]) },
3113     { "r30", offsetof(CPUPPCState, gpr[30]) },
3114     { "r31", offsetof(CPUPPCState, gpr[31]) },
3115     /* Floating point registers */
3116     { "f0", offsetof(CPUPPCState, fpr[0]) },
3117     { "f1", offsetof(CPUPPCState, fpr[1]) },
3118     { "f2", offsetof(CPUPPCState, fpr[2]) },
3119     { "f3", offsetof(CPUPPCState, fpr[3]) },
3120     { "f4", offsetof(CPUPPCState, fpr[4]) },
3121     { "f5", offsetof(CPUPPCState, fpr[5]) },
3122     { "f6", offsetof(CPUPPCState, fpr[6]) },
3123     { "f7", offsetof(CPUPPCState, fpr[7]) },
3124     { "f8", offsetof(CPUPPCState, fpr[8]) },
3125     { "f9", offsetof(CPUPPCState, fpr[9]) },
3126     { "f10", offsetof(CPUPPCState, fpr[10]) },
3127     { "f11", offsetof(CPUPPCState, fpr[11]) },
3128     { "f12", offsetof(CPUPPCState, fpr[12]) },
3129     { "f13", offsetof(CPUPPCState, fpr[13]) },
3130     { "f14", offsetof(CPUPPCState, fpr[14]) },
3131     { "f15", offsetof(CPUPPCState, fpr[15]) },
3132     { "f16", offsetof(CPUPPCState, fpr[16]) },
3133     { "f17", offsetof(CPUPPCState, fpr[17]) },
3134     { "f18", offsetof(CPUPPCState, fpr[18]) },
3135     { "f19", offsetof(CPUPPCState, fpr[19]) },
3136     { "f20", offsetof(CPUPPCState, fpr[20]) },
3137     { "f21", offsetof(CPUPPCState, fpr[21]) },
3138     { "f22", offsetof(CPUPPCState, fpr[22]) },
3139     { "f23", offsetof(CPUPPCState, fpr[23]) },
3140     { "f24", offsetof(CPUPPCState, fpr[24]) },
3141     { "f25", offsetof(CPUPPCState, fpr[25]) },
3142     { "f26", offsetof(CPUPPCState, fpr[26]) },
3143     { "f27", offsetof(CPUPPCState, fpr[27]) },
3144     { "f28", offsetof(CPUPPCState, fpr[28]) },
3145     { "f29", offsetof(CPUPPCState, fpr[29]) },
3146     { "f30", offsetof(CPUPPCState, fpr[30]) },
3147     { "f31", offsetof(CPUPPCState, fpr[31]) },
3148     { "fpscr", offsetof(CPUPPCState, fpscr) },
3149     /* Next instruction pointer */
3150     { "nip|pc", offsetof(CPUPPCState, nip) },
3151     { "lr", offsetof(CPUPPCState, lr) },
3152     { "ctr", offsetof(CPUPPCState, ctr) },
3153     { "decr", 0, &monitor_get_decr, },
3154     { "ccr", 0, &monitor_get_ccr, },
3155     /* Machine state register */
3156     { "msr", 0, &monitor_get_msr, },
3157     { "xer", 0, &monitor_get_xer, },
3158     { "tbu", 0, &monitor_get_tbu, },
3159     { "tbl", 0, &monitor_get_tbl, },
3160     /* Segment registers */
3161     { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
3162     { "sr0", offsetof(CPUPPCState, sr[0]) },
3163     { "sr1", offsetof(CPUPPCState, sr[1]) },
3164     { "sr2", offsetof(CPUPPCState, sr[2]) },
3165     { "sr3", offsetof(CPUPPCState, sr[3]) },
3166     { "sr4", offsetof(CPUPPCState, sr[4]) },
3167     { "sr5", offsetof(CPUPPCState, sr[5]) },
3168     { "sr6", offsetof(CPUPPCState, sr[6]) },
3169     { "sr7", offsetof(CPUPPCState, sr[7]) },
3170     { "sr8", offsetof(CPUPPCState, sr[8]) },
3171     { "sr9", offsetof(CPUPPCState, sr[9]) },
3172     { "sr10", offsetof(CPUPPCState, sr[10]) },
3173     { "sr11", offsetof(CPUPPCState, sr[11]) },
3174     { "sr12", offsetof(CPUPPCState, sr[12]) },
3175     { "sr13", offsetof(CPUPPCState, sr[13]) },
3176     { "sr14", offsetof(CPUPPCState, sr[14]) },
3177     { "sr15", offsetof(CPUPPCState, sr[15]) },
3178     /* Too lazy to put BATs... */
3179     { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
3180
3181     { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3182     { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
3183     { "dar", offsetof(CPUPPCState, spr[SPR_DAR]) },
3184     { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR]) },
3185     { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR]) },
3186     { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3187     { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3188     { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3189     { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3190     { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3191     { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3192     { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3193     { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3194     { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3195     { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3196     { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3197     { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3198     { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3199     { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3200     { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3201     { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3202     { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3203     { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3204     { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3205     { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3206     { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3207     { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3208     { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3209     { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3210     { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3211     { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3212     { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3213     { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3214     { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3215     { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3216     { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3217     { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3218     { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3219     { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3220     { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3221     { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3222     { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3223     { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3224     { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3225     { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3226     { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3227     { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3228     { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3229     { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3230     { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3231     { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3232     { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3233     { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3234     { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3235     { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3236     { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3237     { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3238     { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3239     { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3240     { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3241     { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3242     { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3243     { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3244     { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3245     { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3246     { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3247     { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3248     { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3249     { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
3250
3251 #elif defined(TARGET_SPARC)
3252     { "g0", offsetof(CPUSPARCState, gregs[0]) },
3253     { "g1", offsetof(CPUSPARCState, gregs[1]) },
3254     { "g2", offsetof(CPUSPARCState, gregs[2]) },
3255     { "g3", offsetof(CPUSPARCState, gregs[3]) },
3256     { "g4", offsetof(CPUSPARCState, gregs[4]) },
3257     { "g5", offsetof(CPUSPARCState, gregs[5]) },
3258     { "g6", offsetof(CPUSPARCState, gregs[6]) },
3259     { "g7", offsetof(CPUSPARCState, gregs[7]) },
3260     { "o0", 0, monitor_get_reg },
3261     { "o1", 1, monitor_get_reg },
3262     { "o2", 2, monitor_get_reg },
3263     { "o3", 3, monitor_get_reg },
3264     { "o4", 4, monitor_get_reg },
3265     { "o5", 5, monitor_get_reg },
3266     { "o6", 6, monitor_get_reg },
3267     { "o7", 7, monitor_get_reg },
3268     { "l0", 8, monitor_get_reg },
3269     { "l1", 9, monitor_get_reg },
3270     { "l2", 10, monitor_get_reg },
3271     { "l3", 11, monitor_get_reg },
3272     { "l4", 12, monitor_get_reg },
3273     { "l5", 13, monitor_get_reg },
3274     { "l6", 14, monitor_get_reg },
3275     { "l7", 15, monitor_get_reg },
3276     { "i0", 16, monitor_get_reg },
3277     { "i1", 17, monitor_get_reg },
3278     { "i2", 18, monitor_get_reg },
3279     { "i3", 19, monitor_get_reg },
3280     { "i4", 20, monitor_get_reg },
3281     { "i5", 21, monitor_get_reg },
3282     { "i6", 22, monitor_get_reg },
3283     { "i7", 23, monitor_get_reg },
3284     { "pc", offsetof(CPUSPARCState, pc) },
3285     { "npc", offsetof(CPUSPARCState, npc) },
3286     { "y", offsetof(CPUSPARCState, y) },
3287 #ifndef TARGET_SPARC64
3288     { "psr", 0, &monitor_get_psr, },
3289     { "wim", offsetof(CPUSPARCState, wim) },
3290 #endif
3291     { "tbr", offsetof(CPUSPARCState, tbr) },
3292     { "fsr", offsetof(CPUSPARCState, fsr) },
3293     { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3294     { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3295     { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3296     { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3297     { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3298     { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3299     { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3300     { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3301     { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3302     { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3303     { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3304     { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3305     { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3306     { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3307     { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3308     { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3309     { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3310     { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3311     { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3312     { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3313     { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3314     { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3315     { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3316     { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3317     { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3318     { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3319     { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3320     { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3321     { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3322     { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3323     { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3324     { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
3325 #ifdef TARGET_SPARC64
3326     { "f32", offsetof(CPUSPARCState, fpr[16]) },
3327     { "f34", offsetof(CPUSPARCState, fpr[17]) },
3328     { "f36", offsetof(CPUSPARCState, fpr[18]) },
3329     { "f38", offsetof(CPUSPARCState, fpr[19]) },
3330     { "f40", offsetof(CPUSPARCState, fpr[20]) },
3331     { "f42", offsetof(CPUSPARCState, fpr[21]) },
3332     { "f44", offsetof(CPUSPARCState, fpr[22]) },
3333     { "f46", offsetof(CPUSPARCState, fpr[23]) },
3334     { "f48", offsetof(CPUSPARCState, fpr[24]) },
3335     { "f50", offsetof(CPUSPARCState, fpr[25]) },
3336     { "f52", offsetof(CPUSPARCState, fpr[26]) },
3337     { "f54", offsetof(CPUSPARCState, fpr[27]) },
3338     { "f56", offsetof(CPUSPARCState, fpr[28]) },
3339     { "f58", offsetof(CPUSPARCState, fpr[29]) },
3340     { "f60", offsetof(CPUSPARCState, fpr[30]) },
3341     { "f62", offsetof(CPUSPARCState, fpr[31]) },
3342     { "asi", offsetof(CPUSPARCState, asi) },
3343     { "pstate", offsetof(CPUSPARCState, pstate) },
3344     { "cansave", offsetof(CPUSPARCState, cansave) },
3345     { "canrestore", offsetof(CPUSPARCState, canrestore) },
3346     { "otherwin", offsetof(CPUSPARCState, otherwin) },
3347     { "wstate", offsetof(CPUSPARCState, wstate) },
3348     { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3349     { "fprs", offsetof(CPUSPARCState, fprs) },
3350 #endif
3351 #endif
3352     { NULL },
3353 };
3354
3355 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
3356 expr_error(Monitor *mon, const char *fmt, ...)
3357 {
3358     va_list ap;
3359     va_start(ap, fmt);
3360     monitor_vprintf(mon, fmt, ap);
3361     monitor_printf(mon, "\n");
3362     va_end(ap);
3363     siglongjmp(expr_env, 1);
3364 }
3365
3366 /* return 0 if OK, -1 if not found */
3367 static int get_monitor_def(target_long *pval, const char *name)
3368 {
3369     const MonitorDef *md;
3370     void *ptr;
3371
3372     for(md = monitor_defs; md->name != NULL; md++) {
3373         if (compare_cmd(name, md->name)) {
3374             if (md->get_value) {
3375                 *pval = md->get_value(md, md->offset);
3376             } else {
3377                 CPUArchState *env = mon_get_cpu();
3378                 ptr = (uint8_t *)env + md->offset;
3379                 switch(md->type) {
3380                 case MD_I32:
3381                     *pval = *(int32_t *)ptr;
3382                     break;
3383                 case MD_TLONG:
3384                     *pval = *(target_long *)ptr;
3385                     break;
3386                 default:
3387                     *pval = 0;
3388                     break;
3389                 }
3390             }
3391             return 0;
3392         }
3393     }
3394     return -1;
3395 }
3396
3397 static void next(void)
3398 {
3399     if (*pch != '\0') {
3400         pch++;
3401         while (qemu_isspace(*pch))
3402             pch++;
3403     }
3404 }
3405
3406 static int64_t expr_sum(Monitor *mon);
3407
3408 static int64_t expr_unary(Monitor *mon)
3409 {
3410     int64_t n;
3411     char *p;
3412     int ret;
3413
3414     switch(*pch) {
3415     case '+':
3416         next();
3417         n = expr_unary(mon);
3418         break;
3419     case '-':
3420         next();
3421         n = -expr_unary(mon);
3422         break;
3423     case '~':
3424         next();
3425         n = ~expr_unary(mon);
3426         break;
3427     case '(':
3428         next();
3429         n = expr_sum(mon);
3430         if (*pch != ')') {
3431             expr_error(mon, "')' expected");
3432         }
3433         next();
3434         break;
3435     case '\'':
3436         pch++;
3437         if (*pch == '\0')
3438             expr_error(mon, "character constant expected");
3439         n = *pch;
3440         pch++;
3441         if (*pch != '\'')
3442             expr_error(mon, "missing terminating \' character");
3443         next();
3444         break;
3445     case '$':
3446         {
3447             char buf[128], *q;
3448             target_long reg=0;
3449
3450             pch++;
3451             q = buf;
3452             while ((*pch >= 'a' && *pch <= 'z') ||
3453                    (*pch >= 'A' && *pch <= 'Z') ||
3454                    (*pch >= '0' && *pch <= '9') ||
3455                    *pch == '_' || *pch == '.') {
3456                 if ((q - buf) < sizeof(buf) - 1)
3457                     *q++ = *pch;
3458                 pch++;
3459             }
3460             while (qemu_isspace(*pch))
3461                 pch++;
3462             *q = 0;
3463             ret = get_monitor_def(&reg, buf);
3464             if (ret < 0)
3465                 expr_error(mon, "unknown register");
3466             n = reg;
3467         }
3468         break;
3469     case '\0':
3470         expr_error(mon, "unexpected end of expression");
3471         n = 0;
3472         break;
3473     default:
3474         errno = 0;
3475         n = strtoull(pch, &p, 0);
3476         if (errno == ERANGE) {
3477             expr_error(mon, "number too large");
3478         }
3479         if (pch == p) {
3480             expr_error(mon, "invalid char '%c' in expression", *p);
3481         }
3482         pch = p;
3483         while (qemu_isspace(*pch))
3484             pch++;
3485         break;
3486     }
3487     return n;
3488 }
3489
3490
3491 static int64_t expr_prod(Monitor *mon)
3492 {
3493     int64_t val, val2;
3494     int op;
3495
3496     val = expr_unary(mon);
3497     for(;;) {
3498         op = *pch;
3499         if (op != '*' && op != '/' && op != '%')
3500             break;
3501         next();
3502         val2 = expr_unary(mon);
3503         switch(op) {
3504         default:
3505         case '*':
3506             val *= val2;
3507             break;
3508         case '/':
3509         case '%':
3510             if (val2 == 0)
3511                 expr_error(mon, "division by zero");
3512             if (op == '/')
3513                 val /= val2;
3514             else
3515                 val %= val2;
3516             break;
3517         }
3518     }
3519     return val;
3520 }
3521
3522 static int64_t expr_logic(Monitor *mon)
3523 {
3524     int64_t val, val2;
3525     int op;
3526
3527     val = expr_prod(mon);
3528     for(;;) {
3529         op = *pch;
3530         if (op != '&' && op != '|' && op != '^')
3531             break;
3532         next();
3533         val2 = expr_prod(mon);
3534         switch(op) {
3535         default:
3536         case '&':
3537             val &= val2;
3538             break;
3539         case '|':
3540             val |= val2;
3541             break;
3542         case '^':
3543             val ^= val2;
3544             break;
3545         }
3546     }
3547     return val;
3548 }
3549
3550 static int64_t expr_sum(Monitor *mon)
3551 {
3552     int64_t val, val2;
3553     int op;
3554
3555     val = expr_logic(mon);
3556     for(;;) {
3557         op = *pch;
3558         if (op != '+' && op != '-')
3559             break;
3560         next();
3561         val2 = expr_logic(mon);
3562         if (op == '+')
3563             val += val2;
3564         else
3565             val -= val2;
3566     }
3567     return val;
3568 }
3569
3570 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3571 {
3572     pch = *pp;
3573     if (sigsetjmp(expr_env, 0)) {
3574         *pp = pch;
3575         return -1;
3576     }
3577     while (qemu_isspace(*pch))
3578         pch++;
3579     *pval = expr_sum(mon);
3580     *pp = pch;
3581     return 0;
3582 }
3583
3584 static int get_double(Monitor *mon, double *pval, const char **pp)
3585 {
3586     const char *p = *pp;
3587     char *tailp;
3588     double d;
3589
3590     d = strtod(p, &tailp);
3591     if (tailp == p) {
3592         monitor_printf(mon, "Number expected\n");
3593         return -1;
3594     }
3595     if (d != d || d - d != 0) {
3596         /* NaN or infinity */
3597         monitor_printf(mon, "Bad number\n");
3598         return -1;
3599     }
3600     *pval = d;
3601     *pp = tailp;
3602     return 0;
3603 }
3604
3605 /*
3606  * Store the command-name in cmdname, and return a pointer to
3607  * the remaining of the command string.
3608  */
3609 static const char *get_command_name(const char *cmdline,
3610                                     char *cmdname, size_t nlen)
3611 {
3612     size_t len;
3613     const char *p, *pstart;
3614
3615     p = cmdline;
3616     while (qemu_isspace(*p))
3617         p++;
3618     if (*p == '\0')
3619         return NULL;
3620     pstart = p;
3621     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3622         p++;
3623     len = p - pstart;
3624     if (len > nlen - 1)
3625         len = nlen - 1;
3626     memcpy(cmdname, pstart, len);
3627     cmdname[len] = '\0';
3628     return p;
3629 }
3630
3631 /**
3632  * Read key of 'type' into 'key' and return the current
3633  * 'type' pointer.
3634  */
3635 static char *key_get_info(const char *type, char **key)
3636 {
3637     size_t len;
3638     char *p, *str;
3639
3640     if (*type == ',')
3641         type++;
3642
3643     p = strchr(type, ':');
3644     if (!p) {
3645         *key = NULL;
3646         return NULL;
3647     }
3648     len = p - type;
3649
3650     str = g_malloc(len + 1);
3651     memcpy(str, type, len);
3652     str[len] = '\0';
3653
3654     *key = str;
3655     return ++p;
3656 }
3657
3658 static int default_fmt_format = 'x';
3659 static int default_fmt_size = 4;
3660
3661 static int is_valid_option(const char *c, const char *typestr)
3662 {
3663     char option[3];
3664
3665     option[0] = '-';
3666     option[1] = *c;
3667     option[2] = '\0';
3668
3669     typestr = strstr(typestr, option);
3670     return (typestr != NULL);
3671 }
3672
3673 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3674                                               const char *cmdname)
3675 {
3676     const mon_cmd_t *cmd;
3677
3678     for (cmd = disp_table; cmd->name != NULL; cmd++) {
3679         if (compare_cmd(cmdname, cmd->name)) {
3680             return cmd;
3681         }
3682     }
3683
3684     return NULL;
3685 }
3686
3687 static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3688 {
3689     return search_dispatch_table(qmp_cmds, cmdname);
3690 }
3691
3692 /*
3693  * Parse @cmdline according to command table @table.
3694  * If @cmdline is blank, return NULL.
3695  * If it can't be parsed, report to @mon, and return NULL.
3696  * Else, insert command arguments into @qdict, and return the command.
3697  * If a sub-command table exists, and if @cmdline contains an additional string
3698  * for a sub-command, this function will try to search the sub-command table.
3699  * If no additional string for a sub-command is present, this function will
3700  * return the command found in @table.
3701  * Do not assume the returned command points into @table!  It doesn't
3702  * when the command is a sub-command.
3703  */
3704 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3705                                               const char *cmdline,
3706                                               int start,
3707                                               mon_cmd_t *table,
3708                                               QDict *qdict)
3709 {
3710     const char *p, *typestr;
3711     int c;
3712     const mon_cmd_t *cmd;
3713     char cmdname[256];
3714     char buf[1024];
3715     char *key;
3716
3717 #ifdef DEBUG
3718     monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
3719 #endif
3720
3721     /* extract the command name */
3722     p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
3723     if (!p)
3724         return NULL;
3725
3726     cmd = search_dispatch_table(table, cmdname);
3727     if (!cmd) {
3728         monitor_printf(mon, "unknown command: '%.*s'\n",
3729                        (int)(p - cmdline), cmdline);
3730         return NULL;
3731     }
3732
3733     /* filter out following useless space */
3734     while (qemu_isspace(*p)) {
3735         p++;
3736     }
3737     /* search sub command */
3738     if (cmd->sub_table != NULL) {
3739         /* check if user set additional command */
3740         if (*p == '\0') {
3741             return cmd;
3742         }
3743         return monitor_parse_command(mon, cmdline, p - cmdline,
3744                                      cmd->sub_table, qdict);
3745     }
3746
3747     /* parse the parameters */
3748     typestr = cmd->args_type;
3749     for(;;) {
3750         typestr = key_get_info(typestr, &key);
3751         if (!typestr)
3752             break;
3753         c = *typestr;
3754         typestr++;
3755         switch(c) {
3756         case 'F':
3757         case 'B':
3758         case 's':
3759             {
3760                 int ret;
3761
3762                 while (qemu_isspace(*p))
3763                     p++;
3764                 if (*typestr == '?') {
3765                     typestr++;
3766                     if (*p == '\0') {
3767                         /* no optional string: NULL argument */
3768                         break;
3769                     }
3770                 }
3771                 ret = get_str(buf, sizeof(buf), &p);
3772                 if (ret < 0) {
3773                     switch(c) {
3774                     case 'F':
3775                         monitor_printf(mon, "%s: filename expected\n",
3776                                        cmdname);
3777                         break;
3778                     case 'B':
3779                         monitor_printf(mon, "%s: block device name expected\n",
3780                                        cmdname);
3781                         break;
3782                     default:
3783                         monitor_printf(mon, "%s: string expected\n", cmdname);
3784                         break;
3785                     }
3786                     goto fail;
3787                 }
3788                 qdict_put(qdict, key, qstring_from_str(buf));
3789             }
3790             break;
3791         case 'O':
3792             {
3793                 QemuOptsList *opts_list;
3794                 QemuOpts *opts;
3795
3796                 opts_list = qemu_find_opts(key);
3797                 if (!opts_list || opts_list->desc->name) {
3798                     goto bad_type;
3799                 }
3800                 while (qemu_isspace(*p)) {
3801                     p++;
3802                 }
3803                 if (!*p)
3804                     break;
3805                 if (get_str(buf, sizeof(buf), &p) < 0) {
3806                     goto fail;
3807                 }
3808                 opts = qemu_opts_parse(opts_list, buf, 1);
3809                 if (!opts) {
3810                     goto fail;
3811                 }
3812                 qemu_opts_to_qdict(opts, qdict);
3813                 qemu_opts_del(opts);
3814             }
3815             break;
3816         case '/':
3817             {
3818                 int count, format, size;
3819
3820                 while (qemu_isspace(*p))
3821                     p++;
3822                 if (*p == '/') {
3823                     /* format found */
3824                     p++;
3825                     count = 1;
3826                     if (qemu_isdigit(*p)) {
3827                         count = 0;
3828                         while (qemu_isdigit(*p)) {
3829                             count = count * 10 + (*p - '0');
3830                             p++;
3831                         }
3832                     }
3833                     size = -1;
3834                     format = -1;
3835                     for(;;) {
3836                         switch(*p) {
3837                         case 'o':
3838                         case 'd':
3839                         case 'u':
3840                         case 'x':
3841                         case 'i':
3842                         case 'c':
3843                             format = *p++;
3844                             break;
3845                         case 'b':
3846                             size = 1;
3847                             p++;
3848                             break;
3849                         case 'h':
3850                             size = 2;
3851                             p++;
3852                             break;
3853                         case 'w':
3854                             size = 4;
3855                             p++;
3856                             break;
3857                         case 'g':
3858                         case 'L':
3859                             size = 8;
3860                             p++;
3861                             break;
3862                         default:
3863                             goto next;
3864                         }
3865                     }
3866                 next:
3867                     if (*p != '\0' && !qemu_isspace(*p)) {
3868                         monitor_printf(mon, "invalid char in format: '%c'\n",
3869                                        *p);
3870                         goto fail;
3871                     }
3872                     if (format < 0)
3873                         format = default_fmt_format;
3874                     if (format != 'i') {
3875                         /* for 'i', not specifying a size gives -1 as size */
3876                         if (size < 0)
3877                             size = default_fmt_size;
3878                         default_fmt_size = size;
3879                     }
3880                     default_fmt_format = format;
3881                 } else {
3882                     count = 1;
3883                     format = default_fmt_format;
3884                     if (format != 'i') {
3885                         size = default_fmt_size;
3886                     } else {
3887                         size = -1;
3888                     }
3889                 }
3890                 qdict_put(qdict, "count", qint_from_int(count));
3891                 qdict_put(qdict, "format", qint_from_int(format));
3892                 qdict_put(qdict, "size", qint_from_int(size));
3893             }
3894             break;
3895         case 'i':
3896         case 'l':
3897         case 'M':
3898             {
3899                 int64_t val;
3900
3901                 while (qemu_isspace(*p))
3902                     p++;
3903                 if (*typestr == '?' || *typestr == '.') {
3904                     if (*typestr == '?') {
3905                         if (*p == '\0') {
3906                             typestr++;
3907                             break;
3908                         }
3909                     } else {
3910                         if (*p == '.') {
3911                             p++;
3912                             while (qemu_isspace(*p))
3913                                 p++;
3914                         } else {
3915                             typestr++;
3916                             break;
3917                         }
3918                     }
3919                     typestr++;
3920                 }
3921                 if (get_expr(mon, &val, &p))
3922                     goto fail;
3923                 /* Check if 'i' is greater than 32-bit */
3924                 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3925                     monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3926                     monitor_printf(mon, "integer is for 32-bit values\n");
3927                     goto fail;
3928                 } else if (c == 'M') {
3929                     if (val < 0) {
3930                         monitor_printf(mon, "enter a positive value\n");
3931                         goto fail;
3932                     }
3933                     val <<= 20;
3934                 }
3935                 qdict_put(qdict, key, qint_from_int(val));
3936             }
3937             break;
3938         case 'o':
3939             {
3940                 int64_t val;
3941                 char *end;
3942
3943                 while (qemu_isspace(*p)) {
3944                     p++;
3945                 }
3946                 if (*typestr == '?') {
3947                     typestr++;
3948                     if (*p == '\0') {
3949                         break;
3950                     }
3951                 }
3952                 val = strtosz(p, &end);
3953                 if (val < 0) {
3954                     monitor_printf(mon, "invalid size\n");
3955                     goto fail;
3956                 }
3957                 qdict_put(qdict, key, qint_from_int(val));
3958                 p = end;
3959             }
3960             break;
3961         case 'T':
3962             {
3963                 double val;
3964
3965                 while (qemu_isspace(*p))
3966                     p++;
3967                 if (*typestr == '?') {
3968                     typestr++;
3969                     if (*p == '\0') {
3970                         break;
3971                     }
3972                 }
3973                 if (get_double(mon, &val, &p) < 0) {
3974                     goto fail;
3975                 }
3976                 if (p[0] && p[1] == 's') {
3977                     switch (*p) {
3978                     case 'm':
3979                         val /= 1e3; p += 2; break;
3980                     case 'u':
3981                         val /= 1e6; p += 2; break;
3982                     case 'n':
3983                         val /= 1e9; p += 2; break;
3984                     }
3985                 }
3986                 if (*p && !qemu_isspace(*p)) {
3987                     monitor_printf(mon, "Unknown unit suffix\n");
3988                     goto fail;
3989                 }
3990                 qdict_put(qdict, key, qfloat_from_double(val));
3991             }
3992             break;
3993         case 'b':
3994             {
3995                 const char *beg;
3996                 int val;
3997
3998                 while (qemu_isspace(*p)) {
3999                     p++;
4000                 }
4001                 beg = p;
4002                 while (qemu_isgraph(*p)) {
4003                     p++;
4004                 }
4005                 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4006                     val = 1;
4007                 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4008                     val = 0;
4009                 } else {
4010                     monitor_printf(mon, "Expected 'on' or 'off'\n");
4011                     goto fail;
4012                 }
4013                 qdict_put(qdict, key, qbool_from_int(val));
4014             }
4015             break;
4016         case '-':
4017             {
4018                 const char *tmp = p;
4019                 int skip_key = 0;
4020                 /* option */
4021
4022                 c = *typestr++;
4023                 if (c == '\0')
4024                     goto bad_type;
4025                 while (qemu_isspace(*p))
4026                     p++;
4027                 if (*p == '-') {
4028                     p++;
4029                     if(c != *p) {
4030                         if(!is_valid_option(p, typestr)) {
4031
4032                             monitor_printf(mon, "%s: unsupported option -%c\n",
4033                                            cmdname, *p);
4034                             goto fail;
4035                         } else {
4036                             skip_key = 1;
4037                         }
4038                     }
4039                     if(skip_key) {
4040                         p = tmp;
4041                     } else {
4042                         /* has option */
4043                         p++;
4044                         qdict_put(qdict, key, qbool_from_int(1));
4045                     }
4046                 }
4047             }
4048             break;
4049         case 'S':
4050             {
4051                 /* package all remaining string */
4052                 int len;
4053
4054                 while (qemu_isspace(*p)) {
4055                     p++;
4056                 }
4057                 if (*typestr == '?') {
4058                     typestr++;
4059                     if (*p == '\0') {
4060                         /* no remaining string: NULL argument */
4061                         break;
4062                     }
4063                 }
4064                 len = strlen(p);
4065                 if (len <= 0) {
4066                     monitor_printf(mon, "%s: string expected\n",
4067                                    cmdname);
4068                     break;
4069                 }
4070                 qdict_put(qdict, key, qstring_from_str(p));
4071                 p += len;
4072             }
4073             break;
4074         default:
4075         bad_type:
4076             monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
4077             goto fail;
4078         }
4079         g_free(key);
4080         key = NULL;
4081     }
4082     /* check that all arguments were parsed */
4083     while (qemu_isspace(*p))
4084         p++;
4085     if (*p != '\0') {
4086         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4087                        cmdname);
4088         goto fail;
4089     }
4090
4091     return cmd;
4092
4093 fail:
4094     g_free(key);
4095     return NULL;
4096 }
4097
4098 void monitor_set_error(Monitor *mon, QError *qerror)
4099 {
4100     /* report only the first error */
4101     if (!mon->error) {
4102         mon->error = qerror;
4103     } else {
4104         QDECREF(qerror);
4105     }
4106 }
4107
4108 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4109 {
4110     if (ret && !monitor_has_error(mon)) {
4111         /*
4112          * If it returns failure, it must have passed on error.
4113          *
4114          * Action: Report an internal error to the client if in QMP.
4115          */
4116         qerror_report(QERR_UNDEFINED_ERROR);
4117     }
4118 }
4119
4120 static void handle_user_command(Monitor *mon, const char *cmdline)
4121 {
4122     QDict *qdict;
4123     const mon_cmd_t *cmd;
4124
4125     qdict = qdict_new();
4126
4127     cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
4128     if (!cmd)
4129         goto out;
4130
4131     if (handler_is_async(cmd)) {
4132         user_async_cmd_handler(mon, cmd, qdict);
4133     } else if (handler_is_qobject(cmd)) {
4134         QObject *data = NULL;
4135
4136         /* XXX: ignores the error code */
4137         cmd->mhandler.cmd_new(mon, qdict, &data);
4138         assert(!monitor_has_error(mon));
4139         if (data) {
4140             cmd->user_print(mon, data);
4141             qobject_decref(data);
4142         }
4143     } else {
4144         cmd->mhandler.cmd(mon, qdict);
4145     }
4146
4147 out:
4148     QDECREF(qdict);
4149 }
4150
4151 static void cmd_completion(Monitor *mon, const char *name, const char *list)
4152 {
4153     const char *p, *pstart;
4154     char cmd[128];
4155     int len;
4156
4157     p = list;
4158     for(;;) {
4159         pstart = p;
4160         p = strchr(p, '|');
4161         if (!p)
4162             p = pstart + strlen(pstart);
4163         len = p - pstart;
4164         if (len > sizeof(cmd) - 2)
4165             len = sizeof(cmd) - 2;
4166         memcpy(cmd, pstart, len);
4167         cmd[len] = '\0';
4168         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
4169             readline_add_completion(mon->rs, cmd);
4170         }
4171         if (*p == '\0')
4172             break;
4173         p++;
4174     }
4175 }
4176
4177 static void file_completion(Monitor *mon, const char *input)
4178 {
4179     DIR *ffs;
4180     struct dirent *d;
4181     char path[1024];
4182     char file[1024], file_prefix[1024];
4183     int input_path_len;
4184     const char *p;
4185
4186     p = strrchr(input, '/');
4187     if (!p) {
4188         input_path_len = 0;
4189         pstrcpy(file_prefix, sizeof(file_prefix), input);
4190         pstrcpy(path, sizeof(path), ".");
4191     } else {
4192         input_path_len = p - input + 1;
4193         memcpy(path, input, input_path_len);
4194         if (input_path_len > sizeof(path) - 1)
4195             input_path_len = sizeof(path) - 1;
4196         path[input_path_len] = '\0';
4197         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4198     }
4199 #ifdef DEBUG_COMPLETION
4200     monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
4201                    input, path, file_prefix);
4202 #endif
4203     ffs = opendir(path);
4204     if (!ffs)
4205         return;
4206     for(;;) {
4207         struct stat sb;
4208         d = readdir(ffs);
4209         if (!d)
4210             break;
4211
4212         if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4213             continue;
4214         }
4215
4216         if (strstart(d->d_name, file_prefix, NULL)) {
4217             memcpy(file, input, input_path_len);
4218             if (input_path_len < sizeof(file))
4219                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4220                         d->d_name);
4221             /* stat the file to find out if it's a directory.
4222              * In that case add a slash to speed up typing long paths
4223              */
4224             if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
4225                 pstrcat(file, sizeof(file), "/");
4226             }
4227             readline_add_completion(mon->rs, file);
4228         }
4229     }
4230     closedir(ffs);
4231 }
4232
4233 typedef struct MonitorBlockComplete {
4234     Monitor *mon;
4235     const char *input;
4236 } MonitorBlockComplete;
4237
4238 static void block_completion_it(void *opaque, BlockDriverState *bs)
4239 {
4240     const char *name = bdrv_get_device_name(bs);
4241     MonitorBlockComplete *mbc = opaque;
4242     Monitor *mon = mbc->mon;
4243     const char *input = mbc->input;
4244
4245     if (input[0] == '\0' ||
4246         !strncmp(name, (char *)input, strlen(input))) {
4247         readline_add_completion(mon->rs, name);
4248     }
4249 }
4250
4251 static const char *next_arg_type(const char *typestr)
4252 {
4253     const char *p = strchr(typestr, ':');
4254     return (p != NULL ? ++p : typestr);
4255 }
4256
4257 static void monitor_find_completion_by_table(Monitor *mon,
4258                                              const mon_cmd_t *cmd_table,
4259                                              char **args,
4260                                              int nb_args)
4261 {
4262     const char *cmdname;
4263     int i;
4264     const char *ptype, *str;
4265     const mon_cmd_t *cmd;
4266     MonitorBlockComplete mbs;
4267
4268     if (nb_args <= 1) {
4269         /* command completion */
4270         if (nb_args == 0)
4271             cmdname = "";
4272         else
4273             cmdname = args[0];
4274         readline_set_completion_index(mon->rs, strlen(cmdname));
4275         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4276             cmd_completion(mon, cmdname, cmd->name);
4277         }
4278     } else {
4279         /* find the command */
4280         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
4281             if (compare_cmd(args[0], cmd->name)) {
4282                 break;
4283             }
4284         }
4285         if (!cmd->name) {
4286             return;
4287         }
4288
4289         if (cmd->sub_table) {
4290             /* do the job again */
4291             return monitor_find_completion_by_table(mon, cmd->sub_table,
4292                                                     &args[1], nb_args - 1);
4293         }
4294
4295         ptype = next_arg_type(cmd->args_type);
4296         for(i = 0; i < nb_args - 2; i++) {
4297             if (*ptype != '\0') {
4298                 ptype = next_arg_type(ptype);
4299                 while (*ptype == '?')
4300                     ptype = next_arg_type(ptype);
4301             }
4302         }
4303         str = args[nb_args - 1];
4304         if (*ptype == '-' && ptype[1] != '\0') {
4305             ptype = next_arg_type(ptype);
4306         }
4307         switch(*ptype) {
4308         case 'F':
4309             /* file completion */
4310             readline_set_completion_index(mon->rs, strlen(str));
4311             file_completion(mon, str);
4312             break;
4313         case 'B':
4314             /* block device name completion */
4315             mbs.mon = mon;
4316             mbs.input = str;
4317             readline_set_completion_index(mon->rs, strlen(str));
4318             bdrv_iterate(block_completion_it, &mbs);
4319             break;
4320         case 's':
4321         case 'S':
4322             if (!strcmp(cmd->name, "sendkey")) {
4323                 char *sep = strrchr(str, '-');
4324                 if (sep)
4325                     str = sep + 1;
4326                 readline_set_completion_index(mon->rs, strlen(str));
4327                 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4328                     cmd_completion(mon, str, QKeyCode_lookup[i]);
4329                 }
4330             } else if (!strcmp(cmd->name, "help|?")) {
4331                 monitor_find_completion_by_table(mon, cmd_table,
4332                                                  &args[1], nb_args - 1);
4333             }
4334             break;
4335         default:
4336             break;
4337         }
4338     }
4339 }
4340
4341 static void monitor_find_completion(void *opaque,
4342                                     const char *cmdline)
4343 {
4344     Monitor *mon = opaque;
4345     char *args[MAX_ARGS];
4346     int nb_args, len;
4347
4348     /* 1. parse the cmdline */
4349     if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4350         return;
4351     }
4352 #ifdef DEBUG_COMPLETION
4353     for (i = 0; i < nb_args; i++) {
4354         monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4355     }
4356 #endif
4357
4358     /* if the line ends with a space, it means we want to complete the
4359        next arg */
4360     len = strlen(cmdline);
4361     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4362         if (nb_args >= MAX_ARGS) {
4363             goto cleanup;
4364         }
4365         args[nb_args++] = g_strdup("");
4366     }
4367
4368     /* 2. auto complete according to args */
4369     monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4370
4371 cleanup:
4372     free_cmdline_args(args, nb_args);
4373 }
4374
4375 static int monitor_can_read(void *opaque)
4376 {
4377     Monitor *mon = opaque;
4378
4379     return (mon->suspend_cnt == 0) ? 1 : 0;
4380 }
4381
4382 static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4383 {
4384     int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4385     return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4386 }
4387
4388 /*
4389  * Argument validation rules:
4390  *
4391  * 1. The argument must exist in cmd_args qdict
4392  * 2. The argument type must be the expected one
4393  *
4394  * Special case: If the argument doesn't exist in cmd_args and
4395  *               the QMP_ACCEPT_UNKNOWNS flag is set, then the
4396  *               checking is skipped for it.
4397  */
4398 static int check_client_args_type(const QDict *client_args,
4399                                   const QDict *cmd_args, int flags)
4400 {
4401     const QDictEntry *ent;
4402
4403     for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4404         QObject *obj;
4405         QString *arg_type;
4406         const QObject *client_arg = qdict_entry_value(ent);
4407         const char *client_arg_name = qdict_entry_key(ent);
4408
4409         obj = qdict_get(cmd_args, client_arg_name);
4410         if (!obj) {
4411             if (flags & QMP_ACCEPT_UNKNOWNS) {
4412                 /* handler accepts unknowns */
4413                 continue;
4414             }
4415             /* client arg doesn't exist */
4416             qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4417             return -1;
4418         }
4419
4420         arg_type = qobject_to_qstring(obj);
4421         assert(arg_type != NULL);
4422
4423         /* check if argument's type is correct */
4424         switch (qstring_get_str(arg_type)[0]) {
4425         case 'F':
4426         case 'B':
4427         case 's':
4428             if (qobject_type(client_arg) != QTYPE_QSTRING) {
4429                 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4430                               "string");
4431                 return -1;
4432             }
4433         break;
4434         case 'i':
4435         case 'l':
4436         case 'M':
4437         case 'o':
4438             if (qobject_type(client_arg) != QTYPE_QINT) {
4439                 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4440                               "int");
4441                 return -1;
4442             }
4443             break;
4444         case 'T':
4445             if (qobject_type(client_arg) != QTYPE_QINT &&
4446                 qobject_type(client_arg) != QTYPE_QFLOAT) {
4447                 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4448                               "number");
4449                return -1;
4450             }
4451             break;
4452         case 'b':
4453         case '-':
4454             if (qobject_type(client_arg) != QTYPE_QBOOL) {
4455                 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4456                               "bool");
4457                return -1;
4458             }
4459             break;
4460         case 'O':
4461             assert(flags & QMP_ACCEPT_UNKNOWNS);
4462             break;
4463         case 'q':
4464             /* Any QObject can be passed.  */
4465             break;
4466         case '/':
4467         case '.':
4468             /*
4469              * These types are not supported by QMP and thus are not
4470              * handled here. Fall through.
4471              */
4472         default:
4473             abort();
4474         }
4475     }
4476
4477     return 0;
4478 }
4479
4480 /*
4481  * - Check if the client has passed all mandatory args
4482  * - Set special flags for argument validation
4483  */
4484 static int check_mandatory_args(const QDict *cmd_args,
4485                                 const QDict *client_args, int *flags)
4486 {
4487     const QDictEntry *ent;
4488
4489     for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4490         const char *cmd_arg_name = qdict_entry_key(ent);
4491         QString *type = qobject_to_qstring(qdict_entry_value(ent));
4492         assert(type != NULL);
4493
4494         if (qstring_get_str(type)[0] == 'O') {
4495             assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4496             *flags |= QMP_ACCEPT_UNKNOWNS;
4497         } else if (qstring_get_str(type)[0] != '-' &&
4498                    qstring_get_str(type)[1] != '?' &&
4499                    !qdict_haskey(client_args, cmd_arg_name)) {
4500             qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4501             return -1;
4502         }
4503     }
4504
4505     return 0;
4506 }
4507
4508 static QDict *qdict_from_args_type(const char *args_type)
4509 {
4510     int i;
4511     QDict *qdict;
4512     QString *key, *type, *cur_qs;
4513
4514     assert(args_type != NULL);
4515
4516     qdict = qdict_new();
4517
4518     if (args_type == NULL || args_type[0] == '\0') {
4519         /* no args, empty qdict */
4520         goto out;
4521     }
4522
4523     key = qstring_new();
4524     type = qstring_new();
4525
4526     cur_qs = key;
4527
4528     for (i = 0;; i++) {
4529         switch (args_type[i]) {
4530             case ',':
4531             case '\0':
4532                 qdict_put(qdict, qstring_get_str(key), type);
4533                 QDECREF(key);
4534                 if (args_type[i] == '\0') {
4535                     goto out;
4536                 }
4537                 type = qstring_new(); /* qdict has ref */
4538                 cur_qs = key = qstring_new();
4539                 break;
4540             case ':':
4541                 cur_qs = type;
4542                 break;
4543             default:
4544                 qstring_append_chr(cur_qs, args_type[i]);
4545                 break;
4546         }
4547     }
4548
4549 out:
4550     return qdict;
4551 }
4552
4553 /*
4554  * Client argument checking rules:
4555  *
4556  * 1. Client must provide all mandatory arguments
4557  * 2. Each argument provided by the client must be expected
4558  * 3. Each argument provided by the client must have the type expected
4559  *    by the command
4560  */
4561 static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4562 {
4563     int flags, err;
4564     QDict *cmd_args;
4565
4566     cmd_args = qdict_from_args_type(cmd->args_type);
4567
4568     flags = 0;
4569     err = check_mandatory_args(cmd_args, client_args, &flags);
4570     if (err) {
4571         goto out;
4572     }
4573
4574     err = check_client_args_type(client_args, cmd_args, flags);
4575
4576 out:
4577     QDECREF(cmd_args);
4578     return err;
4579 }
4580
4581 /*
4582  * Input object checking rules
4583  *
4584  * 1. Input object must be a dict
4585  * 2. The "execute" key must exist
4586  * 3. The "execute" key must be a string
4587  * 4. If the "arguments" key exists, it must be a dict
4588  * 5. If the "id" key exists, it can be anything (ie. json-value)
4589  * 6. Any argument not listed above is considered invalid
4590  */
4591 static QDict *qmp_check_input_obj(QObject *input_obj)
4592 {
4593     const QDictEntry *ent;
4594     int has_exec_key = 0;
4595     QDict *input_dict;
4596
4597     if (qobject_type(input_obj) != QTYPE_QDICT) {
4598         qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4599         return NULL;
4600     }
4601
4602     input_dict = qobject_to_qdict(input_obj);
4603
4604     for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4605         const char *arg_name = qdict_entry_key(ent);
4606         const QObject *arg_obj = qdict_entry_value(ent);
4607
4608         if (!strcmp(arg_name, "execute")) {
4609             if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4610                 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4611                               "string");
4612                 return NULL;
4613             }
4614             has_exec_key = 1;
4615         } else if (!strcmp(arg_name, "arguments")) {
4616             if (qobject_type(arg_obj) != QTYPE_QDICT) {
4617                 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4618                               "object");
4619                 return NULL;
4620             }
4621         } else if (!strcmp(arg_name, "id")) {
4622             /* FIXME: check duplicated IDs for async commands */
4623         } else {
4624             qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4625             return NULL;
4626         }
4627     }
4628
4629     if (!has_exec_key) {
4630         qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4631         return NULL;
4632     }
4633
4634     return input_dict;
4635 }
4636
4637 static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4638                          const QDict *params)
4639 {
4640     int ret;
4641     QObject *data = NULL;
4642
4643     ret = cmd->mhandler.cmd_new(mon, params, &data);
4644     handler_audit(mon, cmd, ret);
4645     monitor_protocol_emitter(mon, data);
4646     qobject_decref(data);
4647 }
4648
4649 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4650 {
4651     int err;
4652     QObject *obj;
4653     QDict *input, *args;
4654     const mon_cmd_t *cmd;
4655     const char *cmd_name;
4656     Monitor *mon = cur_mon;
4657
4658     args = input = NULL;
4659
4660     obj = json_parser_parse(tokens, NULL);
4661     if (!obj) {
4662         // FIXME: should be triggered in json_parser_parse()
4663         qerror_report(QERR_JSON_PARSING);
4664         goto err_out;
4665     }
4666
4667     input = qmp_check_input_obj(obj);
4668     if (!input) {
4669         qobject_decref(obj);
4670         goto err_out;
4671     }
4672
4673     mon->mc->id = qdict_get(input, "id");
4674     qobject_incref(mon->mc->id);
4675
4676     cmd_name = qdict_get_str(input, "execute");
4677     trace_handle_qmp_command(mon, cmd_name);
4678     if (invalid_qmp_mode(mon, cmd_name)) {
4679         qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4680         goto err_out;
4681     }
4682
4683     cmd = qmp_find_cmd(cmd_name);
4684     if (!cmd) {
4685         qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4686         goto err_out;
4687     }
4688
4689     obj = qdict_get(input, "arguments");
4690     if (!obj) {
4691         args = qdict_new();
4692     } else {
4693         args = qobject_to_qdict(obj);
4694         QINCREF(args);
4695     }
4696
4697     err = qmp_check_client_args(cmd, args);
4698     if (err < 0) {
4699         goto err_out;
4700     }
4701
4702     if (handler_is_async(cmd)) {
4703         err = qmp_async_cmd_handler(mon, cmd, args);
4704         if (err) {
4705             /* emit the error response */
4706             goto err_out;
4707         }
4708     } else {
4709         qmp_call_cmd(mon, cmd, args);
4710     }
4711
4712     goto out;
4713
4714 err_out:
4715     monitor_protocol_emitter(mon, NULL);
4716 out:
4717     QDECREF(input);
4718     QDECREF(args);
4719 }
4720
4721 /**
4722  * monitor_control_read(): Read and handle QMP input
4723  */
4724 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4725 {
4726     Monitor *old_mon = cur_mon;
4727
4728     cur_mon = opaque;
4729
4730     json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4731
4732     cur_mon = old_mon;
4733 }
4734
4735 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4736 {
4737     Monitor *old_mon = cur_mon;
4738     int i;
4739
4740     cur_mon = opaque;
4741
4742     if (cur_mon->rs) {
4743         for (i = 0; i < size; i++)
4744             readline_handle_byte(cur_mon->rs, buf[i]);
4745     } else {
4746         if (size == 0 || buf[size - 1] != 0)
4747             monitor_printf(cur_mon, "corrupted command\n");
4748         else
4749             handle_user_command(cur_mon, (char *)buf);
4750     }
4751
4752     cur_mon = old_mon;
4753 }
4754
4755 static void monitor_command_cb(void *opaque, const char *cmdline,
4756                                void *readline_opaque)
4757 {
4758     Monitor *mon = opaque;
4759
4760     monitor_suspend(mon);
4761     handle_user_command(mon, cmdline);
4762     monitor_resume(mon);
4763 }
4764
4765 int monitor_suspend(Monitor *mon)
4766 {
4767     if (!mon->rs)
4768         return -ENOTTY;
4769     mon->suspend_cnt++;
4770     return 0;
4771 }
4772
4773 void monitor_resume(Monitor *mon)
4774 {
4775     if (!mon->rs)
4776         return;
4777     if (--mon->suspend_cnt == 0)
4778         readline_show_prompt(mon->rs);
4779 }
4780
4781 static QObject *get_qmp_greeting(void)
4782 {
4783     QObject *ver = NULL;
4784
4785     qmp_marshal_input_query_version(NULL, NULL, &ver);
4786     return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4787 }
4788
4789 /**
4790  * monitor_control_event(): Print QMP gretting
4791  */
4792 static void monitor_control_event(void *opaque, int event)
4793 {
4794     QObject *data;
4795     Monitor *mon = opaque;
4796
4797     switch (event) {
4798     case CHR_EVENT_OPENED:
4799         mon->mc->command_mode = 0;
4800         data = get_qmp_greeting();
4801         monitor_json_emitter(mon, data);
4802         qobject_decref(data);
4803         mon_refcount++;
4804         break;
4805     case CHR_EVENT_CLOSED:
4806         json_message_parser_destroy(&mon->mc->parser);
4807         json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4808         mon_refcount--;
4809         monitor_fdsets_cleanup();
4810         break;
4811     }
4812 }
4813
4814 static void monitor_event(void *opaque, int event)
4815 {
4816     Monitor *mon = opaque;
4817
4818     switch (event) {
4819     case CHR_EVENT_MUX_IN:
4820         mon->mux_out = 0;
4821         if (mon->reset_seen) {
4822             readline_restart(mon->rs);
4823             monitor_resume(mon);
4824             monitor_flush(mon);
4825         } else {
4826             mon->suspend_cnt = 0;
4827         }
4828         break;
4829
4830     case CHR_EVENT_MUX_OUT:
4831         if (mon->reset_seen) {
4832             if (mon->suspend_cnt == 0) {
4833                 monitor_printf(mon, "\n");
4834             }
4835             monitor_flush(mon);
4836             monitor_suspend(mon);
4837         } else {
4838             mon->suspend_cnt++;
4839         }
4840         mon->mux_out = 1;
4841         break;
4842
4843     case CHR_EVENT_OPENED:
4844         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4845                        "information\n", QEMU_VERSION);
4846         if (!mon->mux_out) {
4847             readline_show_prompt(mon->rs);
4848         }
4849         mon->reset_seen = 1;
4850         mon_refcount++;
4851         break;
4852
4853     case CHR_EVENT_CLOSED:
4854         mon_refcount--;
4855         monitor_fdsets_cleanup();
4856         break;
4857     }
4858 }
4859
4860 static int
4861 compare_mon_cmd(const void *a, const void *b)
4862 {
4863     return strcmp(((const mon_cmd_t *)a)->name,
4864             ((const mon_cmd_t *)b)->name);
4865 }
4866
4867 static void sortcmdlist(void)
4868 {
4869     int array_num;
4870     int elem_size = sizeof(mon_cmd_t);
4871
4872     array_num = sizeof(mon_cmds)/elem_size-1;
4873     qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4874
4875     array_num = sizeof(info_cmds)/elem_size-1;
4876     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4877 }
4878
4879
4880 /*
4881  * Local variables:
4882  *  c-indent-level: 4
4883  *  c-basic-offset: 4
4884  *  tab-width: 8
4885  * End:
4886  */
4887
4888 /* These functions just adapt the readline interface in a typesafe way.  We
4889  * could cast function pointers but that discards compiler checks.
4890  */
4891 static void monitor_readline_printf(void *opaque, const char *fmt, ...)
4892 {
4893     va_list ap;
4894     va_start(ap, fmt);
4895     monitor_vprintf(opaque, fmt, ap);
4896     va_end(ap);
4897 }
4898
4899 static void monitor_readline_flush(void *opaque)
4900 {
4901     monitor_flush(opaque);
4902 }
4903
4904 void monitor_init(CharDriverState *chr, int flags)
4905 {
4906     static int is_first_init = 1;
4907     Monitor *mon;
4908
4909     if (is_first_init) {
4910         monitor_protocol_event_init();
4911         sortcmdlist();
4912         is_first_init = 0;
4913     }
4914
4915     mon = g_malloc(sizeof(*mon));
4916     monitor_data_init(mon);
4917
4918     mon->chr = chr;
4919     mon->flags = flags;
4920     if (flags & MONITOR_USE_READLINE) {
4921         mon->rs = readline_init(monitor_readline_printf,
4922                                 monitor_readline_flush,
4923                                 mon,
4924                                 monitor_find_completion);
4925         monitor_read_command(mon, 0);
4926     }
4927
4928     if (monitor_ctrl_mode(mon)) {
4929         mon->mc = g_malloc0(sizeof(MonitorControl));
4930         /* Control mode requires special handlers */
4931         qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4932                               monitor_control_event, mon);
4933         qemu_chr_fe_set_echo(chr, true);
4934
4935         json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4936     } else {
4937         qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4938                               monitor_event, mon);
4939     }
4940
4941     QLIST_INSERT_HEAD(&mon_list, mon, entry);
4942     if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4943         default_mon = mon;
4944 }
4945
4946 static void bdrv_password_cb(void *opaque, const char *password,
4947                              void *readline_opaque)
4948 {
4949     Monitor *mon = opaque;
4950     BlockDriverState *bs = readline_opaque;
4951     int ret = 0;
4952
4953     if (bdrv_set_key(bs, password) != 0) {
4954         monitor_printf(mon, "invalid password\n");
4955         ret = -EPERM;
4956     }
4957     if (mon->password_completion_cb)
4958         mon->password_completion_cb(mon->password_opaque, ret);
4959
4960     monitor_read_command(mon, 1);
4961 }
4962
4963 ReadLineState *monitor_get_rs(Monitor *mon)
4964 {
4965     return mon->rs;
4966 }
4967
4968 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4969                                 BlockDriverCompletionFunc *completion_cb,
4970                                 void *opaque)
4971 {
4972     int err;
4973
4974     if (!bdrv_key_required(bs)) {
4975         if (completion_cb)
4976             completion_cb(opaque, 0);
4977         return 0;
4978     }
4979
4980     if (monitor_ctrl_mode(mon)) {
4981         qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
4982                       bdrv_get_encrypted_filename(bs));
4983         return -1;
4984     }
4985
4986     monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4987                    bdrv_get_encrypted_filename(bs));
4988
4989     mon->password_completion_cb = completion_cb;
4990     mon->password_opaque = opaque;
4991
4992     err = monitor_read_password(mon, bdrv_password_cb, bs);
4993
4994     if (err && completion_cb)
4995         completion_cb(opaque, err);
4996
4997     return err;
4998 }
4999
5000 int monitor_read_block_device_key(Monitor *mon, const char *device,
5001                                   BlockDriverCompletionFunc *completion_cb,
5002                                   void *opaque)
5003 {
5004     BlockDriverState *bs;
5005
5006     bs = bdrv_find(device);
5007     if (!bs) {
5008         monitor_printf(mon, "Device not found %s\n", device);
5009         return -1;
5010     }
5011
5012     return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
5013 }
5014
5015 QemuOptsList qemu_mon_opts = {
5016     .name = "mon",
5017     .implied_opt_name = "chardev",
5018     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
5019     .desc = {
5020         {
5021             .name = "mode",
5022             .type = QEMU_OPT_STRING,
5023         },{
5024             .name = "chardev",
5025             .type = QEMU_OPT_STRING,
5026         },{
5027             .name = "default",
5028             .type = QEMU_OPT_BOOL,
5029         },{
5030             .name = "pretty",
5031             .type = QEMU_OPT_BOOL,
5032         },
5033         { /* end of list */ }
5034     },
5035 };