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