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