monitor.c

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