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