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