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