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