monitor.c

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