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