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         fwrite(buf, 1, l, f);
1328         addr += l;
1329         size -= l;
1330     }
1331     fclose(f);
1332 }
1333
1334 static void do_physical_memory_save(Monitor *mon, const QDict *qdict,
1335                                     QObject **ret_data)
1336 {
1337     FILE *f;
1338     uint32_t l;
1339     uint8_t buf[1024];
1340     uint32_t size = qdict_get_int(qdict, "size");
1341     const char *filename = qdict_get_str(qdict, "filename");
1342     target_phys_addr_t addr = qdict_get_int(qdict, "val");
1343
1344     f = fopen(filename, "wb");
1345     if (!f) {
1346         qemu_error_new(QERR_OPEN_FILE_FAILED, filename);
1347         return;
1348     }
1349     while (size != 0) {
1350         l = sizeof(buf);
1351         if (l > size)
1352             l = size;
1353         cpu_physical_memory_rw(addr, buf, l, 0);
1354         fwrite(buf, 1, l, f);
1355         fflush(f);
1356         addr += l;
1357         size -= l;
1358     }
1359     fclose(f);
1360 }
1361
1362 static void do_sum(Monitor *mon, const QDict *qdict)
1363 {
1364     uint32_t addr;
1365     uint8_t buf[1];
1366     uint16_t sum;
1367     uint32_t start = qdict_get_int(qdict, "start");
1368     uint32_t size = qdict_get_int(qdict, "size");
1369
1370     sum = 0;
1371     for(addr = start; addr < (start + size); addr++) {
1372         cpu_physical_memory_rw(addr, buf, 1, 0);
1373         /* BSD sum algorithm ('sum' Unix command) */
1374         sum = (sum >> 1) | (sum << 15);
1375         sum += buf[0];
1376     }
1377     monitor_printf(mon, "%05d\n", sum);
1378 }
1379
1380 typedef struct {
1381     int keycode;
1382     const char *name;
1383 } KeyDef;
1384
1385 static const KeyDef key_defs[] = {
1386     { 0x2a, "shift" },
1387     { 0x36, "shift_r" },
1388
1389     { 0x38, "alt" },
1390     { 0xb8, "alt_r" },
1391     { 0x64, "altgr" },
1392     { 0xe4, "altgr_r" },
1393     { 0x1d, "ctrl" },
1394     { 0x9d, "ctrl_r" },
1395
1396     { 0xdd, "menu" },
1397
1398     { 0x01, "esc" },
1399
1400     { 0x02, "1" },
1401     { 0x03, "2" },
1402     { 0x04, "3" },
1403     { 0x05, "4" },
1404     { 0x06, "5" },
1405     { 0x07, "6" },
1406     { 0x08, "7" },
1407     { 0x09, "8" },
1408     { 0x0a, "9" },
1409     { 0x0b, "0" },
1410     { 0x0c, "minus" },
1411     { 0x0d, "equal" },
1412     { 0x0e, "backspace" },
1413
1414     { 0x0f, "tab" },
1415     { 0x10, "q" },
1416     { 0x11, "w" },
1417     { 0x12, "e" },
1418     { 0x13, "r" },
1419     { 0x14, "t" },
1420     { 0x15, "y" },
1421     { 0x16, "u" },
1422     { 0x17, "i" },
1423     { 0x18, "o" },
1424     { 0x19, "p" },
1425
1426     { 0x1c, "ret" },
1427
1428     { 0x1e, "a" },
1429     { 0x1f, "s" },
1430     { 0x20, "d" },
1431     { 0x21, "f" },
1432     { 0x22, "g" },
1433     { 0x23, "h" },
1434     { 0x24, "j" },
1435     { 0x25, "k" },
1436     { 0x26, "l" },
1437
1438     { 0x2c, "z" },
1439     { 0x2d, "x" },
1440     { 0x2e, "c" },
1441     { 0x2f, "v" },
1442     { 0x30, "b" },
1443     { 0x31, "n" },
1444     { 0x32, "m" },
1445     { 0x33, "comma" },
1446     { 0x34, "dot" },
1447     { 0x35, "slash" },
1448
1449     { 0x37, "asterisk" },
1450
1451     { 0x39, "spc" },
1452     { 0x3a, "caps_lock" },
1453     { 0x3b, "f1" },
1454     { 0x3c, "f2" },
1455     { 0x3d, "f3" },
1456     { 0x3e, "f4" },
1457     { 0x3f, "f5" },
1458     { 0x40, "f6" },
1459     { 0x41, "f7" },
1460     { 0x42, "f8" },
1461     { 0x43, "f9" },
1462     { 0x44, "f10" },
1463     { 0x45, "num_lock" },
1464     { 0x46, "scroll_lock" },
1465
1466     { 0xb5, "kp_divide" },
1467     { 0x37, "kp_multiply" },
1468     { 0x4a, "kp_subtract" },
1469     { 0x4e, "kp_add" },
1470     { 0x9c, "kp_enter" },
1471     { 0x53, "kp_decimal" },
1472     { 0x54, "sysrq" },
1473
1474     { 0x52, "kp_0" },
1475     { 0x4f, "kp_1" },
1476     { 0x50, "kp_2" },
1477     { 0x51, "kp_3" },
1478     { 0x4b, "kp_4" },
1479     { 0x4c, "kp_5" },
1480     { 0x4d, "kp_6" },
1481     { 0x47, "kp_7" },
1482     { 0x48, "kp_8" },
1483     { 0x49, "kp_9" },
1484
1485     { 0x56, "<" },
1486
1487     { 0x57, "f11" },
1488     { 0x58, "f12" },
1489
1490     { 0xb7, "print" },
1491
1492     { 0xc7, "home" },
1493     { 0xc9, "pgup" },
1494     { 0xd1, "pgdn" },
1495     { 0xcf, "end" },
1496
1497     { 0xcb, "left" },
1498     { 0xc8, "up" },
1499     { 0xd0, "down" },
1500     { 0xcd, "right" },
1501
1502     { 0xd2, "insert" },
1503     { 0xd3, "delete" },
1504 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1505     { 0xf0, "stop" },
1506     { 0xf1, "again" },
1507     { 0xf2, "props" },
1508     { 0xf3, "undo" },
1509     { 0xf4, "front" },
1510     { 0xf5, "copy" },
1511     { 0xf6, "open" },
1512     { 0xf7, "paste" },
1513     { 0xf8, "find" },
1514     { 0xf9, "cut" },
1515     { 0xfa, "lf" },
1516     { 0xfb, "help" },
1517     { 0xfc, "meta_l" },
1518     { 0xfd, "meta_r" },
1519     { 0xfe, "compose" },
1520 #endif
1521     { 0, NULL },
1522 };
1523
1524 static int get_keycode(const char *key)
1525 {
1526     const KeyDef *p;
1527     char *endp;
1528     int ret;
1529
1530     for(p = key_defs; p->name != NULL; p++) {
1531         if (!strcmp(key, p->name))
1532             return p->keycode;
1533     }
1534     if (strstart(key, "0x", NULL)) {
1535         ret = strtoul(key, &endp, 0);
1536         if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1537             return ret;
1538     }
1539     return -1;
1540 }
1541
1542 #define MAX_KEYCODES 16
1543 static uint8_t keycodes[MAX_KEYCODES];
1544 static int nb_pending_keycodes;
1545 static QEMUTimer *key_timer;
1546
1547 static void release_keys(void *opaque)
1548 {
1549     int keycode;
1550
1551     while (nb_pending_keycodes > 0) {
1552         nb_pending_keycodes--;
1553         keycode = keycodes[nb_pending_keycodes];
1554         if (keycode & 0x80)
1555             kbd_put_keycode(0xe0);
1556         kbd_put_keycode(keycode | 0x80);
1557     }
1558 }
1559
1560 static void do_sendkey(Monitor *mon, const QDict *qdict)
1561 {
1562     char keyname_buf[16];
1563     char *separator;
1564     int keyname_len, keycode, i;
1565     const char *string = qdict_get_str(qdict, "string");
1566     int has_hold_time = qdict_haskey(qdict, "hold_time");
1567     int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1568
1569     if (nb_pending_keycodes > 0) {
1570         qemu_del_timer(key_timer);
1571         release_keys(NULL);
1572     }
1573     if (!has_hold_time)
1574         hold_time = 100;
1575     i = 0;
1576     while (1) {
1577         separator = strchr(string, '-');
1578         keyname_len = separator ? separator - string : strlen(string);
1579         if (keyname_len > 0) {
1580             pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1581             if (keyname_len > sizeof(keyname_buf) - 1) {
1582                 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1583                 return;
1584             }
1585             if (i == MAX_KEYCODES) {
1586                 monitor_printf(mon, "too many keys\n");
1587                 return;
1588             }
1589             keyname_buf[keyname_len] = 0;
1590             keycode = get_keycode(keyname_buf);
1591             if (keycode < 0) {
1592                 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1593                 return;
1594             }
1595             keycodes[i++] = keycode;
1596         }
1597         if (!separator)
1598             break;
1599         string = separator + 1;
1600     }
1601     nb_pending_keycodes = i;
1602     /* key down events */
1603     for (i = 0; i < nb_pending_keycodes; i++) {
1604         keycode = keycodes[i];
1605         if (keycode & 0x80)
1606             kbd_put_keycode(0xe0);
1607         kbd_put_keycode(keycode & 0x7f);
1608     }
1609     /* delayed key up events */
1610     qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1611                    muldiv64(get_ticks_per_sec(), hold_time, 1000));
1612 }
1613
1614 static int mouse_button_state;
1615
1616 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1617 {
1618     int dx, dy, dz;
1619     const char *dx_str = qdict_get_str(qdict, "dx_str");
1620     const char *dy_str = qdict_get_str(qdict, "dy_str");
1621     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1622     dx = strtol(dx_str, NULL, 0);
1623     dy = strtol(dy_str, NULL, 0);
1624     dz = 0;
1625     if (dz_str)
1626         dz = strtol(dz_str, NULL, 0);
1627     kbd_mouse_event(dx, dy, dz, mouse_button_state);
1628 }
1629
1630 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1631 {
1632     int button_state = qdict_get_int(qdict, "button_state");
1633     mouse_button_state = button_state;
1634     kbd_mouse_event(0, 0, 0, mouse_button_state);
1635 }
1636
1637 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1638 {
1639     int size = qdict_get_int(qdict, "size");
1640     int addr = qdict_get_int(qdict, "addr");
1641     int has_index = qdict_haskey(qdict, "index");
1642     uint32_t val;
1643     int suffix;
1644
1645     if (has_index) {
1646         int index = qdict_get_int(qdict, "index");
1647         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1648         addr++;
1649     }
1650     addr &= 0xffff;
1651
1652     switch(size) {
1653     default:
1654     case 1:
1655         val = cpu_inb(addr);
1656         suffix = 'b';
1657         break;
1658     case 2:
1659         val = cpu_inw(addr);
1660         suffix = 'w';
1661         break;
1662     case 4:
1663         val = cpu_inl(addr);
1664         suffix = 'l';
1665         break;
1666     }
1667     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1668                    suffix, addr, size * 2, val);
1669 }
1670
1671 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1672 {
1673     int size = qdict_get_int(qdict, "size");
1674     int addr = qdict_get_int(qdict, "addr");
1675     int val = qdict_get_int(qdict, "val");
1676
1677     addr &= IOPORTS_MASK;
1678
1679     switch (size) {
1680     default:
1681     case 1:
1682         cpu_outb(addr, val);
1683         break;
1684     case 2:
1685         cpu_outw(addr, val);
1686         break;
1687     case 4:
1688         cpu_outl(addr, val);
1689         break;
1690     }
1691 }
1692
1693 static void do_boot_set(Monitor *mon, const QDict *qdict)
1694 {
1695     int res;
1696     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1697
1698     res = qemu_boot_set(bootdevice);
1699     if (res == 0) {
1700         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1701     } else if (res > 0) {
1702         monitor_printf(mon, "setting boot device list failed\n");
1703     } else {
1704         monitor_printf(mon, "no function defined to set boot device list for "
1705                        "this architecture\n");
1706     }
1707 }
1708
1709 /**
1710  * do_system_reset(): Issue a machine reset
1711  */
1712 static void do_system_reset(Monitor *mon, const QDict *qdict,
1713                             QObject **ret_data)
1714 {
1715     qemu_system_reset_request();
1716 }
1717
1718 /**
1719  * do_system_powerdown(): Issue a machine powerdown
1720  */
1721 static void do_system_powerdown(Monitor *mon, const QDict *qdict,
1722                                 QObject **ret_data)
1723 {
1724     qemu_system_powerdown_request();
1725 }
1726
1727 #if defined(TARGET_I386)
1728 static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1729 {
1730     monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1731                    addr,
1732                    pte & mask,
1733                    pte & PG_GLOBAL_MASK ? 'G' : '-',
1734                    pte & PG_PSE_MASK ? 'P' : '-',
1735                    pte & PG_DIRTY_MASK ? 'D' : '-',
1736                    pte & PG_ACCESSED_MASK ? 'A' : '-',
1737                    pte & PG_PCD_MASK ? 'C' : '-',
1738                    pte & PG_PWT_MASK ? 'T' : '-',
1739                    pte & PG_USER_MASK ? 'U' : '-',
1740                    pte & PG_RW_MASK ? 'W' : '-');
1741 }
1742
1743 static void tlb_info(Monitor *mon)
1744 {
1745     CPUState *env;
1746     int l1, l2;
1747     uint32_t pgd, pde, pte;
1748
1749     env = mon_get_cpu();
1750
1751     if (!(env->cr[0] & CR0_PG_MASK)) {
1752         monitor_printf(mon, "PG disabled\n");
1753         return;
1754     }
1755     pgd = env->cr[3] & ~0xfff;
1756     for(l1 = 0; l1 < 1024; l1++) {
1757         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1758         pde = le32_to_cpu(pde);
1759         if (pde & PG_PRESENT_MASK) {
1760             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1761                 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1762             } else {
1763                 for(l2 = 0; l2 < 1024; l2++) {
1764                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1765                                              (uint8_t *)&pte, 4);
1766                     pte = le32_to_cpu(pte);
1767                     if (pte & PG_PRESENT_MASK) {
1768                         print_pte(mon, (l1 << 22) + (l2 << 12),
1769                                   pte & ~PG_PSE_MASK,
1770                                   ~0xfff);
1771                     }
1772                 }
1773             }
1774         }
1775     }
1776 }
1777
1778 static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1779                       uint32_t end, int prot)
1780 {
1781     int prot1;
1782     prot1 = *plast_prot;
1783     if (prot != prot1) {
1784         if (*pstart != -1) {
1785             monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1786                            *pstart, end, end - *pstart,
1787                            prot1 & PG_USER_MASK ? 'u' : '-',
1788                            'r',
1789                            prot1 & PG_RW_MASK ? 'w' : '-');
1790         }
1791         if (prot != 0)
1792             *pstart = end;
1793         else
1794             *pstart = -1;
1795         *plast_prot = prot;
1796     }
1797 }
1798
1799 static void mem_info(Monitor *mon)
1800 {
1801     CPUState *env;
1802     int l1, l2, prot, last_prot;
1803     uint32_t pgd, pde, pte, start, end;
1804
1805     env = mon_get_cpu();
1806
1807     if (!(env->cr[0] & CR0_PG_MASK)) {
1808         monitor_printf(mon, "PG disabled\n");
1809         return;
1810     }
1811     pgd = env->cr[3] & ~0xfff;
1812     last_prot = 0;
1813     start = -1;
1814     for(l1 = 0; l1 < 1024; l1++) {
1815         cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1816         pde = le32_to_cpu(pde);
1817         end = l1 << 22;
1818         if (pde & PG_PRESENT_MASK) {
1819             if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1820                 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1821                 mem_print(mon, &start, &last_prot, end, prot);
1822             } else {
1823                 for(l2 = 0; l2 < 1024; l2++) {
1824                     cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1825                                              (uint8_t *)&pte, 4);
1826                     pte = le32_to_cpu(pte);
1827                     end = (l1 << 22) + (l2 << 12);
1828                     if (pte & PG_PRESENT_MASK) {
1829                         prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1830                     } else {
1831                         prot = 0;
1832                     }
1833                     mem_print(mon, &start, &last_prot, end, prot);
1834                 }
1835             }
1836         } else {
1837             prot = 0;
1838             mem_print(mon, &start, &last_prot, end, prot);
1839         }
1840     }
1841 }
1842 #endif
1843
1844 #if defined(TARGET_SH4)
1845
1846 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
1847 {
1848     monitor_printf(mon, " tlb%i:\t"
1849                    "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1850                    "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1851                    "dirty=%hhu writethrough=%hhu\n",
1852                    idx,
1853                    tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1854                    tlb->v, tlb->sh, tlb->c, tlb->pr,
1855                    tlb->d, tlb->wt);
1856 }
1857
1858 static void tlb_info(Monitor *mon)
1859 {
1860     CPUState *env = mon_get_cpu();
1861     int i;
1862
1863     monitor_printf (mon, "ITLB:\n");
1864     for (i = 0 ; i < ITLB_SIZE ; i++)
1865         print_tlb (mon, i, &env->itlb[i]);
1866     monitor_printf (mon, "UTLB:\n");
1867     for (i = 0 ; i < UTLB_SIZE ; i++)
1868         print_tlb (mon, i, &env->utlb[i]);
1869 }
1870
1871 #endif
1872
1873 static void do_info_kvm_print(Monitor *mon, const QObject *data)
1874 {
1875     QDict *qdict;
1876
1877     qdict = qobject_to_qdict(data);
1878
1879     monitor_printf(mon, "kvm support: ");
1880     if (qdict_get_bool(qdict, "present")) {
1881         monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
1882                                     "enabled" : "disabled");
1883     } else {
1884         monitor_printf(mon, "not compiled\n");
1885     }
1886 }
1887
1888 /**
1889  * do_info_kvm(): Show KVM information
1890  *
1891  * Return a QDict with the following information:
1892  *
1893  * - "enabled": true if KVM support is enabled, false otherwise
1894  * - "present": true if QEMU has KVM support, false otherwise
1895  *
1896  * Example:
1897  *
1898  * { "enabled": true, "present": true }
1899  */
1900 static void do_info_kvm(Monitor *mon, QObject **ret_data)
1901 {
1902 #ifdef CONFIG_KVM
1903     *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
1904                                    kvm_enabled());
1905 #else
1906     *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
1907 #endif
1908 }
1909
1910 static void do_info_numa(Monitor *mon)
1911 {
1912     int i;
1913     CPUState *env;
1914
1915     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1916     for (i = 0; i < nb_numa_nodes; i++) {
1917         monitor_printf(mon, "node %d cpus:", i);
1918         for (env = first_cpu; env != NULL; env = env->next_cpu) {
1919             if (env->numa_node == i) {
1920                 monitor_printf(mon, " %d", env->cpu_index);
1921             }
1922         }
1923         monitor_printf(mon, "\n");
1924         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1925             node_mem[i] >> 20);
1926     }
1927 }
1928
1929 #ifdef CONFIG_PROFILER
1930
1931 int64_t qemu_time;
1932 int64_t dev_time;
1933
1934 static void do_info_profile(Monitor *mon)
1935 {
1936     int64_t total;
1937     total = qemu_time;
1938     if (total == 0)
1939         total = 1;
1940     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
1941                    dev_time, dev_time / (double)get_ticks_per_sec());
1942     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
1943                    qemu_time, qemu_time / (double)get_ticks_per_sec());
1944     qemu_time = 0;
1945     dev_time = 0;
1946 }
1947 #else
1948 static void do_info_profile(Monitor *mon)
1949 {
1950     monitor_printf(mon, "Internal profiler not compiled\n");
1951 }
1952 #endif
1953
1954 /* Capture support */
1955 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1956
1957 static void do_info_capture(Monitor *mon)
1958 {
1959     int i;
1960     CaptureState *s;
1961
1962     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1963         monitor_printf(mon, "[%d]: ", i);
1964         s->ops.info (s->opaque);
1965     }
1966 }
1967
1968 #ifdef HAS_AUDIO
1969 static void do_stop_capture(Monitor *mon, const QDict *qdict)
1970 {
1971     int i;
1972     int n = qdict_get_int(qdict, "n");
1973     CaptureState *s;
1974
1975     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1976         if (i == n) {
1977             s->ops.destroy (s->opaque);
1978             QLIST_REMOVE (s, entries);
1979             qemu_free (s);
1980             return;
1981         }
1982     }
1983 }
1984
1985 static void do_wav_capture(Monitor *mon, const QDict *qdict)
1986 {
1987     const char *path = qdict_get_str(qdict, "path");
1988     int has_freq = qdict_haskey(qdict, "freq");
1989     int freq = qdict_get_try_int(qdict, "freq", -1);
1990     int has_bits = qdict_haskey(qdict, "bits");
1991     int bits = qdict_get_try_int(qdict, "bits", -1);
1992     int has_channels = qdict_haskey(qdict, "nchannels");
1993     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
1994     CaptureState *s;
1995
1996     s = qemu_mallocz (sizeof (*s));
1997
1998     freq = has_freq ? freq : 44100;
1999     bits = has_bits ? bits : 16;
2000     nchannels = has_channels ? nchannels : 2;
2001
2002     if (wav_start_capture (s, path, freq, bits, nchannels)) {
2003         monitor_printf(mon, "Faied to add wave capture\n");
2004         qemu_free (s);
2005     }
2006     QLIST_INSERT_HEAD (&capture_head, s, entries);
2007 }
2008 #endif
2009
2010 #if defined(TARGET_I386)
2011 static void do_inject_nmi(Monitor *mon, const QDict *qdict)
2012 {
2013     CPUState *env;
2014     int cpu_index = qdict_get_int(qdict, "cpu_index");
2015
2016     for (env = first_cpu; env != NULL; env = env->next_cpu)
2017         if (env->cpu_index == cpu_index) {
2018             cpu_interrupt(env, CPU_INTERRUPT_NMI);
2019             break;
2020         }
2021 }
2022 #endif
2023
2024 static void do_info_status_print(Monitor *mon, const QObject *data)
2025 {
2026     QDict *qdict;
2027
2028     qdict = qobject_to_qdict(data);
2029
2030     monitor_printf(mon, "VM status: ");
2031     if (qdict_get_bool(qdict, "running")) {
2032         monitor_printf(mon, "running");
2033         if (qdict_get_bool(qdict, "singlestep")) {
2034             monitor_printf(mon, " (single step mode)");
2035         }
2036     } else {
2037         monitor_printf(mon, "paused");
2038     }
2039
2040     monitor_printf(mon, "\n");
2041 }
2042
2043 /**
2044  * do_info_status(): VM status
2045  *
2046  * Return a QDict with the following information:
2047  *
2048  * - "running": true if the VM is running, or false if it is paused
2049  * - "singlestep": true if the VM is in single step mode, false otherwise
2050  *
2051  * Example:
2052  *
2053  * { "running": true, "singlestep": false }
2054  */
2055 static void do_info_status(Monitor *mon, QObject **ret_data)
2056 {
2057     *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2058                                     vm_running, singlestep);
2059 }
2060
2061 static ram_addr_t balloon_get_value(void)
2062 {
2063     ram_addr_t actual;
2064
2065     if (kvm_enabled() && !kvm_has_sync_mmu()) {
2066         qemu_error_new(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
2067         return 0;
2068     }
2069
2070     actual = qemu_balloon_status();
2071     if (actual == 0) {
2072         qemu_error_new(QERR_DEVICE_NOT_ACTIVE, "balloon");
2073         return 0;
2074     }
2075
2076     return actual;
2077 }
2078
2079 /**
2080  * do_balloon(): Request VM to change its memory allocation
2081  */
2082 static void do_balloon(Monitor *mon, const QDict *qdict, QObject **ret_data)
2083 {
2084     if (balloon_get_value()) {
2085         /* ballooning is active */
2086         qemu_balloon(qdict_get_int(qdict, "value"));
2087     }
2088 }
2089
2090 static void monitor_print_balloon(Monitor *mon, const QObject *data)
2091 {
2092     QDict *qdict;
2093
2094     qdict = qobject_to_qdict(data);
2095
2096     monitor_printf(mon, "balloon: actual=%" PRId64 "\n",
2097                         qdict_get_int(qdict, "balloon") >> 20);
2098 }
2099
2100 /**
2101  * do_info_balloon(): Balloon information
2102  *
2103  * Return a QDict with the following information:
2104  *
2105  * - "balloon": current balloon value in bytes
2106  *
2107  * Example:
2108  *
2109  * { "balloon": 1073741824 }
2110  */
2111 static void do_info_balloon(Monitor *mon, QObject **ret_data)
2112 {
2113     ram_addr_t actual;
2114
2115     actual = balloon_get_value();
2116     if (actual != 0) {
2117         *ret_data = qobject_from_jsonf("{ 'balloon': %" PRId64 "}",
2118                                        (int64_t) actual);
2119     }
2120 }
2121
2122 static qemu_acl *find_acl(Monitor *mon, const char *name)
2123 {
2124     qemu_acl *acl = qemu_acl_find(name);
2125
2126     if (!acl) {
2127         monitor_printf(mon, "acl: unknown list '%s'\n", name);
2128     }
2129     return acl;
2130 }
2131
2132 static void do_acl_show(Monitor *mon, const QDict *qdict)
2133 {
2134     const char *aclname = qdict_get_str(qdict, "aclname");
2135     qemu_acl *acl = find_acl(mon, aclname);
2136     qemu_acl_entry *entry;
2137     int i = 0;
2138
2139     if (acl) {
2140         monitor_printf(mon, "policy: %s\n",
2141                        acl->defaultDeny ? "deny" : "allow");
2142         QTAILQ_FOREACH(entry, &acl->entries, next) {
2143             i++;
2144             monitor_printf(mon, "%d: %s %s\n", i,
2145                            entry->deny ? "deny" : "allow", entry->match);
2146         }
2147     }
2148 }
2149
2150 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2151 {
2152     const char *aclname = qdict_get_str(qdict, "aclname");
2153     qemu_acl *acl = find_acl(mon, aclname);
2154
2155     if (acl) {
2156         qemu_acl_reset(acl);
2157         monitor_printf(mon, "acl: removed all rules\n");
2158     }
2159 }
2160
2161 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2162 {
2163     const char *aclname = qdict_get_str(qdict, "aclname");
2164     const char *policy = qdict_get_str(qdict, "policy");
2165     qemu_acl *acl = find_acl(mon, aclname);
2166
2167     if (acl) {
2168         if (strcmp(policy, "allow") == 0) {
2169             acl->defaultDeny = 0;
2170             monitor_printf(mon, "acl: policy set to 'allow'\n");
2171         } else if (strcmp(policy, "deny") == 0) {
2172             acl->defaultDeny = 1;
2173             monitor_printf(mon, "acl: policy set to 'deny'\n");
2174         } else {
2175             monitor_printf(mon, "acl: unknown policy '%s', "
2176                            "expected 'deny' or 'allow'\n", policy);
2177         }
2178     }
2179 }
2180
2181 static void do_acl_add(Monitor *mon, const QDict *qdict)
2182 {
2183     const char *aclname = qdict_get_str(qdict, "aclname");
2184     const char *match = qdict_get_str(qdict, "match");
2185     const char *policy = qdict_get_str(qdict, "policy");
2186     int has_index = qdict_haskey(qdict, "index");
2187     int index = qdict_get_try_int(qdict, "index", -1);
2188     qemu_acl *acl = find_acl(mon, aclname);
2189     int deny, ret;
2190
2191     if (acl) {
2192         if (strcmp(policy, "allow") == 0) {
2193             deny = 0;
2194         } else if (strcmp(policy, "deny") == 0) {
2195             deny = 1;
2196         } else {
2197             monitor_printf(mon, "acl: unknown policy '%s', "
2198                            "expected 'deny' or 'allow'\n", policy);
2199             return;
2200         }
2201         if (has_index)
2202             ret = qemu_acl_insert(acl, deny, match, index);
2203         else
2204             ret = qemu_acl_append(acl, deny, match);
2205         if (ret < 0)
2206             monitor_printf(mon, "acl: unable to add acl entry\n");
2207         else
2208             monitor_printf(mon, "acl: added rule at position %d\n", ret);
2209     }
2210 }
2211
2212 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2213 {
2214     const char *aclname = qdict_get_str(qdict, "aclname");
2215     const char *match = qdict_get_str(qdict, "match");
2216     qemu_acl *acl = find_acl(mon, aclname);
2217     int ret;
2218
2219     if (acl) {
2220         ret = qemu_acl_remove(acl, match);
2221         if (ret < 0)
2222             monitor_printf(mon, "acl: no matching acl entry\n");
2223         else
2224             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2225     }
2226 }
2227
2228 #if defined(TARGET_I386)
2229 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2230 {
2231     CPUState *cenv;
2232     int cpu_index = qdict_get_int(qdict, "cpu_index");
2233     int bank = qdict_get_int(qdict, "bank");
2234     uint64_t status = qdict_get_int(qdict, "status");
2235     uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2236     uint64_t addr = qdict_get_int(qdict, "addr");
2237     uint64_t misc = qdict_get_int(qdict, "misc");
2238
2239     for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2240         if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2241             cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2242             break;
2243         }
2244 }
2245 #endif
2246
2247 static void do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2248 {
2249     const char *fdname = qdict_get_str(qdict, "fdname");
2250     mon_fd_t *monfd;
2251     int fd;
2252
2253     fd = qemu_chr_get_msgfd(mon->chr);
2254     if (fd == -1) {
2255         qemu_error_new(QERR_FD_NOT_SUPPLIED);
2256         return;
2257     }
2258
2259     if (qemu_isdigit(fdname[0])) {
2260         qemu_error_new(QERR_INVALID_PARAMETER, "fdname");
2261         return;
2262     }
2263
2264     fd = dup(fd);
2265     if (fd == -1) {
2266         if (errno == EMFILE)
2267             qemu_error_new(QERR_TOO_MANY_FILES);
2268         else
2269             qemu_error_new(QERR_UNDEFINED_ERROR);
2270         return;
2271     }
2272
2273     QLIST_FOREACH(monfd, &mon->fds, next) {
2274         if (strcmp(monfd->name, fdname) != 0) {
2275             continue;
2276         }
2277
2278         close(monfd->fd);
2279         monfd->fd = fd;
2280         return;
2281     }
2282
2283     monfd = qemu_mallocz(sizeof(mon_fd_t));
2284     monfd->name = qemu_strdup(fdname);
2285     monfd->fd = fd;
2286
2287     QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2288 }
2289
2290 static void do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2291 {
2292     const char *fdname = qdict_get_str(qdict, "fdname");
2293     mon_fd_t *monfd;
2294
2295     QLIST_FOREACH(monfd, &mon->fds, next) {
2296         if (strcmp(monfd->name, fdname) != 0) {
2297             continue;
2298         }
2299
2300         QLIST_REMOVE(monfd, next);
2301         close(monfd->fd);
2302         qemu_free(monfd->name);
2303         qemu_free(monfd);
2304         return;
2305     }
2306
2307     qemu_error_new(QERR_FD_NOT_FOUND, fdname);
2308 }
2309
2310 static void do_loadvm(Monitor *mon, const QDict *qdict)
2311 {
2312     int saved_vm_running  = vm_running;
2313     const char *name = qdict_get_str(qdict, "name");
2314
2315     vm_stop(0);
2316
2317     if (load_vmstate(mon, name) >= 0 && saved_vm_running)
2318         vm_start();
2319 }
2320
2321 int monitor_get_fd(Monitor *mon, const char *fdname)
2322 {
2323     mon_fd_t *monfd;
2324
2325     QLIST_FOREACH(monfd, &mon->fds, next) {
2326         int fd;
2327
2328         if (strcmp(monfd->name, fdname) != 0) {
2329             continue;
2330         }
2331
2332         fd = monfd->fd;
2333
2334         /* caller takes ownership of fd */
2335         QLIST_REMOVE(monfd, next);
2336         qemu_free(monfd->name);
2337         qemu_free(monfd);
2338
2339         return fd;
2340     }
2341
2342     return -1;
2343 }
2344
2345 static const mon_cmd_t mon_cmds[] = {
2346 #include "qemu-monitor.h"
2347     { NULL, NULL, },
2348 };
2349
2350 /* Please update qemu-monitor.hx when adding or changing commands */
2351 static const mon_cmd_t info_cmds[] = {
2352     {
2353         .name       = "version",
2354         .args_type  = "",
2355         .params     = "",
2356         .help       = "show the version of QEMU",
2357         .user_print = do_info_version_print,
2358         .mhandler.info_new = do_info_version,
2359     },
2360     {
2361         .name       = "commands",
2362         .args_type  = "",
2363         .params     = "",
2364         .help       = "list QMP available commands",
2365         .user_print = monitor_user_noop,
2366         .mhandler.info_new = do_info_commands,
2367     },
2368     {
2369         .name       = "network",
2370         .args_type  = "",
2371         .params     = "",
2372         .help       = "show the network state",
2373         .mhandler.info = do_info_network,
2374     },
2375     {
2376         .name       = "chardev",
2377         .args_type  = "",
2378         .params     = "",
2379         .help       = "show the character devices",
2380         .user_print = qemu_chr_info_print,
2381         .mhandler.info_new = qemu_chr_info,
2382     },
2383     {
2384         .name       = "block",
2385         .args_type  = "",
2386         .params     = "",
2387         .help       = "show the block devices",
2388         .user_print = bdrv_info_print,
2389         .mhandler.info_new = bdrv_info,
2390     },
2391     {
2392         .name       = "blockstats",
2393         .args_type  = "",
2394         .params     = "",
2395         .help       = "show block device statistics",
2396         .user_print = bdrv_stats_print,
2397         .mhandler.info_new = bdrv_info_stats,
2398     },
2399     {
2400         .name       = "registers",
2401         .args_type  = "",
2402         .params     = "",
2403         .help       = "show the cpu registers",
2404         .mhandler.info = do_info_registers,
2405     },
2406     {
2407         .name       = "cpus",
2408         .args_type  = "",
2409         .params     = "",
2410         .help       = "show infos for each CPU",
2411         .user_print = monitor_print_cpus,
2412         .mhandler.info_new = do_info_cpus,
2413     },
2414     {
2415         .name       = "history",
2416         .args_type  = "",
2417         .params     = "",
2418         .help       = "show the command line history",
2419         .mhandler.info = do_info_history,
2420     },
2421     {
2422         .name       = "irq",
2423         .args_type  = "",
2424         .params     = "",
2425         .help       = "show the interrupts statistics (if available)",
2426         .mhandler.info = irq_info,
2427     },
2428     {
2429         .name       = "pic",
2430         .args_type  = "",
2431         .params     = "",
2432         .help       = "show i8259 (PIC) state",
2433         .mhandler.info = pic_info,
2434     },
2435     {
2436         .name       = "pci",
2437         .args_type  = "",
2438         .params     = "",
2439         .help       = "show PCI info",
2440         .mhandler.info = pci_info,
2441     },
2442 #if defined(TARGET_I386) || defined(TARGET_SH4)
2443     {
2444         .name       = "tlb",
2445         .args_type  = "",
2446         .params     = "",
2447         .help       = "show virtual to physical memory mappings",
2448         .mhandler.info = tlb_info,
2449     },
2450 #endif
2451 #if defined(TARGET_I386)
2452     {
2453         .name       = "mem",
2454         .args_type  = "",
2455         .params     = "",
2456         .help       = "show the active virtual memory mappings",
2457         .mhandler.info = mem_info,
2458     },
2459     {
2460         .name       = "hpet",
2461         .args_type  = "",
2462         .params     = "",
2463         .help       = "show state of HPET",
2464         .user_print = do_info_hpet_print,
2465         .mhandler.info_new = do_info_hpet,
2466     },
2467 #endif
2468     {
2469         .name       = "jit",
2470         .args_type  = "",
2471         .params     = "",
2472         .help       = "show dynamic compiler info",
2473         .mhandler.info = do_info_jit,
2474     },
2475     {
2476         .name       = "kvm",
2477         .args_type  = "",
2478         .params     = "",
2479         .help       = "show KVM information",
2480         .user_print = do_info_kvm_print,
2481         .mhandler.info_new = do_info_kvm,
2482     },
2483     {
2484         .name       = "numa",
2485         .args_type  = "",
2486         .params     = "",
2487         .help       = "show NUMA information",
2488         .mhandler.info = do_info_numa,
2489     },
2490     {
2491         .name       = "usb",
2492         .args_type  = "",
2493         .params     = "",
2494         .help       = "show guest USB devices",
2495         .mhandler.info = usb_info,
2496     },
2497     {
2498         .name       = "usbhost",
2499         .args_type  = "",
2500         .params     = "",
2501         .help       = "show host USB devices",
2502         .mhandler.info = usb_host_info,
2503     },
2504     {
2505         .name       = "profile",
2506         .args_type  = "",
2507         .params     = "",
2508         .help       = "show profiling information",
2509         .mhandler.info = do_info_profile,
2510     },
2511     {
2512         .name       = "capture",
2513         .args_type  = "",
2514         .params     = "",
2515         .help       = "show capture information",
2516         .mhandler.info = do_info_capture,
2517     },
2518     {
2519         .name       = "snapshots",
2520         .args_type  = "",
2521         .params     = "",
2522         .help       = "show the currently saved VM snapshots",
2523         .mhandler.info = do_info_snapshots,
2524     },
2525     {
2526         .name       = "status",
2527         .args_type  = "",
2528         .params     = "",
2529         .help       = "show the current VM status (running|paused)",
2530         .user_print = do_info_status_print,
2531         .mhandler.info_new = do_info_status,
2532     },
2533     {
2534         .name       = "pcmcia",
2535         .args_type  = "",
2536         .params     = "",
2537         .help       = "show guest PCMCIA status",
2538         .mhandler.info = pcmcia_info,
2539     },
2540     {
2541         .name       = "mice",
2542         .args_type  = "",
2543         .params     = "",
2544         .help       = "show which guest mouse is receiving events",
2545         .user_print = do_info_mice_print,
2546         .mhandler.info_new = do_info_mice,
2547     },
2548     {
2549         .name       = "vnc",
2550         .args_type  = "",
2551         .params     = "",
2552         .help       = "show the vnc server status",
2553         .user_print = do_info_vnc_print,
2554         .mhandler.info_new = do_info_vnc,
2555     },
2556     {
2557         .name       = "name",
2558         .args_type  = "",
2559         .params     = "",
2560         .help       = "show the current VM name",
2561         .user_print = do_info_name_print,
2562         .mhandler.info_new = do_info_name,
2563     },
2564     {
2565         .name       = "uuid",
2566         .args_type  = "",
2567         .params     = "",
2568         .help       = "show the current VM UUID",
2569         .user_print = do_info_uuid_print,
2570         .mhandler.info_new = do_info_uuid,
2571     },
2572 #if defined(TARGET_PPC)
2573     {
2574         .name       = "cpustats",
2575         .args_type  = "",
2576         .params     = "",
2577         .help       = "show CPU statistics",
2578         .mhandler.info = do_info_cpu_stats,
2579     },
2580 #endif
2581 #if defined(CONFIG_SLIRP)
2582     {
2583         .name       = "usernet",
2584         .args_type  = "",
2585         .params     = "",
2586         .help       = "show user network stack connection states",
2587         .mhandler.info = do_info_usernet,
2588     },
2589 #endif
2590     {
2591         .name       = "migrate",
2592         .args_type  = "",
2593         .params     = "",
2594         .help       = "show migration status",
2595         .user_print = do_info_migrate_print,
2596         .mhandler.info_new = do_info_migrate,
2597     },
2598     {
2599         .name       = "balloon",
2600         .args_type  = "",
2601         .params     = "",
2602         .help       = "show balloon information",
2603         .user_print = monitor_print_balloon,
2604         .mhandler.info_new = do_info_balloon,
2605     },
2606     {
2607         .name       = "qtree",
2608         .args_type  = "",
2609         .params     = "",
2610         .help       = "show device tree",
2611         .mhandler.info = do_info_qtree,
2612     },
2613     {
2614         .name       = "qdm",
2615         .args_type  = "",
2616         .params     = "",
2617         .help       = "show qdev device model list",
2618         .mhandler.info = do_info_qdm,
2619     },
2620     {
2621         .name       = "roms",
2622         .args_type  = "",
2623         .params     = "",
2624         .help       = "show roms",
2625         .mhandler.info = do_info_roms,
2626     },
2627     {
2628         .name       = NULL,
2629     },
2630 };
2631
2632 /*******************************************************************/
2633
2634 static const char *pch;
2635 static jmp_buf expr_env;
2636
2637 #define MD_TLONG 0
2638 #define MD_I32   1
2639
2640 typedef struct MonitorDef {
2641     const char *name;
2642     int offset;
2643     target_long (*get_value)(const struct MonitorDef *md, int val);
2644     int type;
2645 } MonitorDef;
2646
2647 #if defined(TARGET_I386)
2648 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2649 {
2650     CPUState *env = mon_get_cpu();
2651     return env->eip + env->segs[R_CS].base;
2652 }
2653 #endif
2654
2655 #if defined(TARGET_PPC)
2656 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2657 {
2658     CPUState *env = mon_get_cpu();
2659     unsigned int u;
2660     int i;
2661
2662     u = 0;
2663     for (i = 0; i < 8; i++)
2664         u |= env->crf[i] << (32 - (4 * i));
2665
2666     return u;
2667 }
2668
2669 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2670 {
2671     CPUState *env = mon_get_cpu();
2672     return env->msr;
2673 }
2674
2675 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2676 {
2677     CPUState *env = mon_get_cpu();
2678     return env->xer;
2679 }
2680
2681 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2682 {
2683     CPUState *env = mon_get_cpu();
2684     return cpu_ppc_load_decr(env);
2685 }
2686
2687 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2688 {
2689     CPUState *env = mon_get_cpu();
2690     return cpu_ppc_load_tbu(env);
2691 }
2692
2693 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2694 {
2695     CPUState *env = mon_get_cpu();
2696     return cpu_ppc_load_tbl(env);
2697 }
2698 #endif
2699
2700 #if defined(TARGET_SPARC)
2701 #ifndef TARGET_SPARC64
2702 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2703 {
2704     CPUState *env = mon_get_cpu();
2705     return GET_PSR(env);
2706 }
2707 #endif
2708
2709 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2710 {
2711     CPUState *env = mon_get_cpu();
2712     return env->regwptr[val];
2713 }
2714 #endif
2715
2716 static const MonitorDef monitor_defs[] = {
2717 #ifdef TARGET_I386
2718
2719 #define SEG(name, seg) \
2720     { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2721     { name ".base", offsetof(CPUState, segs[seg].base) },\
2722     { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2723
2724     { "eax", offsetof(CPUState, regs[0]) },
2725     { "ecx", offsetof(CPUState, regs[1]) },
2726     { "edx", offsetof(CPUState, regs[2]) },
2727     { "ebx", offsetof(CPUState, regs[3]) },
2728     { "esp|sp", offsetof(CPUState, regs[4]) },
2729     { "ebp|fp", offsetof(CPUState, regs[5]) },
2730     { "esi", offsetof(CPUState, regs[6]) },
2731     { "edi", offsetof(CPUState, regs[7]) },
2732 #ifdef TARGET_X86_64
2733     { "r8", offsetof(CPUState, regs[8]) },
2734     { "r9", offsetof(CPUState, regs[9]) },
2735     { "r10", offsetof(CPUState, regs[10]) },
2736     { "r11", offsetof(CPUState, regs[11]) },
2737     { "r12", offsetof(CPUState, regs[12]) },
2738     { "r13", offsetof(CPUState, regs[13]) },
2739     { "r14", offsetof(CPUState, regs[14]) },
2740     { "r15", offsetof(CPUState, regs[15]) },
2741 #endif
2742     { "eflags", offsetof(CPUState, eflags) },
2743     { "eip", offsetof(CPUState, eip) },
2744     SEG("cs", R_CS)
2745     SEG("ds", R_DS)
2746     SEG("es", R_ES)
2747     SEG("ss", R_SS)
2748     SEG("fs", R_FS)
2749     SEG("gs", R_GS)
2750     { "pc", 0, monitor_get_pc, },
2751 #elif defined(TARGET_PPC)
2752     /* General purpose registers */
2753     { "r0", offsetof(CPUState, gpr[0]) },
2754     { "r1", offsetof(CPUState, gpr[1]) },
2755     { "r2", offsetof(CPUState, gpr[2]) },
2756     { "r3", offsetof(CPUState, gpr[3]) },
2757     { "r4", offsetof(CPUState, gpr[4]) },
2758     { "r5", offsetof(CPUState, gpr[5]) },
2759     { "r6", offsetof(CPUState, gpr[6]) },
2760     { "r7", offsetof(CPUState, gpr[7]) },
2761     { "r8", offsetof(CPUState, gpr[8]) },
2762     { "r9", offsetof(CPUState, gpr[9]) },
2763     { "r10", offsetof(CPUState, gpr[10]) },
2764     { "r11", offsetof(CPUState, gpr[11]) },
2765     { "r12", offsetof(CPUState, gpr[12]) },
2766     { "r13", offsetof(CPUState, gpr[13]) },
2767     { "r14", offsetof(CPUState, gpr[14]) },
2768     { "r15", offsetof(CPUState, gpr[15]) },
2769     { "r16", offsetof(CPUState, gpr[16]) },
2770     { "r17", offsetof(CPUState, gpr[17]) },
2771     { "r18", offsetof(CPUState, gpr[18]) },
2772     { "r19", offsetof(CPUState, gpr[19]) },
2773     { "r20", offsetof(CPUState, gpr[20]) },
2774     { "r21", offsetof(CPUState, gpr[21]) },
2775     { "r22", offsetof(CPUState, gpr[22]) },
2776     { "r23", offsetof(CPUState, gpr[23]) },
2777     { "r24", offsetof(CPUState, gpr[24]) },
2778     { "r25", offsetof(CPUState, gpr[25]) },
2779     { "r26", offsetof(CPUState, gpr[26]) },
2780     { "r27", offsetof(CPUState, gpr[27]) },
2781     { "r28", offsetof(CPUState, gpr[28]) },
2782     { "r29", offsetof(CPUState, gpr[29]) },
2783     { "r30", offsetof(CPUState, gpr[30]) },
2784     { "r31", offsetof(CPUState, gpr[31]) },
2785     /* Floating point registers */
2786     { "f0", offsetof(CPUState, fpr[0]) },
2787     { "f1", offsetof(CPUState, fpr[1]) },
2788     { "f2", offsetof(CPUState, fpr[2]) },
2789     { "f3", offsetof(CPUState, fpr[3]) },
2790     { "f4", offsetof(CPUState, fpr[4]) },
2791     { "f5", offsetof(CPUState, fpr[5]) },
2792     { "f6", offsetof(CPUState, fpr[6]) },
2793     { "f7", offsetof(CPUState, fpr[7]) },
2794     { "f8", offsetof(CPUState, fpr[8]) },
2795     { "f9", offsetof(CPUState, fpr[9]) },
2796     { "f10", offsetof(CPUState, fpr[10]) },
2797     { "f11", offsetof(CPUState, fpr[11]) },
2798     { "f12", offsetof(CPUState, fpr[12]) },
2799     { "f13", offsetof(CPUState, fpr[13]) },
2800     { "f14", offsetof(CPUState, fpr[14]) },
2801     { "f15", offsetof(CPUState, fpr[15]) },
2802     { "f16", offsetof(CPUState, fpr[16]) },
2803     { "f17", offsetof(CPUState, fpr[17]) },
2804     { "f18", offsetof(CPUState, fpr[18]) },
2805     { "f19", offsetof(CPUState, fpr[19]) },
2806     { "f20", offsetof(CPUState, fpr[20]) },
2807     { "f21", offsetof(CPUState, fpr[21]) },
2808     { "f22", offsetof(CPUState, fpr[22]) },
2809     { "f23", offsetof(CPUState, fpr[23]) },
2810     { "f24", offsetof(CPUState, fpr[24]) },
2811     { "f25", offsetof(CPUState, fpr[25]) },
2812     { "f26", offsetof(CPUState, fpr[26]) },
2813     { "f27", offsetof(CPUState, fpr[27]) },
2814     { "f28", offsetof(CPUState, fpr[28]) },
2815     { "f29", offsetof(CPUState, fpr[29]) },
2816     { "f30", offsetof(CPUState, fpr[30]) },
2817     { "f31", offsetof(CPUState, fpr[31]) },
2818     { "fpscr", offsetof(CPUState, fpscr) },
2819     /* Next instruction pointer */
2820     { "nip|pc", offsetof(CPUState, nip) },
2821     { "lr", offsetof(CPUState, lr) },
2822     { "ctr", offsetof(CPUState, ctr) },
2823     { "decr", 0, &monitor_get_decr, },
2824     { "ccr", 0, &monitor_get_ccr, },
2825     /* Machine state register */
2826     { "msr", 0, &monitor_get_msr, },
2827     { "xer", 0, &monitor_get_xer, },
2828     { "tbu", 0, &monitor_get_tbu, },
2829     { "tbl", 0, &monitor_get_tbl, },
2830 #if defined(TARGET_PPC64)
2831     /* Address space register */
2832     { "asr", offsetof(CPUState, asr) },
2833 #endif
2834     /* Segment registers */
2835     { "sdr1", offsetof(CPUState, sdr1) },
2836     { "sr0", offsetof(CPUState, sr[0]) },
2837     { "sr1", offsetof(CPUState, sr[1]) },
2838     { "sr2", offsetof(CPUState, sr[2]) },
2839     { "sr3", offsetof(CPUState, sr[3]) },
2840     { "sr4", offsetof(CPUState, sr[4]) },
2841     { "sr5", offsetof(CPUState, sr[5]) },
2842     { "sr6", offsetof(CPUState, sr[6]) },
2843     { "sr7", offsetof(CPUState, sr[7]) },
2844     { "sr8", offsetof(CPUState, sr[8]) },
2845     { "sr9", offsetof(CPUState, sr[9]) },
2846     { "sr10", offsetof(CPUState, sr[10]) },
2847     { "sr11", offsetof(CPUState, sr[11]) },
2848     { "sr12", offsetof(CPUState, sr[12]) },
2849     { "sr13", offsetof(CPUState, sr[13]) },
2850     { "sr14", offsetof(CPUState, sr[14]) },
2851     { "sr15", offsetof(CPUState, sr[15]) },
2852     /* Too lazy to put BATs and SPRs ... */
2853 #elif defined(TARGET_SPARC)
2854     { "g0", offsetof(CPUState, gregs[0]) },
2855     { "g1", offsetof(CPUState, gregs[1]) },
2856     { "g2", offsetof(CPUState, gregs[2]) },
2857     { "g3", offsetof(CPUState, gregs[3]) },
2858     { "g4", offsetof(CPUState, gregs[4]) },
2859     { "g5", offsetof(CPUState, gregs[5]) },
2860     { "g6", offsetof(CPUState, gregs[6]) },
2861     { "g7", offsetof(CPUState, gregs[7]) },
2862     { "o0", 0, monitor_get_reg },
2863     { "o1", 1, monitor_get_reg },
2864     { "o2", 2, monitor_get_reg },
2865     { "o3", 3, monitor_get_reg },
2866     { "o4", 4, monitor_get_reg },
2867     { "o5", 5, monitor_get_reg },
2868     { "o6", 6, monitor_get_reg },
2869     { "o7", 7, monitor_get_reg },
2870     { "l0", 8, monitor_get_reg },
2871     { "l1", 9, monitor_get_reg },
2872     { "l2", 10, monitor_get_reg },
2873     { "l3", 11, monitor_get_reg },
2874     { "l4", 12, monitor_get_reg },
2875     { "l5", 13, monitor_get_reg },
2876     { "l6", 14, monitor_get_reg },
2877     { "l7", 15, monitor_get_reg },
2878     { "i0", 16, monitor_get_reg },
2879     { "i1", 17, monitor_get_reg },
2880     { "i2", 18, monitor_get_reg },
2881     { "i3", 19, monitor_get_reg },
2882     { "i4", 20, monitor_get_reg },
2883     { "i5", 21, monitor_get_reg },
2884     { "i6", 22, monitor_get_reg },
2885     { "i7", 23, monitor_get_reg },
2886     { "pc", offsetof(CPUState, pc) },
2887     { "npc", offsetof(CPUState, npc) },
2888     { "y", offsetof(CPUState, y) },
2889 #ifndef TARGET_SPARC64
2890     { "psr", 0, &monitor_get_psr, },
2891     { "wim", offsetof(CPUState, wim) },
2892 #endif
2893     { "tbr", offsetof(CPUState, tbr) },
2894     { "fsr", offsetof(CPUState, fsr) },
2895     { "f0", offsetof(CPUState, fpr[0]) },
2896     { "f1", offsetof(CPUState, fpr[1]) },
2897     { "f2", offsetof(CPUState, fpr[2]) },
2898     { "f3", offsetof(CPUState, fpr[3]) },
2899     { "f4", offsetof(CPUState, fpr[4]) },
2900     { "f5", offsetof(CPUState, fpr[5]) },
2901     { "f6", offsetof(CPUState, fpr[6]) },
2902     { "f7", offsetof(CPUState, fpr[7]) },
2903     { "f8", offsetof(CPUState, fpr[8]) },
2904     { "f9", offsetof(CPUState, fpr[9]) },
2905     { "f10", offsetof(CPUState, fpr[10]) },
2906     { "f11", offsetof(CPUState, fpr[11]) },
2907     { "f12", offsetof(CPUState, fpr[12]) },
2908     { "f13", offsetof(CPUState, fpr[13]) },
2909     { "f14", offsetof(CPUState, fpr[14]) },
2910     { "f15", offsetof(CPUState, fpr[15]) },
2911     { "f16", offsetof(CPUState, fpr[16]) },
2912     { "f17", offsetof(CPUState, fpr[17]) },
2913     { "f18", offsetof(CPUState, fpr[18]) },
2914     { "f19", offsetof(CPUState, fpr[19]) },
2915     { "f20", offsetof(CPUState, fpr[20]) },
2916     { "f21", offsetof(CPUState, fpr[21]) },
2917     { "f22", offsetof(CPUState, fpr[22]) },
2918     { "f23", offsetof(CPUState, fpr[23]) },
2919     { "f24", offsetof(CPUState, fpr[24]) },
2920     { "f25", offsetof(CPUState, fpr[25]) },
2921     { "f26", offsetof(CPUState, fpr[26]) },
2922     { "f27", offsetof(CPUState, fpr[27]) },
2923     { "f28", offsetof(CPUState, fpr[28]) },
2924     { "f29", offsetof(CPUState, fpr[29]) },
2925     { "f30", offsetof(CPUState, fpr[30]) },
2926     { "f31", offsetof(CPUState, fpr[31]) },
2927 #ifdef TARGET_SPARC64
2928     { "f32", offsetof(CPUState, fpr[32]) },
2929     { "f34", offsetof(CPUState, fpr[34]) },
2930     { "f36", offsetof(CPUState, fpr[36]) },
2931     { "f38", offsetof(CPUState, fpr[38]) },
2932     { "f40", offsetof(CPUState, fpr[40]) },
2933     { "f42", offsetof(CPUState, fpr[42]) },
2934     { "f44", offsetof(CPUState, fpr[44]) },
2935     { "f46", offsetof(CPUState, fpr[46]) },
2936     { "f48", offsetof(CPUState, fpr[48]) },
2937     { "f50", offsetof(CPUState, fpr[50]) },
2938     { "f52", offsetof(CPUState, fpr[52]) },
2939     { "f54", offsetof(CPUState, fpr[54]) },
2940     { "f56", offsetof(CPUState, fpr[56]) },
2941     { "f58", offsetof(CPUState, fpr[58]) },
2942     { "f60", offsetof(CPUState, fpr[60]) },
2943     { "f62", offsetof(CPUState, fpr[62]) },
2944     { "asi", offsetof(CPUState, asi) },
2945     { "pstate", offsetof(CPUState, pstate) },
2946     { "cansave", offsetof(CPUState, cansave) },
2947     { "canrestore", offsetof(CPUState, canrestore) },
2948     { "otherwin", offsetof(CPUState, otherwin) },
2949     { "wstate", offsetof(CPUState, wstate) },
2950     { "cleanwin", offsetof(CPUState, cleanwin) },
2951     { "fprs", offsetof(CPUState, fprs) },
2952 #endif
2953 #endif
2954     { NULL },
2955 };
2956
2957 static void expr_error(Monitor *mon, const char *msg)
2958 {
2959     monitor_printf(mon, "%s\n", msg);
2960     longjmp(expr_env, 1);
2961 }
2962
2963 /* return 0 if OK, -1 if not found */
2964 static int get_monitor_def(target_long *pval, const char *name)
2965 {
2966     const MonitorDef *md;
2967     void *ptr;
2968
2969     for(md = monitor_defs; md->name != NULL; md++) {
2970         if (compare_cmd(name, md->name)) {
2971             if (md->get_value) {
2972                 *pval = md->get_value(md, md->offset);
2973             } else {
2974                 CPUState *env = mon_get_cpu();
2975                 ptr = (uint8_t *)env + md->offset;
2976                 switch(md->type) {
2977                 case MD_I32:
2978                     *pval = *(int32_t *)ptr;
2979                     break;
2980                 case MD_TLONG:
2981                     *pval = *(target_long *)ptr;
2982                     break;
2983                 default:
2984                     *pval = 0;
2985                     break;
2986                 }
2987             }
2988             return 0;
2989         }
2990     }
2991     return -1;
2992 }
2993
2994 static void next(void)
2995 {
2996     if (*pch != '\0') {
2997         pch++;
2998         while (qemu_isspace(*pch))
2999             pch++;
3000     }
3001 }
3002
3003 static int64_t expr_sum(Monitor *mon);
3004
3005 static int64_t expr_unary(Monitor *mon)
3006 {
3007     int64_t n;
3008     char *p;
3009     int ret;
3010
3011     switch(*pch) {
3012     case '+':
3013         next();
3014         n = expr_unary(mon);
3015         break;
3016     case '-':
3017         next();
3018         n = -expr_unary(mon);
3019         break;
3020     case '~':
3021         next();
3022         n = ~expr_unary(mon);
3023         break;
3024     case '(':
3025         next();
3026         n = expr_sum(mon);
3027         if (*pch != ')') {
3028             expr_error(mon, "')' expected");
3029         }
3030         next();
3031         break;
3032     case '\'':
3033         pch++;
3034         if (*pch == '\0')
3035             expr_error(mon, "character constant expected");
3036         n = *pch;
3037         pch++;
3038         if (*pch != '\'')
3039             expr_error(mon, "missing terminating \' character");
3040         next();
3041         break;
3042     case '$':
3043         {
3044             char buf[128], *q;
3045             target_long reg=0;
3046
3047             pch++;
3048             q = buf;
3049             while ((*pch >= 'a' && *pch <= 'z') ||
3050                    (*pch >= 'A' && *pch <= 'Z') ||
3051                    (*pch >= '0' && *pch <= '9') ||
3052                    *pch == '_' || *pch == '.') {
3053                 if ((q - buf) < sizeof(buf) - 1)
3054                     *q++ = *pch;
3055                 pch++;
3056             }
3057             while (qemu_isspace(*pch))
3058                 pch++;
3059             *q = 0;
3060             ret = get_monitor_def(&reg, buf);
3061             if (ret < 0)
3062                 expr_error(mon, "unknown register");
3063             n = reg;
3064         }
3065         break;
3066     case '\0':
3067         expr_error(mon, "unexpected end of expression");
3068         n = 0;
3069         break;
3070     default:
3071 #if TARGET_PHYS_ADDR_BITS > 32
3072         n = strtoull(pch, &p, 0);
3073 #else
3074         n = strtoul(pch, &p, 0);
3075 #endif
3076         if (pch == p) {
3077             expr_error(mon, "invalid char in expression");
3078         }
3079         pch = p;
3080         while (qemu_isspace(*pch))
3081             pch++;
3082         break;
3083     }
3084     return n;
3085 }
3086
3087
3088 static int64_t expr_prod(Monitor *mon)
3089 {
3090     int64_t val, val2;
3091     int op;
3092
3093     val = expr_unary(mon);
3094     for(;;) {
3095         op = *pch;
3096         if (op != '*' && op != '/' && op != '%')
3097             break;
3098         next();
3099         val2 = expr_unary(mon);
3100         switch(op) {
3101         default:
3102         case '*':
3103             val *= val2;
3104             break;
3105         case '/':
3106         case '%':
3107             if (val2 == 0)
3108                 expr_error(mon, "division by zero");
3109             if (op == '/')
3110                 val /= val2;
3111             else
3112                 val %= val2;
3113             break;
3114         }
3115     }
3116     return val;
3117 }
3118
3119 static int64_t expr_logic(Monitor *mon)
3120 {
3121     int64_t val, val2;
3122     int op;
3123
3124     val = expr_prod(mon);
3125     for(;;) {
3126         op = *pch;
3127         if (op != '&' && op != '|' && op != '^')
3128             break;
3129         next();
3130         val2 = expr_prod(mon);
3131         switch(op) {
3132         default:
3133         case '&':
3134             val &= val2;
3135             break;
3136         case '|':
3137             val |= val2;
3138             break;
3139         case '^':
3140             val ^= val2;
3141             break;
3142         }
3143     }
3144     return val;
3145 }
3146
3147 static int64_t expr_sum(Monitor *mon)
3148 {
3149     int64_t val, val2;
3150     int op;
3151
3152     val = expr_logic(mon);
3153     for(;;) {
3154         op = *pch;
3155         if (op != '+' && op != '-')
3156             break;
3157         next();
3158         val2 = expr_logic(mon);
3159         if (op == '+')
3160             val += val2;
3161         else
3162             val -= val2;
3163     }
3164     return val;
3165 }
3166
3167 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3168 {
3169     pch = *pp;
3170     if (setjmp(expr_env)) {
3171         *pp = pch;
3172         return -1;
3173     }
3174     while (qemu_isspace(*pch))
3175         pch++;
3176     *pval = expr_sum(mon);
3177     *pp = pch;
3178     return 0;
3179 }
3180
3181 static int get_str(char *buf, int buf_size, const char **pp)
3182 {
3183     const char *p;
3184     char *q;
3185     int c;
3186
3187     q = buf;
3188     p = *pp;
3189     while (qemu_isspace(*p))
3190         p++;
3191     if (*p == '\0') {
3192     fail:
3193         *q = '\0';
3194         *pp = p;
3195         return -1;
3196     }
3197     if (*p == '\"') {
3198         p++;
3199         while (*p != '\0' && *p != '\"') {
3200             if (*p == '\\') {
3201                 p++;
3202                 c = *p++;
3203                 switch(c) {
3204                 case 'n':
3205                     c = '\n';
3206                     break;
3207                 case 'r':
3208                     c = '\r';
3209                     break;
3210                 case '\\':
3211                 case '\'':
3212                 case '\"':
3213                     break;
3214                 default:
3215                     qemu_printf("unsupported escape code: '\\%c'\n", c);
3216                     goto fail;
3217                 }
3218                 if ((q - buf) < buf_size - 1) {
3219                     *q++ = c;
3220                 }
3221             } else {
3222                 if ((q - buf) < buf_size - 1) {
3223                     *q++ = *p;
3224                 }
3225                 p++;
3226             }
3227         }
3228         if (*p != '\"') {
3229             qemu_printf("unterminated string\n");
3230             goto fail;
3231         }
3232         p++;
3233     } else {
3234         while (*p != '\0' && !qemu_isspace(*p)) {
3235             if ((q - buf) < buf_size - 1) {
3236                 *q++ = *p;
3237             }
3238             p++;
3239         }
3240     }
3241     *q = '\0';
3242     *pp = p;
3243     return 0;
3244 }
3245
3246 /*
3247  * Store the command-name in cmdname, and return a pointer to
3248  * the remaining of the command string.
3249  */
3250 static const char *get_command_name(const char *cmdline,
3251                                     char *cmdname, size_t nlen)
3252 {
3253     size_t len;
3254     const char *p, *pstart;
3255
3256     p = cmdline;
3257     while (qemu_isspace(*p))
3258         p++;
3259     if (*p == '\0')
3260         return NULL;
3261     pstart = p;
3262     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3263         p++;
3264     len = p - pstart;
3265     if (len > nlen - 1)
3266         len = nlen - 1;
3267     memcpy(cmdname, pstart, len);
3268     cmdname[len] = '\0';
3269     return p;
3270 }
3271
3272 /**
3273  * Read key of 'type' into 'key' and return the current
3274  * 'type' pointer.
3275  */
3276 static char *key_get_info(const char *type, char **key)
3277 {
3278     size_t len;
3279     char *p, *str;
3280
3281     if (*type == ',')
3282         type++;
3283
3284     p = strchr(type, ':');
3285     if (!p) {
3286         *key = NULL;
3287         return NULL;
3288     }
3289     len = p - type;
3290
3291     str = qemu_malloc(len + 1);
3292     memcpy(str, type, len);
3293     str[len] = '\0';
3294
3295     *key = str;
3296     return ++p;
3297 }
3298
3299 static int default_fmt_format = 'x';
3300 static int default_fmt_size = 4;
3301
3302 #define MAX_ARGS 16
3303
3304 static int is_valid_option(const char *c, const char *typestr)
3305 {
3306     char option[3];
3307
3308     option[0] = '-';
3309     option[1] = *c;
3310     option[2] = '\0';
3311
3312     typestr = strstr(typestr, option);
3313     return (typestr != NULL);
3314 }
3315
3316 static const mon_cmd_t *monitor_find_command(const char *cmdname)
3317 {
3318     const mon_cmd_t *cmd;
3319
3320     for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3321         if (compare_cmd(cmdname, cmd->name)) {
3322             return cmd;
3323         }
3324     }
3325
3326     return NULL;
3327 }
3328
3329 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3330                                               const char *cmdline,
3331                                               QDict *qdict)
3332 {
3333     const char *p, *typestr;
3334     int c;
3335     const mon_cmd_t *cmd;
3336     char cmdname[256];
3337     char buf[1024];
3338     char *key;
3339
3340 #ifdef DEBUG
3341     monitor_printf(mon, "command='%s'\n", cmdline);
3342 #endif
3343
3344     /* extract the command name */
3345     p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3346     if (!p)
3347         return NULL;
3348
3349     cmd = monitor_find_command(cmdname);
3350     if (!cmd) {
3351         monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3352         return NULL;
3353     }
3354
3355     /* parse the parameters */
3356     typestr = cmd->args_type;
3357     for(;;) {
3358         typestr = key_get_info(typestr, &key);
3359         if (!typestr)
3360             break;
3361         c = *typestr;
3362         typestr++;
3363         switch(c) {
3364         case 'F':
3365         case 'B':
3366         case 's':
3367             {
3368                 int ret;
3369
3370                 while (qemu_isspace(*p))
3371                     p++;
3372                 if (*typestr == '?') {
3373                     typestr++;
3374                     if (*p == '\0') {
3375                         /* no optional string: NULL argument */
3376                         break;
3377                     }
3378                 }
3379                 ret = get_str(buf, sizeof(buf), &p);
3380                 if (ret < 0) {
3381                     switch(c) {
3382                     case 'F':
3383                         monitor_printf(mon, "%s: filename expected\n",
3384                                        cmdname);
3385                         break;
3386                     case 'B':
3387                         monitor_printf(mon, "%s: block device name expected\n",
3388                                        cmdname);
3389                         break;
3390                     default:
3391                         monitor_printf(mon, "%s: string expected\n", cmdname);
3392                         break;
3393                     }
3394                     goto fail;
3395                 }
3396                 qdict_put(qdict, key, qstring_from_str(buf));
3397             }
3398             break;
3399         case '/':
3400             {
3401                 int count, format, size;
3402
3403                 while (qemu_isspace(*p))
3404                     p++;
3405                 if (*p == '/') {
3406                     /* format found */
3407                     p++;
3408                     count = 1;
3409                     if (qemu_isdigit(*p)) {
3410                         count = 0;
3411                         while (qemu_isdigit(*p)) {
3412                             count = count * 10 + (*p - '0');
3413                             p++;
3414                         }
3415                     }
3416                     size = -1;
3417                     format = -1;
3418                     for(;;) {
3419                         switch(*p) {
3420                         case 'o':
3421                         case 'd':
3422                         case 'u':
3423                         case 'x':
3424                         case 'i':
3425                         case 'c':
3426                             format = *p++;
3427                             break;
3428                         case 'b':
3429                             size = 1;
3430                             p++;
3431                             break;
3432                         case 'h':
3433                             size = 2;
3434                             p++;
3435                             break;
3436                         case 'w':
3437                             size = 4;
3438                             p++;
3439                             break;
3440                         case 'g':
3441                         case 'L':
3442                             size = 8;
3443                             p++;
3444                             break;
3445                         default:
3446                             goto next;
3447                         }
3448                     }
3449                 next:
3450                     if (*p != '\0' && !qemu_isspace(*p)) {
3451                         monitor_printf(mon, "invalid char in format: '%c'\n",
3452                                        *p);
3453                         goto fail;
3454                     }
3455                     if (format < 0)
3456                         format = default_fmt_format;
3457                     if (format != 'i') {
3458                         /* for 'i', not specifying a size gives -1 as size */
3459                         if (size < 0)
3460                             size = default_fmt_size;
3461                         default_fmt_size = size;
3462                     }
3463                     default_fmt_format = format;
3464                 } else {
3465                     count = 1;
3466                     format = default_fmt_format;
3467                     if (format != 'i') {
3468                         size = default_fmt_size;
3469                     } else {
3470                         size = -1;
3471                     }
3472                 }
3473                 qdict_put(qdict, "count", qint_from_int(count));
3474                 qdict_put(qdict, "format", qint_from_int(format));
3475                 qdict_put(qdict, "size", qint_from_int(size));
3476             }
3477             break;
3478         case 'i':
3479         case 'l':
3480         case 'M':
3481             {
3482                 int64_t val;
3483
3484                 while (qemu_isspace(*p))
3485                     p++;
3486                 if (*typestr == '?' || *typestr == '.') {
3487                     if (*typestr == '?') {
3488                         if (*p == '\0') {
3489                             typestr++;
3490                             break;
3491                         }
3492                     } else {
3493                         if (*p == '.') {
3494                             p++;
3495                             while (qemu_isspace(*p))
3496                                 p++;
3497                         } else {
3498                             typestr++;
3499                             break;
3500                         }
3501                     }
3502                     typestr++;
3503                 }
3504                 if (get_expr(mon, &val, &p))
3505                     goto fail;
3506                 /* Check if 'i' is greater than 32-bit */
3507                 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3508                     monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3509                     monitor_printf(mon, "integer is for 32-bit values\n");
3510                     goto fail;
3511                 } else if (c == 'M') {
3512                     val <<= 20;
3513                 }
3514                 qdict_put(qdict, key, qint_from_int(val));
3515             }
3516             break;
3517         case '-':
3518             {
3519                 const char *tmp = p;
3520                 int has_option, skip_key = 0;
3521                 /* option */
3522
3523                 c = *typestr++;
3524                 if (c == '\0')
3525                     goto bad_type;
3526                 while (qemu_isspace(*p))
3527                     p++;
3528                 has_option = 0;
3529                 if (*p == '-') {
3530                     p++;
3531                     if(c != *p) {
3532                         if(!is_valid_option(p, typestr)) {
3533
3534                             monitor_printf(mon, "%s: unsupported option -%c\n",
3535                                            cmdname, *p);
3536                             goto fail;
3537                         } else {
3538                             skip_key = 1;
3539                         }
3540                     }
3541                     if(skip_key) {
3542                         p = tmp;
3543                     } else {
3544                         p++;
3545                         has_option = 1;
3546                     }
3547                 }
3548                 qdict_put(qdict, key, qint_from_int(has_option));
3549             }
3550             break;
3551         default:
3552         bad_type:
3553             monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3554             goto fail;
3555         }
3556         qemu_free(key);
3557         key = NULL;
3558     }
3559     /* check that all arguments were parsed */
3560     while (qemu_isspace(*p))
3561         p++;
3562     if (*p != '\0') {
3563         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3564                        cmdname);
3565         goto fail;
3566     }
3567
3568     return cmd;
3569
3570 fail:
3571     qemu_free(key);
3572     return NULL;
3573 }
3574
3575 static void monitor_print_error(Monitor *mon)
3576 {
3577     qerror_print(mon->error);
3578     QDECREF(mon->error);
3579     mon->error = NULL;
3580 }
3581
3582 static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3583                                  const QDict *params)
3584 {
3585     QObject *data = NULL;
3586
3587     cmd->mhandler.cmd_new(mon, params, &data);
3588
3589     if (monitor_ctrl_mode(mon)) {
3590         /* Monitor Protocol */
3591         monitor_protocol_emitter(mon, data);
3592     } else {
3593         /* User Protocol */
3594          if (data)
3595             cmd->user_print(mon, data);
3596     }
3597
3598     qobject_decref(data);
3599 }
3600
3601 static void handle_user_command(Monitor *mon, const char *cmdline)
3602 {
3603     QDict *qdict;
3604     const mon_cmd_t *cmd;
3605
3606     qdict = qdict_new();
3607
3608     cmd = monitor_parse_command(mon, cmdline, qdict);
3609     if (!cmd)
3610         goto out;
3611
3612     qemu_errors_to_mon(mon);
3613
3614     if (monitor_handler_ported(cmd)) {
3615         monitor_call_handler(mon, cmd, qdict);
3616     } else {
3617         cmd->mhandler.cmd(mon, qdict);
3618     }
3619
3620     if (monitor_has_error(mon))
3621         monitor_print_error(mon);
3622
3623     qemu_errors_to_previous();
3624
3625 out:
3626     QDECREF(qdict);
3627 }
3628
3629 static void cmd_completion(const char *name, const char *list)
3630 {
3631     const char *p, *pstart;
3632     char cmd[128];
3633     int len;
3634
3635     p = list;
3636     for(;;) {
3637         pstart = p;
3638         p = strchr(p, '|');
3639         if (!p)
3640             p = pstart + strlen(pstart);
3641         len = p - pstart;
3642         if (len > sizeof(cmd) - 2)
3643             len = sizeof(cmd) - 2;
3644         memcpy(cmd, pstart, len);
3645         cmd[len] = '\0';
3646         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3647             readline_add_completion(cur_mon->rs, cmd);
3648         }
3649         if (*p == '\0')
3650             break;
3651         p++;
3652     }
3653 }
3654
3655 static void file_completion(const char *input)
3656 {
3657     DIR *ffs;
3658     struct dirent *d;
3659     char path[1024];
3660     char file[1024], file_prefix[1024];
3661     int input_path_len;
3662     const char *p;
3663
3664     p = strrchr(input, '/');
3665     if (!p) {
3666         input_path_len = 0;
3667         pstrcpy(file_prefix, sizeof(file_prefix), input);
3668         pstrcpy(path, sizeof(path), ".");
3669     } else {
3670         input_path_len = p - input + 1;
3671         memcpy(path, input, input_path_len);
3672         if (input_path_len > sizeof(path) - 1)
3673             input_path_len = sizeof(path) - 1;
3674         path[input_path_len] = '\0';
3675         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3676     }
3677 #ifdef DEBUG_COMPLETION
3678     monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3679                    input, path, file_prefix);
3680 #endif
3681     ffs = opendir(path);
3682     if (!ffs)
3683         return;
3684     for(;;) {
3685         struct stat sb;
3686         d = readdir(ffs);
3687         if (!d)
3688             break;
3689         if (strstart(d->d_name, file_prefix, NULL)) {
3690             memcpy(file, input, input_path_len);
3691             if (input_path_len < sizeof(file))
3692                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3693                         d->d_name);
3694             /* stat the file to find out if it's a directory.
3695              * In that case add a slash to speed up typing long paths
3696              */
3697             stat(file, &sb);
3698             if(S_ISDIR(sb.st_mode))
3699                 pstrcat(file, sizeof(file), "/");
3700             readline_add_completion(cur_mon->rs, file);
3701         }
3702     }
3703     closedir(ffs);
3704 }
3705
3706 static void block_completion_it(void *opaque, BlockDriverState *bs)
3707 {
3708     const char *name = bdrv_get_device_name(bs);
3709     const char *input = opaque;
3710
3711     if (input[0] == '\0' ||
3712         !strncmp(name, (char *)input, strlen(input))) {
3713         readline_add_completion(cur_mon->rs, name);
3714     }
3715 }
3716
3717 /* NOTE: this parser is an approximate form of the real command parser */
3718 static void parse_cmdline(const char *cmdline,
3719                          int *pnb_args, char **args)
3720 {
3721     const char *p;
3722     int nb_args, ret;
3723     char buf[1024];
3724
3725     p = cmdline;
3726     nb_args = 0;
3727     for(;;) {
3728         while (qemu_isspace(*p))
3729             p++;
3730         if (*p == '\0')
3731             break;
3732         if (nb_args >= MAX_ARGS)
3733             break;
3734         ret = get_str(buf, sizeof(buf), &p);
3735         args[nb_args] = qemu_strdup(buf);
3736         nb_args++;
3737         if (ret < 0)
3738             break;
3739     }
3740     *pnb_args = nb_args;
3741 }
3742
3743 static const char *next_arg_type(const char *typestr)
3744 {
3745     const char *p = strchr(typestr, ':');
3746     return (p != NULL ? ++p : typestr);
3747 }
3748
3749 static void monitor_find_completion(const char *cmdline)
3750 {
3751     const char *cmdname;
3752     char *args[MAX_ARGS];
3753     int nb_args, i, len;
3754     const char *ptype, *str;
3755     const mon_cmd_t *cmd;
3756     const KeyDef *key;
3757
3758     parse_cmdline(cmdline, &nb_args, args);
3759 #ifdef DEBUG_COMPLETION
3760     for(i = 0; i < nb_args; i++) {
3761         monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
3762     }
3763 #endif
3764
3765     /* if the line ends with a space, it means we want to complete the
3766        next arg */
3767     len = strlen(cmdline);
3768     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3769         if (nb_args >= MAX_ARGS)
3770             return;
3771         args[nb_args++] = qemu_strdup("");
3772     }
3773     if (nb_args <= 1) {
3774         /* command completion */
3775         if (nb_args == 0)
3776             cmdname = "";
3777         else
3778             cmdname = args[0];
3779         readline_set_completion_index(cur_mon->rs, strlen(cmdname));
3780         for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
3781             cmd_completion(cmdname, cmd->name);
3782         }
3783     } else {
3784         /* find the command */
3785         for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
3786             if (compare_cmd(args[0], cmd->name))
3787                 goto found;
3788         }
3789         return;
3790     found:
3791         ptype = next_arg_type(cmd->args_type);
3792         for(i = 0; i < nb_args - 2; i++) {
3793             if (*ptype != '\0') {
3794                 ptype = next_arg_type(ptype);
3795                 while (*ptype == '?')
3796                     ptype = next_arg_type(ptype);
3797             }
3798         }
3799         str = args[nb_args - 1];
3800         if (*ptype == '-' && ptype[1] != '\0') {
3801             ptype += 2;
3802         }
3803         switch(*ptype) {
3804         case 'F':
3805             /* file completion */
3806             readline_set_completion_index(cur_mon->rs, strlen(str));
3807             file_completion(str);
3808             break;
3809         case 'B':
3810             /* block device name completion */
3811             readline_set_completion_index(cur_mon->rs, strlen(str));
3812             bdrv_iterate(block_completion_it, (void *)str);
3813             break;
3814         case 's':
3815             /* XXX: more generic ? */
3816             if (!strcmp(cmd->name, "info")) {
3817                 readline_set_completion_index(cur_mon->rs, strlen(str));
3818                 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
3819                     cmd_completion(str, cmd->name);
3820                 }
3821             } else if (!strcmp(cmd->name, "sendkey")) {
3822                 char *sep = strrchr(str, '-');
3823                 if (sep)
3824                     str = sep + 1;
3825                 readline_set_completion_index(cur_mon->rs, strlen(str));
3826                 for(key = key_defs; key->name != NULL; key++) {
3827                     cmd_completion(str, key->name);
3828                 }
3829             } else if (!strcmp(cmd->name, "help|?")) {
3830                 readline_set_completion_index(cur_mon->rs, strlen(str));
3831                 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3832                     cmd_completion(str, cmd->name);
3833                 }
3834             }
3835             break;
3836         default:
3837             break;
3838         }
3839     }
3840     for(i = 0; i < nb_args; i++)
3841         qemu_free(args[i]);
3842 }
3843
3844 static int monitor_can_read(void *opaque)
3845 {
3846     Monitor *mon = opaque;
3847
3848     return (mon->suspend_cnt == 0) ? 1 : 0;
3849 }
3850
3851 typedef struct CmdArgs {
3852     QString *name;
3853     int type;
3854     int flag;
3855     int optional;
3856 } CmdArgs;
3857
3858 static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
3859 {
3860     if (!cmd_args->optional) {
3861         qemu_error_new(QERR_MISSING_PARAMETER, name);
3862         return -1;
3863     }
3864
3865     if (cmd_args->type == '-') {
3866         /* handlers expect a value, they need to be changed */
3867         qdict_put(args, name, qint_from_int(0));
3868     }
3869
3870     return 0;
3871 }
3872
3873 static int check_arg(const CmdArgs *cmd_args, QDict *args)
3874 {
3875     QObject *value;
3876     const char *name;
3877
3878     name = qstring_get_str(cmd_args->name);
3879
3880     if (!args) {
3881         return check_opt(cmd_args, name, args);
3882     }
3883
3884     value = qdict_get(args, name);
3885     if (!value) {
3886         return check_opt(cmd_args, name, args);
3887     }
3888
3889     switch (cmd_args->type) {
3890         case 'F':
3891         case 'B':
3892         case 's':
3893             if (qobject_type(value) != QTYPE_QSTRING) {
3894                 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "string");
3895                 return -1;
3896             }
3897             break;
3898         case '/': {
3899             int i;
3900             const char *keys[] = { "count", "format", "size", NULL };
3901
3902             for (i = 0; keys[i]; i++) {
3903                 QObject *obj = qdict_get(args, keys[i]);
3904                 if (!obj) {
3905                     qemu_error_new(QERR_MISSING_PARAMETER, name);
3906                     return -1;
3907                 }
3908                 if (qobject_type(obj) != QTYPE_QINT) {
3909                     qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
3910                     return -1;
3911                 }
3912             }
3913             break;
3914         }
3915         case 'i':
3916         case 'l':
3917         case 'M':
3918             if (qobject_type(value) != QTYPE_QINT) {
3919                 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "int");
3920                 return -1;
3921             }
3922             break;
3923         case '-':
3924             if (qobject_type(value) != QTYPE_QINT &&
3925                 qobject_type(value) != QTYPE_QBOOL) {
3926                 qemu_error_new(QERR_INVALID_PARAMETER_TYPE, name, "bool");
3927                 return -1;
3928             }
3929             if (qobject_type(value) == QTYPE_QBOOL) {
3930                 /* handlers expect a QInt, they need to be changed */
3931                 qdict_put(args, name,
3932                          qint_from_int(qbool_get_int(qobject_to_qbool(value))));
3933             }
3934             break;
3935         default:
3936             /* impossible */
3937             abort();
3938     }
3939
3940     return 0;
3941 }
3942
3943 static void cmd_args_init(CmdArgs *cmd_args)
3944 {
3945     cmd_args->name = qstring_new();
3946     cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
3947 }
3948
3949 /*
3950  * This is not trivial, we have to parse Monitor command's argument
3951  * type syntax to be able to check the arguments provided by clients.
3952  *
3953  * In the near future we will be using an array for that and will be
3954  * able to drop all this parsing...
3955  */
3956 static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
3957 {
3958     int err;
3959     const char *p;
3960     CmdArgs cmd_args;
3961
3962     if (cmd->args_type == NULL) {
3963         return (qdict_size(args) == 0 ? 0 : -1);
3964     }
3965
3966     err = 0;
3967     cmd_args_init(&cmd_args);
3968
3969     for (p = cmd->args_type;; p++) {
3970         if (*p == ':') {
3971             cmd_args.type = *++p;
3972             p++;
3973             if (cmd_args.type == '-') {
3974                 cmd_args.flag = *p++;
3975                 cmd_args.optional = 1;
3976             } else if (*p == '?') {
3977                 cmd_args.optional = 1;
3978                 p++;
3979             }
3980
3981             assert(*p == ',' || *p == '\0');
3982             err = check_arg(&cmd_args, args);
3983
3984             QDECREF(cmd_args.name);
3985             cmd_args_init(&cmd_args);
3986
3987             if (err < 0) {
3988                 break;
3989             }
3990         } else {
3991             qstring_append_chr(cmd_args.name, *p);
3992         }
3993
3994         if (*p == '\0') {
3995             break;
3996         }
3997     }
3998
3999     QDECREF(cmd_args.name);
4000     return err;
4001 }
4002
4003 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4004 {
4005     int err;
4006     QObject *obj;
4007     QDict *input, *args;
4008     const mon_cmd_t *cmd;
4009     Monitor *mon = cur_mon;
4010     const char *cmd_name, *info_item;
4011
4012     args = NULL;
4013     qemu_errors_to_mon(mon);
4014
4015     obj = json_parser_parse(tokens, NULL);
4016     if (!obj) {
4017         // FIXME: should be triggered in json_parser_parse()
4018         qemu_error_new(QERR_JSON_PARSING);
4019         goto err_out;
4020     } else if (qobject_type(obj) != QTYPE_QDICT) {
4021         qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "object");
4022         qobject_decref(obj);
4023         goto err_out;
4024     }
4025
4026     input = qobject_to_qdict(obj);
4027
4028     mon->mc->id = qdict_get(input, "id");
4029     qobject_incref(mon->mc->id);
4030
4031     obj = qdict_get(input, "execute");
4032     if (!obj) {
4033         qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4034         goto err_input;
4035     } else if (qobject_type(obj) != QTYPE_QSTRING) {
4036         qemu_error_new(QERR_QMP_BAD_INPUT_OBJECT, "string");
4037         goto err_input;
4038     }
4039
4040     cmd_name = qstring_get_str(qobject_to_qstring(obj));
4041
4042     /*
4043      * XXX: We need this special case until we get info handlers
4044      * converted into 'query-' commands
4045      */
4046     if (compare_cmd(cmd_name, "info")) {
4047         qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
4048         goto err_input;
4049     } else if (strstart(cmd_name, "query-", &info_item)) {
4050         cmd = monitor_find_command("info");
4051         qdict_put_obj(input, "arguments",
4052                       qobject_from_jsonf("{ 'item': %s }", info_item));
4053     } else {
4054         cmd = monitor_find_command(cmd_name);
4055         if (!cmd || !monitor_handler_ported(cmd)) {
4056             qemu_error_new(QERR_COMMAND_NOT_FOUND, cmd_name);
4057             goto err_input;
4058         }
4059     }
4060
4061     obj = qdict_get(input, "arguments");
4062     if (!obj) {
4063         args = qdict_new();
4064     } else {
4065         args = qobject_to_qdict(obj);
4066         QINCREF(args);
4067     }
4068
4069     QDECREF(input);
4070
4071     err = monitor_check_qmp_args(cmd, args);
4072     if (err < 0) {
4073         goto err_out;
4074     }
4075
4076     monitor_call_handler(mon, cmd, args);
4077     goto out;
4078
4079 err_input:
4080     QDECREF(input);
4081 err_out:
4082     monitor_protocol_emitter(mon, NULL);
4083 out:
4084     QDECREF(args);
4085     qemu_errors_to_previous();
4086 }
4087
4088 /**
4089  * monitor_control_read(): Read and handle QMP input
4090  */
4091 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4092 {
4093     Monitor *old_mon = cur_mon;
4094
4095     cur_mon = opaque;
4096
4097     json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4098
4099     cur_mon = old_mon;
4100 }
4101
4102 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4103 {
4104     Monitor *old_mon = cur_mon;
4105     int i;
4106
4107     cur_mon = opaque;
4108
4109     if (cur_mon->rs) {
4110         for (i = 0; i < size; i++)
4111             readline_handle_byte(cur_mon->rs, buf[i]);
4112     } else {
4113         if (size == 0 || buf[size - 1] != 0)
4114             monitor_printf(cur_mon, "corrupted command\n");
4115         else
4116             handle_user_command(cur_mon, (char *)buf);
4117     }
4118
4119     cur_mon = old_mon;
4120 }
4121
4122 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4123 {
4124     monitor_suspend(mon);
4125     handle_user_command(mon, cmdline);
4126     monitor_resume(mon);
4127 }
4128
4129 int monitor_suspend(Monitor *mon)
4130 {
4131     if (!mon->rs)
4132         return -ENOTTY;
4133     mon->suspend_cnt++;
4134     return 0;
4135 }
4136
4137 void monitor_resume(Monitor *mon)
4138 {
4139     if (!mon->rs)
4140         return;
4141     if (--mon->suspend_cnt == 0)
4142         readline_show_prompt(mon->rs);
4143 }
4144
4145 /**
4146  * monitor_control_event(): Print QMP gretting
4147  */
4148 static void monitor_control_event(void *opaque, int event)
4149 {
4150     if (event == CHR_EVENT_OPENED) {
4151         QObject *data;
4152         Monitor *mon = opaque;
4153
4154         json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4155
4156         data = qobject_from_jsonf("{ 'QMP': { 'capabilities': [] } }");
4157         assert(data != NULL);
4158
4159         monitor_json_emitter(mon, data);
4160         qobject_decref(data);
4161     }
4162 }
4163
4164 static void monitor_event(void *opaque, int event)
4165 {
4166     Monitor *mon = opaque;
4167
4168     switch (event) {
4169     case CHR_EVENT_MUX_IN:
4170         mon->mux_out = 0;
4171         if (mon->reset_seen) {
4172             readline_restart(mon->rs);
4173             monitor_resume(mon);
4174             monitor_flush(mon);
4175         } else {
4176             mon->suspend_cnt = 0;
4177         }
4178         break;
4179
4180     case CHR_EVENT_MUX_OUT:
4181         if (mon->reset_seen) {
4182             if (mon->suspend_cnt == 0) {
4183                 monitor_printf(mon, "\n");
4184             }
4185             monitor_flush(mon);
4186             monitor_suspend(mon);
4187         } else {
4188             mon->suspend_cnt++;
4189         }
4190         mon->mux_out = 1;
4191         break;
4192
4193     case CHR_EVENT_OPENED:
4194         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4195                        "information\n", QEMU_VERSION);
4196         if (!mon->mux_out) {
4197             readline_show_prompt(mon->rs);
4198         }
4199         mon->reset_seen = 1;
4200         break;
4201     }
4202 }
4203
4204
4205 /*
4206  * Local variables:
4207  *  c-indent-level: 4
4208  *  c-basic-offset: 4
4209  *  tab-width: 8
4210  * End:
4211  */
4212
4213 void monitor_init(CharDriverState *chr, int flags)
4214 {
4215     static int is_first_init = 1;
4216     Monitor *mon;
4217
4218     if (is_first_init) {
4219         key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4220         is_first_init = 0;
4221     }
4222
4223     mon = qemu_mallocz(sizeof(*mon));
4224
4225     mon->chr = chr;
4226     mon->flags = flags;
4227     if (flags & MONITOR_USE_READLINE) {
4228         mon->rs = readline_init(mon, monitor_find_completion);
4229         monitor_read_command(mon, 0);
4230     }
4231
4232     if (monitor_ctrl_mode(mon)) {
4233         mon->mc = qemu_mallocz(sizeof(MonitorControl));
4234         /* Control mode requires special handlers */
4235         qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4236                               monitor_control_event, mon);
4237     } else {
4238         qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4239                               monitor_event, mon);
4240     }
4241
4242     QLIST_INSERT_HEAD(&mon_list, mon, entry);
4243     if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
4244         cur_mon = mon;
4245 }
4246
4247 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4248 {
4249     BlockDriverState *bs = opaque;
4250     int ret = 0;
4251
4252     if (bdrv_set_key(bs, password) != 0) {
4253         monitor_printf(mon, "invalid password\n");
4254         ret = -EPERM;
4255     }
4256     if (mon->password_completion_cb)
4257         mon->password_completion_cb(mon->password_opaque, ret);
4258
4259     monitor_read_command(mon, 1);
4260 }
4261
4262 void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4263                                  BlockDriverCompletionFunc *completion_cb,
4264                                  void *opaque)
4265 {
4266     int err;
4267
4268     if (!bdrv_key_required(bs)) {
4269         if (completion_cb)
4270             completion_cb(opaque, 0);
4271         return;
4272     }
4273
4274     if (monitor_ctrl_mode(mon)) {
4275         qemu_error_new(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4276         return;
4277     }
4278
4279     monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4280                    bdrv_get_encrypted_filename(bs));
4281
4282     mon->password_completion_cb = completion_cb;
4283     mon->password_opaque = opaque;
4284
4285     err = monitor_read_password(mon, bdrv_password_cb, bs);
4286
4287     if (err && completion_cb)
4288         completion_cb(opaque, err);
4289 }
4290
4291 typedef struct QemuErrorSink QemuErrorSink;
4292 struct QemuErrorSink {
4293     enum {
4294         ERR_SINK_FILE,
4295         ERR_SINK_MONITOR,
4296     } dest;
4297     union {
4298         FILE    *fp;
4299         Monitor *mon;
4300     };
4301     QemuErrorSink *previous;
4302 };
4303
4304 static QemuErrorSink *qemu_error_sink;
4305
4306 void qemu_errors_to_file(FILE *fp)
4307 {
4308     QemuErrorSink *sink;
4309
4310     sink = qemu_mallocz(sizeof(*sink));
4311     sink->dest = ERR_SINK_FILE;
4312     sink->fp = fp;
4313     sink->previous = qemu_error_sink;
4314     qemu_error_sink = sink;
4315 }
4316
4317 void qemu_errors_to_mon(Monitor *mon)
4318 {
4319     QemuErrorSink *sink;
4320
4321     sink = qemu_mallocz(sizeof(*sink));
4322     sink->dest = ERR_SINK_MONITOR;
4323     sink->mon = mon;
4324     sink->previous = qemu_error_sink;
4325     qemu_error_sink = sink;
4326 }
4327
4328 void qemu_errors_to_previous(void)
4329 {
4330     QemuErrorSink *sink;
4331
4332     assert(qemu_error_sink != NULL);
4333     sink = qemu_error_sink;
4334     qemu_error_sink = sink->previous;
4335     qemu_free(sink);
4336 }
4337
4338 void qemu_error(const char *fmt, ...)
4339 {
4340     va_list args;
4341
4342     assert(qemu_error_sink != NULL);
4343     switch (qemu_error_sink->dest) {
4344     case ERR_SINK_FILE:
4345         va_start(args, fmt);
4346         vfprintf(qemu_error_sink->fp, fmt, args);
4347         va_end(args);
4348         break;
4349     case ERR_SINK_MONITOR:
4350         va_start(args, fmt);
4351         monitor_vprintf(qemu_error_sink->mon, fmt, args);
4352         va_end(args);
4353         break;
4354     }
4355 }
4356
4357 void qemu_error_internal(const char *file, int linenr, const char *func,
4358                          const char *fmt, ...)
4359 {
4360     va_list va;
4361     QError *qerror;
4362
4363     assert(qemu_error_sink != NULL);
4364
4365     va_start(va, fmt);
4366     qerror = qerror_from_info(file, linenr, func, fmt, &va);
4367     va_end(va);
4368
4369     switch (qemu_error_sink->dest) {
4370     case ERR_SINK_FILE:
4371         qerror_print(qerror);
4372         QDECREF(qerror);
4373         break;
4374     case ERR_SINK_MONITOR:
4375         assert(qemu_error_sink->mon->error == NULL);
4376         qemu_error_sink->mon->error = qerror;
4377         break;
4378     }
4379 }