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