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
  25 #include "qemu/osdep.h"
  26 #include <dirent.h>
  27 #include "cpu.h"
  28 #include "hw/hw.h"
  29 #include "monitor/qdev.h"
  30 #include "hw/usb.h"
  31 #include "hw/pci/pci.h"
  32 #include "sysemu/watchdog.h"
  33 #include "hw/loader.h"
  34 #include "exec/gdbstub.h"
  35 #include "net/net.h"
  36 #include "net/slirp.h"
  37 #include "chardev/char-fe.h"
  38 #include "chardev/char-io.h"
  39 #include "chardev/char-mux.h"
  40 #include "ui/qemu-spice.h"
  41 #include "sysemu/numa.h"
  42 #include "monitor/monitor.h"
  43 #include "qemu/config-file.h"
  44 #include "qemu/readline.h"
  45 #include "ui/console.h"
  46 #include "ui/input.h"
  47 #include "sysemu/blockdev.h"
  48 #include "sysemu/block-backend.h"
  49 #include "audio/audio.h"
  50 #include "disas/disas.h"
  51 #include "sysemu/balloon.h"
  52 #include "qemu/timer.h"
  53 #include "sysemu/hw_accel.h"
  54 #include "qemu/acl.h"
  55 #include "sysemu/tpm.h"
  56 #include "qapi/qmp/qdict.h"
  57 #include "qapi/qmp/qerror.h"
  58 #include "qapi/qmp/qnum.h"
  59 #include "qapi/qmp/qstring.h"
  60 #include "qapi/qmp/qjson.h"
  61 #include "qapi/qmp/json-streamer.h"
  62 #include "qapi/qmp/json-parser.h"
  63 #include "qapi/qmp/qlist.h"
  64 #include "qom/object_interfaces.h"
  65 #include "trace-root.h"
  66 #include "trace/control.h"
  67 #include "monitor/hmp-target.h"
  68 #ifdef CONFIG_TRACE_SIMPLE
  69 #include "trace/simple.h"
  70 #endif
  71 #include "exec/memory.h"
  72 #include "exec/exec-all.h"
  73 #include "qemu/log.h"
  74 #include "qemu/option.h"
  75 #include "hmp.h"
  76 #include "qemu/thread.h"
  77 #include "block/qapi.h"
  78 #include "qapi/qapi-commands.h"
  79 #include "qapi/qapi-events.h"
  80 #include "qapi/error.h"
  81 #include "qapi/qmp-event.h"
  82 #include "qapi/qapi-introspect.h"
  83 #include "sysemu/qtest.h"
  84 #include "sysemu/cpus.h"
  85 #include "sysemu/iothread.h"
  86 #include "qemu/cutils.h"
  87
  88 #if defined(TARGET_S390X)
  89 #include "hw/s390x/storage-keys.h"
  90 #include "hw/s390x/storage-attributes.h"
  91 #endif
  92
  93 /*
  94  * Supported types:
  95  *
  96  * 'F'          filename
  97  * 'B'          block device name
  98  * 's'          string (accept optional quote)
  99  * 'S'          it just appends the rest of the string (accept optional quote)
 100  * 'O'          option string of the form NAME=VALUE,...
 101  *              parsed according to QemuOptsList given by its name
 102  *              Example: 'device:O' uses qemu_device_opts.
 103  *              Restriction: only lists with empty desc are supported
 104  *              TODO lift the restriction
 105  * 'i'          32 bit integer
 106  * 'l'          target long (32 or 64 bit)
 107  * 'M'          Non-negative target long (32 or 64 bit), in user mode the
 108  *              value is multiplied by 2^20 (think Mebibyte)
 109  * 'o'          octets (aka bytes)
 110  *              user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
 111  *              K, k suffix, which multiplies the value by 2^60 for suffixes E
 112  *              and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
 113  *              2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
 114  * 'T'          double
 115  *              user mode accepts an optional ms, us, ns suffix,
 116  *              which divides the value by 1e3, 1e6, 1e9, respectively
 117  * '/'          optional gdb-like print format (like "/10x")
 118  *
 119  * '?'          optional type (for all types, except '/')
 120  * '.'          other form of optional type (for 'i' and 'l')
 121  * 'b'          boolean
 122  *              user mode accepts "on" or "off"
 123  * '-'          optional parameter (eg. '-f')
 124  *
 125  */
 126
 127 typedef struct mon_cmd_t {
 128     const char *name;
 129     const char *args_type;
 130     const char *params;
 131     const char *help;
 132     void (*cmd)(Monitor *mon, const QDict *qdict);
 133     /* @sub_table is a list of 2nd level of commands. If it does not exist,
 134      * cmd should be used. If it exists, sub_table[?].cmd should be
 135      * used, and cmd of 1st level plays the role of help function.
 136      */
 137     struct mon_cmd_t *sub_table;
 138     void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
 139 } mon_cmd_t;
 140
 141 /* file descriptors passed via SCM_RIGHTS */
 142 typedef struct mon_fd_t mon_fd_t;
 143 struct mon_fd_t {
 144     char *name;
 145     int fd;
 146     QLIST_ENTRY(mon_fd_t) next;
 147 };
 148
 149 /* file descriptor associated with a file descriptor set */
 150 typedef struct MonFdsetFd MonFdsetFd;
 151 struct MonFdsetFd {
 152     int fd;
 153     bool removed;
 154     char *opaque;
 155     QLIST_ENTRY(MonFdsetFd) next;
 156 };
 157
 158 /* file descriptor set containing fds passed via SCM_RIGHTS */
 159 typedef struct MonFdset MonFdset;
 160 struct MonFdset {
 161     int64_t id;
 162     QLIST_HEAD(, MonFdsetFd) fds;
 163     QLIST_HEAD(, MonFdsetFd) dup_fds;
 164     QLIST_ENTRY(MonFdset) next;
 165 };
 166
 167 typedef struct {
 168     JSONMessageParser parser;
 169     /*
 170      * When a client connects, we're in capabilities negotiation mode.
 171      * When command qmp_capabilities succeeds, we go into command
 172      * mode.
 173      */
 174     QmpCommandList *commands;
 175     bool qmp_caps[QMP_CAPABILITY__MAX];
 176     /*
 177      * Protects qmp request/response queue.  Please take monitor_lock
 178      * first when used together.
 179      */
 180     QemuMutex qmp_queue_lock;
 181     /* Input queue that holds all the parsed QMP requests */
 182     GQueue *qmp_requests;
 183     /* Output queue contains all the QMP responses in order */
 184     GQueue *qmp_responses;
 185 } MonitorQMP;
 186
 187 /*
 188  * To prevent flooding clients, events can be throttled. The
 189  * throttling is calculated globally, rather than per-Monitor
 190  * instance.
 191  */
 192 typedef struct MonitorQAPIEventState {
 193     QAPIEvent event;    /* Throttling state for this event type and... */
 194     QDict *data;        /* ... data, see qapi_event_throttle_equal() */
 195     QEMUTimer *timer;   /* Timer for handling delayed events */
 196     QDict *qdict;       /* Delayed event (if any) */
 197 } MonitorQAPIEventState;
 198
 199 typedef struct {
 200     int64_t rate;       /* Minimum time (in ns) between two events */
 201 } MonitorQAPIEventConf;
 202
 203 struct Monitor {
 204     CharBackend chr;
 205     int reset_seen;
 206     int flags;
 207     int suspend_cnt;            /* Needs to be accessed atomically */
 208     bool skip_flush;
 209     bool use_io_thr;
 210
 211     /* We can't access guest memory when holding the lock */
 212     QemuMutex out_lock;
 213     QString *outbuf;
 214     guint out_watch;
 215
 216     /* Read under either BQL or out_lock, written with BQL+out_lock.  */
 217     int mux_out;
 218
 219     ReadLineState *rs;
 220     MonitorQMP qmp;
 221     gchar *mon_cpu_path;
 222     BlockCompletionFunc *password_completion_cb;
 223     void *password_opaque;
 224     mon_cmd_t *cmd_table;
 225     QLIST_HEAD(,mon_fd_t) fds;
 226     QTAILQ_ENTRY(Monitor) entry;
 227 };
 228
 229 /* Let's add monitor global variables to this struct. */
 230 static struct {
 231     IOThread *mon_iothread;
 232     /* Bottom half to dispatch the requests received from IO thread */
 233     QEMUBH *qmp_dispatcher_bh;
 234     /* Bottom half to deliver the responses back to clients */
 235     QEMUBH *qmp_respond_bh;
 236 } mon_global;
 237
 238 struct QMPRequest {
 239     /* Owner of the request */
 240     Monitor *mon;
 241     /* "id" field of the request */
 242     QObject *id;
 243     /* Request object to be handled */
 244     QObject *req;
 245     /*
 246      * Whether we need to resume the monitor afterward.  This flag is
 247      * used to emulate the old QMP server behavior that the current
 248      * command must be completed before execution of the next one.
 249      */
 250     bool need_resume;
 251 };
 252 typedef struct QMPRequest QMPRequest;
 253
 254 /* QMP checker flags */
 255 #define QMP_ACCEPT_UNKNOWNS 1
 256
 257 /* Protects mon_list, monitor_event_state.  */
 258 static QemuMutex monitor_lock;
 259
 260 static QTAILQ_HEAD(mon_list, Monitor) mon_list;
 261 static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
 262 static int mon_refcount;
 263
 264 static mon_cmd_t mon_cmds[];
 265 static mon_cmd_t info_cmds[];
 266
 267 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
 268
 269 Monitor *cur_mon;
 270
 271 static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
 272
 273 static void monitor_command_cb(void *opaque, const char *cmdline,
 274                                void *readline_opaque);
 275
 276 /**
 277  * Is @mon a QMP monitor?
 278  */
 279 static inline bool monitor_is_qmp(const Monitor *mon)
 280 {
 281     return (mon->flags & MONITOR_USE_CONTROL);
 282 }
 283
 284 /**
 285  * Whether @mon is using readline?  Note: not all HMP monitors use
 286  * readline, e.g., gdbserver has a non-interactive HMP monitor, so
 287  * readline is not used there.
 288  */
 289 static inline bool monitor_uses_readline(const Monitor *mon)
 290 {
 291     return mon->flags & MONITOR_USE_READLINE;
 292 }
 293
 294 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
 295 {
 296     return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
 297 }
 298
 299 /**
 300  * Is the current monitor, if any, a QMP monitor?
 301  */
 302 bool monitor_cur_is_qmp(void)
 303 {
 304     return cur_mon && monitor_is_qmp(cur_mon);
 305 }
 306
 307 void monitor_read_command(Monitor *mon, int show_prompt)
 308 {
 309     if (!mon->rs)
 310         return;
 311
 312     readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
 313     if (show_prompt)
 314         readline_show_prompt(mon->rs);
 315 }
 316
 317 int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
 318                           void *opaque)
 319 {
 320     if (mon->rs) {
 321         readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
 322         /* prompt is printed on return from the command handler */
 323         return 0;
 324     } else {
 325         monitor_printf(mon, "terminal does not support password prompting\n");
 326         return -ENOTTY;
 327     }
 328 }
 329
 330 static void qmp_request_free(QMPRequest *req)
 331 {
 332     qobject_unref(req->id);
 333     qobject_unref(req->req);
 334     g_free(req);
 335 }
 336
 337 /* Must with the mon->qmp.qmp_queue_lock held */
 338 static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
 339 {
 340     while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
 341         qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
 342     }
 343 }
 344
 345 /* Must with the mon->qmp.qmp_queue_lock held */
 346 static void monitor_qmp_cleanup_resp_queue_locked(Monitor *mon)
 347 {
 348     while (!g_queue_is_empty(mon->qmp.qmp_responses)) {
 349         qobject_unref((QObject *)g_queue_pop_head(mon->qmp.qmp_responses));
 350     }
 351 }
 352
 353 static void monitor_qmp_cleanup_queues(Monitor *mon)
 354 {
 355     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 356     monitor_qmp_cleanup_req_queue_locked(mon);
 357     monitor_qmp_cleanup_resp_queue_locked(mon);
 358     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 359 }
 360
 361
 362 static void monitor_flush_locked(Monitor *mon);
 363
 364 static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
 365                                   void *opaque)
 366 {
 367     Monitor *mon = opaque;
 368
 369     qemu_mutex_lock(&mon->out_lock);
 370     mon->out_watch = 0;
 371     monitor_flush_locked(mon);
 372     qemu_mutex_unlock(&mon->out_lock);
 373     return FALSE;
 374 }
 375
 376 /* Called with mon->out_lock held.  */
 377 static void monitor_flush_locked(Monitor *mon)
 378 {
 379     int rc;
 380     size_t len;
 381     const char *buf;
 382
 383     if (mon->skip_flush) {
 384         return;
 385     }
 386
 387     buf = qstring_get_str(mon->outbuf);
 388     len = qstring_get_length(mon->outbuf);
 389
 390     if (len && !mon->mux_out) {
 391         rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
 392         if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
 393             /* all flushed or error */
 394             qobject_unref(mon->outbuf);
 395             mon->outbuf = qstring_new();
 396             return;
 397         }
 398         if (rc > 0) {
 399             /* partial write */
 400             QString *tmp = qstring_from_str(buf + rc);
 401             qobject_unref(mon->outbuf);
 402             mon->outbuf = tmp;
 403         }
 404         if (mon->out_watch == 0) {
 405             mon->out_watch =
 406                 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
 407                                       monitor_unblocked, mon);
 408         }
 409     }
 410 }
 411
 412 void monitor_flush(Monitor *mon)
 413 {
 414     qemu_mutex_lock(&mon->out_lock);
 415     monitor_flush_locked(mon);
 416     qemu_mutex_unlock(&mon->out_lock);
 417 }
 418
 419 /* flush at every end of line */
 420 static void monitor_puts(Monitor *mon, const char *str)
 421 {
 422     char c;
 423
 424     qemu_mutex_lock(&mon->out_lock);
 425     for(;;) {
 426         c = *str++;
 427         if (c == '\0')
 428             break;
 429         if (c == '\n') {
 430             qstring_append_chr(mon->outbuf, '\r');
 431         }
 432         qstring_append_chr(mon->outbuf, c);
 433         if (c == '\n') {
 434             monitor_flush_locked(mon);
 435         }
 436     }
 437     qemu_mutex_unlock(&mon->out_lock);
 438 }
 439
 440 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
 441 {
 442     char *buf;
 443
 444     if (!mon)
 445         return;
 446
 447     if (monitor_is_qmp(mon)) {
 448         return;
 449     }
 450
 451     buf = g_strdup_vprintf(fmt, ap);
 452     monitor_puts(mon, buf);
 453     g_free(buf);
 454 }
 455
 456 void monitor_printf(Monitor *mon, const char *fmt, ...)
 457 {
 458     va_list ap;
 459     va_start(ap, fmt);
 460     monitor_vprintf(mon, fmt, ap);
 461     va_end(ap);
 462 }
 463
 464 int monitor_fprintf(FILE *stream, const char *fmt, ...)
 465 {
 466     va_list ap;
 467     va_start(ap, fmt);
 468     monitor_vprintf((Monitor *)stream, fmt, ap);
 469     va_end(ap);
 470     return 0;
 471 }
 472
 473 static void monitor_json_emitter_raw(Monitor *mon,
 474                                      QObject *data)
 475 {
 476     QString *json;
 477
 478     json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
 479                                              qobject_to_json(data);
 480     assert(json != NULL);
 481
 482     qstring_append_chr(json, '\n');
 483     monitor_puts(mon, qstring_get_str(json));
 484
 485     qobject_unref(json);
 486 }
 487
 488 static void monitor_json_emitter(Monitor *mon, QObject *data)
 489 {
 490     if (mon->use_io_thr) {
 491         /*
 492          * If using IO thread, we need to queue the item so that IO
 493          * thread will do the rest for us.  Take refcount so that
 494          * caller won't free the data (which will be finally freed in
 495          * responder thread).
 496          */
 497         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 498         g_queue_push_tail(mon->qmp.qmp_responses, qobject_ref(data));
 499         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 500         qemu_bh_schedule(mon_global.qmp_respond_bh);
 501     } else {
 502         /*
 503          * If not using monitor IO thread, then we are in main thread.
 504          * Do the emission right away.
 505          */
 506         monitor_json_emitter_raw(mon, data);
 507     }
 508 }
 509
 510 struct QMPResponse {
 511     Monitor *mon;
 512     QObject *data;
 513 };
 514 typedef struct QMPResponse QMPResponse;
 515
 516 /*
 517  * Return one QMPResponse.  The response is only valid if
 518  * response.data is not NULL.
 519  */
 520 static QMPResponse monitor_qmp_response_pop_one(void)
 521 {
 522     Monitor *mon;
 523     QObject *data = NULL;
 524
 525     qemu_mutex_lock(&monitor_lock);
 526     QTAILQ_FOREACH(mon, &mon_list, entry) {
 527         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
 528         data = g_queue_pop_head(mon->qmp.qmp_responses);
 529         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
 530         if (data) {
 531             break;
 532         }
 533     }
 534     qemu_mutex_unlock(&monitor_lock);
 535     return (QMPResponse) { .mon = mon, .data = data };
 536 }
 537
 538 static void monitor_qmp_bh_responder(void *opaque)
 539 {
 540     QMPResponse response;
 541
 542     while (true) {
 543         response = monitor_qmp_response_pop_one();
 544         if (!response.data) {
 545             break;
 546         }
 547         monitor_json_emitter_raw(response.mon, response.data);
 548         qobject_unref(response.data);
 549     }
 550 }
 551
 552 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
 553     /* Limit guest-triggerable events to 1 per second */
 554     [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
 555     [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
 556     [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
 557     [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
 558     [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
 559     [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
 560 };
 561
 562 GHashTable *monitor_qapi_event_state;
 563
 564 /*
 565  * Emits the event to every monitor instance, @event is only used for trace
 566  * Called with monitor_lock held.
 567  */
 568 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
 569 {
 570     Monitor *mon;
 571
 572     trace_monitor_protocol_event_emit(event, qdict);
 573     QTAILQ_FOREACH(mon, &mon_list, entry) {
 574         if (monitor_is_qmp(mon)
 575             && mon->qmp.commands != &qmp_cap_negotiation_commands) {
 576             monitor_json_emitter(mon, QOBJECT(qdict));
 577         }
 578     }
 579 }
 580
 581 static void monitor_qapi_event_handler(void *opaque);
 582
 583 /*
 584  * Queue a new event for emission to Monitor instances,
 585  * applying any rate limiting if required.
 586  */
 587 static void
 588 monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
 589 {
 590     MonitorQAPIEventConf *evconf;
 591     MonitorQAPIEventState *evstate;
 592
 593     assert(event < QAPI_EVENT__MAX);
 594     evconf = &monitor_qapi_event_conf[event];
 595     trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
 596
 597     qemu_mutex_lock(&monitor_lock);
 598
 599     if (!evconf->rate) {
 600         /* Unthrottled event */
 601         monitor_qapi_event_emit(event, qdict);
 602     } else {
 603         QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
 604         MonitorQAPIEventState key = { .event = event, .data = data };
 605
 606         evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
 607         assert(!evstate || timer_pending(evstate->timer));
 608
 609         if (evstate) {
 610             /*
 611              * Timer is pending for (at least) evconf->rate ns after
 612              * last send.  Store event for sending when timer fires,
 613              * replacing a prior stored event if any.
 614              */
 615             qobject_unref(evstate->qdict);
 616             evstate->qdict = qobject_ref(qdict);
 617         } else {
 618             /*
 619              * Last send was (at least) evconf->rate ns ago.
 620              * Send immediately, and arm the timer to call
 621              * monitor_qapi_event_handler() in evconf->rate ns.  Any
 622              * events arriving before then will be delayed until then.
 623              */
 624             int64_t now = qemu_clock_get_ns(event_clock_type);
 625
 626             monitor_qapi_event_emit(event, qdict);
 627
 628             evstate = g_new(MonitorQAPIEventState, 1);
 629             evstate->event = event;
 630             evstate->data = qobject_ref(data);
 631             evstate->qdict = NULL;
 632             evstate->timer = timer_new_ns(event_clock_type,
 633                                           monitor_qapi_event_handler,
 634                                           evstate);
 635             g_hash_table_add(monitor_qapi_event_state, evstate);
 636             timer_mod_ns(evstate->timer, now + evconf->rate);
 637         }
 638     }
 639
 640     qemu_mutex_unlock(&monitor_lock);
 641 }
 642
 643 /*
 644  * This function runs evconf->rate ns after sending a throttled
 645  * event.
 646  * If another event has since been stored, send it.
 647  */
 648 static void monitor_qapi_event_handler(void *opaque)
 649 {
 650     MonitorQAPIEventState *evstate = opaque;
 651     MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
 652
 653     trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
 654     qemu_mutex_lock(&monitor_lock);
 655
 656     if (evstate->qdict) {
 657         int64_t now = qemu_clock_get_ns(event_clock_type);
 658
 659         monitor_qapi_event_emit(evstate->event, evstate->qdict);
 660         qobject_unref(evstate->qdict);
 661         evstate->qdict = NULL;
 662         timer_mod_ns(evstate->timer, now + evconf->rate);
 663     } else {
 664         g_hash_table_remove(monitor_qapi_event_state, evstate);
 665         qobject_unref(evstate->data);
 666         timer_free(evstate->timer);
 667         g_free(evstate);
 668     }
 669
 670     qemu_mutex_unlock(&monitor_lock);
 671 }
 672
 673 static unsigned int qapi_event_throttle_hash(const void *key)
 674 {
 675     const MonitorQAPIEventState *evstate = key;
 676     unsigned int hash = evstate->event * 255;
 677
 678     if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
 679         hash += g_str_hash(qdict_get_str(evstate->data, "id"));
 680     }
 681
 682     if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 683         hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
 684     }
 685
 686     return hash;
 687 }
 688
 689 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
 690 {
 691     const MonitorQAPIEventState *eva = a;
 692     const MonitorQAPIEventState *evb = b;
 693
 694     if (eva->event != evb->event) {
 695         return FALSE;
 696     }
 697
 698     if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
 699         return !strcmp(qdict_get_str(eva->data, "id"),
 700                        qdict_get_str(evb->data, "id"));
 701     }
 702
 703     if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
 704         return !strcmp(qdict_get_str(eva->data, "node-name"),
 705                        qdict_get_str(evb->data, "node-name"));
 706     }
 707
 708     return TRUE;
 709 }
 710
 711 static void monitor_qapi_event_init(void)
 712 {
 713     if (qtest_enabled()) {
 714         event_clock_type = QEMU_CLOCK_VIRTUAL;
 715     }
 716
 717     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
 718                                                 qapi_event_throttle_equal);
 719     qmp_event_set_func_emit(monitor_qapi_event_queue);
 720 }
 721
 722 static void handle_hmp_command(Monitor *mon, const char *cmdline);
 723
 724 static void monitor_data_init(Monitor *mon, bool skip_flush,
 725                               bool use_io_thr)
 726 {
 727     memset(mon, 0, sizeof(Monitor));
 728     qemu_mutex_init(&mon->out_lock);
 729     qemu_mutex_init(&mon->qmp.qmp_queue_lock);
 730     mon->outbuf = qstring_new();
 731     /* Use *mon_cmds by default. */
 732     mon->cmd_table = mon_cmds;
 733     mon->skip_flush = skip_flush;
 734     mon->use_io_thr = use_io_thr;
 735     mon->qmp.qmp_requests = g_queue_new();
 736     mon->qmp.qmp_responses = g_queue_new();
 737 }
 738
 739 static void monitor_data_destroy(Monitor *mon)
 740 {
 741     g_free(mon->mon_cpu_path);
 742     qemu_chr_fe_deinit(&mon->chr, false);
 743     if (monitor_is_qmp(mon)) {
 744         json_message_parser_destroy(&mon->qmp.parser);
 745     }
 746     readline_free(mon->rs);
 747     qobject_unref(mon->outbuf);
 748     qemu_mutex_destroy(&mon->out_lock);
 749     qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
 750     monitor_qmp_cleanup_req_queue_locked(mon);
 751     monitor_qmp_cleanup_resp_queue_locked(mon);
 752     g_queue_free(mon->qmp.qmp_requests);
 753     g_queue_free(mon->qmp.qmp_responses);
 754 }
 755
 756 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
 757                                 int64_t cpu_index, Error **errp)
 758 {
 759     char *output = NULL;
 760     Monitor *old_mon, hmp;
 761
 762     monitor_data_init(&hmp, true, false);
 763
 764     old_mon = cur_mon;
 765     cur_mon = &hmp;
 766
 767     if (has_cpu_index) {
 768         int ret = monitor_set_cpu(cpu_index);
 769         if (ret < 0) {
 770             cur_mon = old_mon;
 771             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
 772                        "a CPU number");
 773             goto out;
 774         }
 775     }
 776
 777     handle_hmp_command(&hmp, command_line);
 778     cur_mon = old_mon;
 779
 780     qemu_mutex_lock(&hmp.out_lock);
 781     if (qstring_get_length(hmp.outbuf) > 0) {
 782         output = g_strdup(qstring_get_str(hmp.outbuf));
 783     } else {
 784         output = g_strdup("");
 785     }
 786     qemu_mutex_unlock(&hmp.out_lock);
 787
 788 out:
 789     monitor_data_destroy(&hmp);
 790     return output;
 791 }
 792
 793 static int compare_cmd(const char *name, const char *list)
 794 {
 795     const char *p, *pstart;
 796     int len;
 797     len = strlen(name);
 798     p = list;
 799     for(;;) {
 800         pstart = p;
 801         p = strchr(p, '|');
 802         if (!p)
 803             p = pstart + strlen(pstart);
 804         if ((p - pstart) == len && !memcmp(pstart, name, len))
 805             return 1;
 806         if (*p == '\0')
 807             break;
 808         p++;
 809     }
 810     return 0;
 811 }
 812
 813 static int get_str(char *buf, int buf_size, const char **pp)
 814 {
 815     const char *p;
 816     char *q;
 817     int c;
 818
 819     q = buf;
 820     p = *pp;
 821     while (qemu_isspace(*p)) {
 822         p++;
 823     }
 824     if (*p == '\0') {
 825     fail:
 826         *q = '\0';
 827         *pp = p;
 828         return -1;
 829     }
 830     if (*p == '\"') {
 831         p++;
 832         while (*p != '\0' && *p != '\"') {
 833             if (*p == '\\') {
 834                 p++;
 835                 c = *p++;
 836                 switch (c) {
 837                 case 'n':
 838                     c = '\n';
 839                     break;
 840                 case 'r':
 841                     c = '\r';
 842                     break;
 843                 case '\\':
 844                 case '\'':
 845                 case '\"':
 846                     break;
 847                 default:
 848                     printf("unsupported escape code: '\\%c'\n", c);
 849                     goto fail;
 850                 }
 851                 if ((q - buf) < buf_size - 1) {
 852                     *q++ = c;
 853                 }
 854             } else {
 855                 if ((q - buf) < buf_size - 1) {
 856                     *q++ = *p;
 857                 }
 858                 p++;
 859             }
 860         }
 861         if (*p != '\"') {
 862             printf("unterminated string\n");
 863             goto fail;
 864         }
 865         p++;
 866     } else {
 867         while (*p != '\0' && !qemu_isspace(*p)) {
 868             if ((q - buf) < buf_size - 1) {
 869                 *q++ = *p;
 870             }
 871             p++;
 872         }
 873     }
 874     *q = '\0';
 875     *pp = p;
 876     return 0;
 877 }
 878
 879 #define MAX_ARGS 16
 880
 881 static void free_cmdline_args(char **args, int nb_args)
 882 {
 883     int i;
 884
 885     assert(nb_args <= MAX_ARGS);
 886
 887     for (i = 0; i < nb_args; i++) {
 888         g_free(args[i]);
 889     }
 890
 891 }
 892
 893 /*
 894  * Parse the command line to get valid args.
 895  * @cmdline: command line to be parsed.
 896  * @pnb_args: location to store the number of args, must NOT be NULL.
 897  * @args: location to store the args, which should be freed by caller, must
 898  *        NOT be NULL.
 899  *
 900  * Returns 0 on success, negative on failure.
 901  *
 902  * NOTE: this parser is an approximate form of the real command parser. Number
 903  *       of args have a limit of MAX_ARGS. If cmdline contains more, it will
 904  *       return with failure.
 905  */
 906 static int parse_cmdline(const char *cmdline,
 907                          int *pnb_args, char **args)
 908 {
 909     const char *p;
 910     int nb_args, ret;
 911     char buf[1024];
 912
 913     p = cmdline;
 914     nb_args = 0;
 915     for (;;) {
 916         while (qemu_isspace(*p)) {
 917             p++;
 918         }
 919         if (*p == '\0') {
 920             break;
 921         }
 922         if (nb_args >= MAX_ARGS) {
 923             goto fail;
 924         }
 925         ret = get_str(buf, sizeof(buf), &p);
 926         if (ret < 0) {
 927             goto fail;
 928         }
 929         args[nb_args] = g_strdup(buf);
 930         nb_args++;
 931     }
 932     *pnb_args = nb_args;
 933     return 0;
 934
 935  fail:
 936     free_cmdline_args(args, nb_args);
 937     return -1;
 938 }
 939
 940 static void help_cmd_dump_one(Monitor *mon,
 941                               const mon_cmd_t *cmd,
 942                               char **prefix_args,
 943                               int prefix_args_nb)
 944 {
 945     int i;
 946
 947     for (i = 0; i < prefix_args_nb; i++) {
 948         monitor_printf(mon, "%s ", prefix_args[i]);
 949     }
 950     monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
 951 }
 952
 953 /* @args[@arg_index] is the valid command need to find in @cmds */
 954 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
 955                           char **args, int nb_args, int arg_index)
 956 {
 957     const mon_cmd_t *cmd;
 958
 959     /* No valid arg need to compare with, dump all in *cmds */
 960     if (arg_index >= nb_args) {
 961         for (cmd = cmds; cmd->name != NULL; cmd++) {
 962             help_cmd_dump_one(mon, cmd, args, arg_index);
 963         }
 964         return;
 965     }
 966
 967     /* Find one entry to dump */
 968     for (cmd = cmds; cmd->name != NULL; cmd++) {
 969         if (compare_cmd(args[arg_index], cmd->name)) {
 970             if (cmd->sub_table) {
 971                 /* continue with next arg */
 972                 help_cmd_dump(mon, cmd->sub_table,
 973                               args, nb_args, arg_index + 1);
 974             } else {
 975                 help_cmd_dump_one(mon, cmd, args, arg_index);
 976             }
 977             break;
 978         }
 979     }
 980 }
 981
 982 static void help_cmd(Monitor *mon, const char *name)
 983 {
 984     char *args[MAX_ARGS];
 985     int nb_args = 0;
 986
 987     /* 1. parse user input */
 988     if (name) {
 989         /* special case for log, directly dump and return */
 990         if (!strcmp(name, "log")) {
 991             const QEMULogItem *item;
 992             monitor_printf(mon, "Log items (comma separated):\n");
 993             monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
 994             for (item = qemu_log_items; item->mask != 0; item++) {
 995                 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
 996             }
 997             return;
 998         }
 999
1000         if (parse_cmdline(name, &nb_args, args) < 0) {
1001             return;
1002         }
1003     }
1004
1005     /* 2. dump the contents according to parsed args */
1006     help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1007
1008     free_cmdline_args(args, nb_args);
1009 }
1010
1011 static void do_help_cmd(Monitor *mon, const QDict *qdict)
1012 {
1013     help_cmd(mon, qdict_get_try_str(qdict, "name"));
1014 }
1015
1016 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1017 {
1018     const char *tp_name = qdict_get_str(qdict, "name");
1019     bool new_state = qdict_get_bool(qdict, "option");
1020     bool has_vcpu = qdict_haskey(qdict, "vcpu");
1021     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1022     Error *local_err = NULL;
1023
1024     if (vcpu < 0) {
1025         monitor_printf(mon, "argument vcpu must be positive");
1026         return;
1027     }
1028
1029     qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1030     if (local_err) {
1031         error_report_err(local_err);
1032     }
1033 }
1034
1035 #ifdef CONFIG_TRACE_SIMPLE
1036 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1037 {
1038     const char *op = qdict_get_try_str(qdict, "op");
1039     const char *arg = qdict_get_try_str(qdict, "arg");
1040
1041     if (!op) {
1042         st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1043     } else if (!strcmp(op, "on")) {
1044         st_set_trace_file_enabled(true);
1045     } else if (!strcmp(op, "off")) {
1046         st_set_trace_file_enabled(false);
1047     } else if (!strcmp(op, "flush")) {
1048         st_flush_trace_buffer();
1049     } else if (!strcmp(op, "set")) {
1050         if (arg) {
1051             st_set_trace_file(arg);
1052         }
1053     } else {
1054         monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1055         help_cmd(mon, "trace-file");
1056     }
1057 }
1058 #endif
1059
1060 static void hmp_info_help(Monitor *mon, const QDict *qdict)
1061 {
1062     help_cmd(mon, "info");
1063 }
1064
1065 static void query_commands_cb(QmpCommand *cmd, void *opaque)
1066 {
1067     CommandInfoList *info, **list = opaque;
1068
1069     if (!cmd->enabled) {
1070         return;
1071     }
1072
1073     info = g_malloc0(sizeof(*info));
1074     info->value = g_malloc0(sizeof(*info->value));
1075     info->value->name = g_strdup(cmd->name);
1076     info->next = *list;
1077     *list = info;
1078 }
1079
1080 CommandInfoList *qmp_query_commands(Error **errp)
1081 {
1082     CommandInfoList *list = NULL;
1083
1084     qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1085
1086     return list;
1087 }
1088
1089 EventInfoList *qmp_query_events(Error **errp)
1090 {
1091     EventInfoList *info, *ev_list = NULL;
1092     QAPIEvent e;
1093
1094     for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1095         const char *event_name = QAPIEvent_str(e);
1096         assert(event_name != NULL);
1097         info = g_malloc0(sizeof(*info));
1098         info->value = g_malloc0(sizeof(*info->value));
1099         info->value->name = g_strdup(event_name);
1100
1101         info->next = ev_list;
1102         ev_list = info;
1103     }
1104
1105     return ev_list;
1106 }
1107
1108 /*
1109  * Minor hack: generated marshalling suppressed for this command
1110  * ('gen': false in the schema) so we can parse the JSON string
1111  * directly into QObject instead of first parsing it with
1112  * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
1113  * to QObject with generated output marshallers, every time.  Instead,
1114  * we do it in test-qobject-input-visitor.c, just to make sure
1115  * qapi-gen.py's output actually conforms to the schema.
1116  */
1117 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1118                                  Error **errp)
1119 {
1120     *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1121 }
1122
1123 /*
1124  * We used to define commands in qmp-commands.hx in addition to the
1125  * QAPI schema.  This permitted defining some of them only in certain
1126  * configurations.  query-commands has always reflected that (good,
1127  * because it lets QMP clients figure out what's actually available),
1128  * while query-qmp-schema never did (not so good).  This function is a
1129  * hack to keep the configuration-specific commands defined exactly as
1130  * before, even though qmp-commands.hx is gone.
1131  *
1132  * FIXME Educate the QAPI schema on configuration-specific commands,
1133  * and drop this hack.
1134  */
1135 static void qmp_unregister_commands_hack(void)
1136 {
1137 #ifndef CONFIG_SPICE
1138     qmp_unregister_command(&qmp_commands, "query-spice");
1139 #endif
1140 #ifndef CONFIG_REPLICATION
1141     qmp_unregister_command(&qmp_commands, "xen-set-replication");
1142     qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1143     qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1144 #endif
1145 #ifndef TARGET_I386
1146     qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1147     qmp_unregister_command(&qmp_commands, "query-sev");
1148     qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1149     qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1150 #endif
1151 #ifndef TARGET_S390X
1152     qmp_unregister_command(&qmp_commands, "dump-skeys");
1153 #endif
1154 #ifndef TARGET_ARM
1155     qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1156 #endif
1157 #if !defined(TARGET_S390X) && !defined(TARGET_I386)
1158     qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1159 #endif
1160 #if !defined(TARGET_S390X)
1161     qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1162     qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1163 #endif
1164 #if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1165     && !defined(TARGET_S390X)
1166     qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1167 #endif
1168 }
1169
1170 static void monitor_init_qmp_commands(void)
1171 {
1172     /*
1173      * Two command lists:
1174      * - qmp_commands contains all QMP commands
1175      * - qmp_cap_negotiation_commands contains just
1176      *   "qmp_capabilities", to enforce capability negotiation
1177      */
1178
1179     qmp_init_marshal(&qmp_commands);
1180
1181     qmp_register_command(&qmp_commands, "query-qmp-schema",
1182                          qmp_query_qmp_schema,
1183                          QCO_NO_OPTIONS);
1184     qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1185                          QCO_NO_OPTIONS);
1186     qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1187                          QCO_NO_OPTIONS);
1188
1189     qmp_unregister_commands_hack();
1190
1191     QTAILQ_INIT(&qmp_cap_negotiation_commands);
1192     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1193                          qmp_marshal_qmp_capabilities, QCO_NO_OPTIONS);
1194 }
1195
1196 static bool qmp_cap_enabled(Monitor *mon, QMPCapability cap)
1197 {
1198     return mon->qmp.qmp_caps[cap];
1199 }
1200
1201 static bool qmp_oob_enabled(Monitor *mon)
1202 {
1203     return qmp_cap_enabled(mon, QMP_CAPABILITY_OOB);
1204 }
1205
1206 static void qmp_caps_check(Monitor *mon, QMPCapabilityList *list,
1207                            Error **errp)
1208 {
1209     for (; list; list = list->next) {
1210         assert(list->value < QMP_CAPABILITY__MAX);
1211         switch (list->value) {
1212         case QMP_CAPABILITY_OOB:
1213             if (!mon->use_io_thr) {
1214                 /*
1215                  * Out-Of-Band only works with monitors that are
1216                  * running on dedicated IOThread.
1217                  */
1218                 error_setg(errp, "This monitor does not support "
1219                            "Out-Of-Band (OOB)");
1220                 return;
1221             }
1222             break;
1223         default:
1224             break;
1225         }
1226     }
1227 }
1228
1229 /* This function should only be called after capabilities are checked. */
1230 static void qmp_caps_apply(Monitor *mon, QMPCapabilityList *list)
1231 {
1232     for (; list; list = list->next) {
1233         mon->qmp.qmp_caps[list->value] = true;
1234     }
1235 }
1236
1237 /*
1238  * Return true if check successful, or false otherwise.  When false is
1239  * returned, detailed error will be in errp if provided.
1240  */
1241 static bool qmp_cmd_oob_check(Monitor *mon, QDict *req, Error **errp)
1242 {
1243     const char *command;
1244     QmpCommand *cmd;
1245
1246     command = qdict_get_try_str(req, "execute");
1247     if (!command) {
1248         error_setg(errp, "Command field 'execute' missing");
1249         return false;
1250     }
1251
1252     cmd = qmp_find_command(mon->qmp.commands, command);
1253     if (!cmd) {
1254         if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
1255             error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1256                       "Expecting capabilities negotiation "
1257                       "with 'qmp_capabilities'");
1258         } else {
1259             error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1260                       "The command %s has not been found", command);
1261         }
1262         return false;
1263     }
1264
1265     if (qmp_is_oob(req)) {
1266         if (!qmp_oob_enabled(mon)) {
1267             error_setg(errp, "Please enable Out-Of-Band first "
1268                        "for the session during capabilities negotiation");
1269             return false;
1270         }
1271         if (!(cmd->options & QCO_ALLOW_OOB)) {
1272             error_setg(errp, "The command %s does not support OOB",
1273                        command);
1274             return false;
1275         }
1276     }
1277
1278     return true;
1279 }
1280
1281 void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1282                           Error **errp)
1283 {
1284     Error *local_err = NULL;
1285
1286     if (cur_mon->qmp.commands == &qmp_commands) {
1287         error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1288                   "Capabilities negotiation is already complete, command "
1289                   "ignored");
1290         return;
1291     }
1292
1293     /* Enable QMP capabilities provided by the client if applicable. */
1294     if (has_enable) {
1295         qmp_caps_check(cur_mon, enable, &local_err);
1296         if (local_err) {
1297             /*
1298              * Failed check on any of the capabilities will fail the
1299              * entire command (and thus not apply any of the other
1300              * capabilities that were also requested).
1301              */
1302             error_propagate(errp, local_err);
1303             return;
1304         }
1305         qmp_caps_apply(cur_mon, enable);
1306     }
1307
1308     cur_mon->qmp.commands = &qmp_commands;
1309 }
1310
1311 /* set the current CPU defined by the user */
1312 int monitor_set_cpu(int cpu_index)
1313 {
1314     CPUState *cpu;
1315
1316     cpu = qemu_get_cpu(cpu_index);
1317     if (cpu == NULL) {
1318         return -1;
1319     }
1320     g_free(cur_mon->mon_cpu_path);
1321     cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1322     return 0;
1323 }
1324
1325 static CPUState *mon_get_cpu_sync(bool synchronize)
1326 {
1327     CPUState *cpu;
1328
1329     if (cur_mon->mon_cpu_path) {
1330         cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1331                                                     TYPE_CPU, NULL);
1332         if (!cpu) {
1333             g_free(cur_mon->mon_cpu_path);
1334             cur_mon->mon_cpu_path = NULL;
1335         }
1336     }
1337     if (!cur_mon->mon_cpu_path) {
1338         if (!first_cpu) {
1339             return NULL;
1340         }
1341         monitor_set_cpu(first_cpu->cpu_index);
1342         cpu = first_cpu;
1343     }
1344     if (synchronize) {
1345         cpu_synchronize_state(cpu);
1346     }
1347     return cpu;
1348 }
1349
1350 CPUState *mon_get_cpu(void)
1351 {
1352     return mon_get_cpu_sync(true);
1353 }
1354
1355 CPUArchState *mon_get_cpu_env(void)
1356 {
1357     CPUState *cs = mon_get_cpu();
1358
1359     return cs ? cs->env_ptr : NULL;
1360 }
1361
1362 int monitor_get_cpu_index(void)
1363 {
1364     CPUState *cs = mon_get_cpu_sync(false);
1365
1366     return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1367 }
1368
1369 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1370 {
1371     bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1372     CPUState *cs;
1373
1374     if (all_cpus) {
1375         CPU_FOREACH(cs) {
1376             monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1377             cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1378         }
1379     } else {
1380         cs = mon_get_cpu();
1381
1382         if (!cs) {
1383             monitor_printf(mon, "No CPU available\n");
1384             return;
1385         }
1386
1387         cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1388     }
1389 }
1390
1391 #ifdef CONFIG_TCG
1392 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1393 {
1394     if (!tcg_enabled()) {
1395         error_report("JIT information is only available with accel=tcg");
1396         return;
1397     }
1398
1399     dump_exec_info((FILE *)mon, monitor_fprintf);
1400     dump_drift_info((FILE *)mon, monitor_fprintf);
1401 }
1402
1403 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1404 {
1405     dump_opcount_info((FILE *)mon, monitor_fprintf);
1406 }
1407 #endif
1408
1409 static void hmp_info_history(Monitor *mon, const QDict *qdict)
1410 {
1411     int i;
1412     const char *str;
1413
1414     if (!mon->rs)
1415         return;
1416     i = 0;
1417     for(;;) {
1418         str = readline_get_history(mon->rs, i);
1419         if (!str)
1420             break;
1421         monitor_printf(mon, "%d: '%s'\n", i, str);
1422         i++;
1423     }
1424 }
1425
1426 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1427 {
1428     CPUState *cs = mon_get_cpu();
1429
1430     if (!cs) {
1431         monitor_printf(mon, "No CPU available\n");
1432         return;
1433     }
1434     cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1435 }
1436
1437 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1438 {
1439     const char *name = qdict_get_try_str(qdict, "name");
1440     bool has_vcpu = qdict_haskey(qdict, "vcpu");
1441     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1442     TraceEventInfoList *events;
1443     TraceEventInfoList *elem;
1444     Error *local_err = NULL;
1445
1446     if (name == NULL) {
1447         name = "*";
1448     }
1449     if (vcpu < 0) {
1450         monitor_printf(mon, "argument vcpu must be positive");
1451         return;
1452     }
1453
1454     events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1455     if (local_err) {
1456         error_report_err(local_err);
1457         return;
1458     }
1459
1460     for (elem = events; elem != NULL; elem = elem->next) {
1461         monitor_printf(mon, "%s : state %u\n",
1462                        elem->value->name,
1463                        elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1464     }
1465     qapi_free_TraceEventInfoList(events);
1466 }
1467
1468 void qmp_client_migrate_info(const char *protocol, const char *hostname,
1469                              bool has_port, int64_t port,
1470                              bool has_tls_port, int64_t tls_port,
1471                              bool has_cert_subject, const char *cert_subject,
1472                              Error **errp)
1473 {
1474     if (strcmp(protocol, "spice") == 0) {
1475         if (!qemu_using_spice(errp)) {
1476             return;
1477         }
1478
1479         if (!has_port && !has_tls_port) {
1480             error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1481             return;
1482         }
1483
1484         if (qemu_spice_migrate_info(hostname,
1485                                     has_port ? port : -1,
1486                                     has_tls_port ? tls_port : -1,
1487                                     cert_subject)) {
1488             error_setg(errp, QERR_UNDEFINED_ERROR);
1489             return;
1490         }
1491         return;
1492     }
1493
1494     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1495 }
1496
1497 static void hmp_logfile(Monitor *mon, const QDict *qdict)
1498 {
1499     Error *err = NULL;
1500
1501     qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1502     if (err) {
1503         error_report_err(err);
1504     }
1505 }
1506
1507 static void hmp_log(Monitor *mon, const QDict *qdict)
1508 {
1509     int mask;
1510     const char *items = qdict_get_str(qdict, "items");
1511
1512     if (!strcmp(items, "none")) {
1513         mask = 0;
1514     } else {
1515         mask = qemu_str_to_log_mask(items);
1516         if (!mask) {
1517             help_cmd(mon, "log");
1518             return;
1519         }
1520     }
1521     qemu_set_log(mask);
1522 }
1523
1524 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1525 {
1526     const char *option = qdict_get_try_str(qdict, "option");
1527     if (!option || !strcmp(option, "on")) {
1528         singlestep = 1;
1529     } else if (!strcmp(option, "off")) {
1530         singlestep = 0;
1531     } else {
1532         monitor_printf(mon, "unexpected option %s\n", option);
1533     }
1534 }
1535
1536 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1537 {
1538     const char *device = qdict_get_try_str(qdict, "device");
1539     if (!device)
1540         device = "tcp::" DEFAULT_GDBSTUB_PORT;
1541     if (gdbserver_start(device) < 0) {
1542         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1543                        device);
1544     } else if (strcmp(device, "none") == 0) {
1545         monitor_printf(mon, "Disabled gdbserver\n");
1546     } else {
1547         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1548                        device);
1549     }
1550 }
1551
1552 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1553 {
1554     const char *action = qdict_get_str(qdict, "action");
1555     if (select_watchdog_action(action) == -1) {
1556         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1557     }
1558 }
1559
1560 static void monitor_printc(Monitor *mon, int c)
1561 {
1562     monitor_printf(mon, "'");
1563     switch(c) {
1564     case '\'':
1565         monitor_printf(mon, "\\'");
1566         break;
1567     case '\\':
1568         monitor_printf(mon, "\\\\");
1569         break;
1570     case '\n':
1571         monitor_printf(mon, "\\n");
1572         break;
1573     case '\r':
1574         monitor_printf(mon, "\\r");
1575         break;
1576     default:
1577         if (c >= 32 && c <= 126) {
1578             monitor_printf(mon, "%c", c);
1579         } else {
1580             monitor_printf(mon, "\\x%02x", c);
1581         }
1582         break;
1583     }
1584     monitor_printf(mon, "'");
1585 }
1586
1587 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1588                         hwaddr addr, int is_physical)
1589 {
1590     int l, line_size, i, max_digits, len;
1591     uint8_t buf[16];
1592     uint64_t v;
1593     CPUState *cs = mon_get_cpu();
1594
1595     if (!cs && (format == 'i' || !is_physical)) {
1596         monitor_printf(mon, "Can not dump without CPU\n");
1597         return;
1598     }
1599
1600     if (format == 'i') {
1601         monitor_disas(mon, cs, addr, count, is_physical);
1602         return;
1603     }
1604
1605     len = wsize * count;
1606     if (wsize == 1)
1607         line_size = 8;
1608     else
1609         line_size = 16;
1610     max_digits = 0;
1611
1612     switch(format) {
1613     case 'o':
1614         max_digits = DIV_ROUND_UP(wsize * 8, 3);
1615         break;
1616     default:
1617     case 'x':
1618         max_digits = (wsize * 8) / 4;
1619         break;
1620     case 'u':
1621     case 'd':
1622         max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1623         break;
1624     case 'c':
1625         wsize = 1;
1626         break;
1627     }
1628
1629     while (len > 0) {
1630         if (is_physical)
1631             monitor_printf(mon, TARGET_FMT_plx ":", addr);
1632         else
1633             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1634         l = len;
1635         if (l > line_size)
1636             l = line_size;
1637         if (is_physical) {
1638             cpu_physical_memory_read(addr, buf, l);
1639         } else {
1640             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1641                 monitor_printf(mon, " Cannot access memory\n");
1642                 break;
1643             }
1644         }
1645         i = 0;
1646         while (i < l) {
1647             switch(wsize) {
1648             default:
1649             case 1:
1650                 v = ldub_p(buf + i);
1651                 break;
1652             case 2:
1653                 v = lduw_p(buf + i);
1654                 break;
1655             case 4:
1656                 v = (uint32_t)ldl_p(buf + i);
1657                 break;
1658             case 8:
1659                 v = ldq_p(buf + i);
1660                 break;
1661             }
1662             monitor_printf(mon, " ");
1663             switch(format) {
1664             case 'o':
1665                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1666                 break;
1667             case 'x':
1668                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1669                 break;
1670             case 'u':
1671                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1672                 break;
1673             case 'd':
1674                 monitor_printf(mon, "%*" PRId64, max_digits, v);
1675                 break;
1676             case 'c':
1677                 monitor_printc(mon, v);
1678                 break;
1679             }
1680             i += wsize;
1681         }
1682         monitor_printf(mon, "\n");
1683         addr += l;
1684         len -= l;
1685     }
1686 }
1687
1688 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1689 {
1690     int count = qdict_get_int(qdict, "count");
1691     int format = qdict_get_int(qdict, "format");
1692     int size = qdict_get_int(qdict, "size");
1693     target_long addr = qdict_get_int(qdict, "addr");
1694
1695     memory_dump(mon, count, format, size, addr, 0);
1696 }
1697
1698 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1699 {
1700     int count = qdict_get_int(qdict, "count");
1701     int format = qdict_get_int(qdict, "format");
1702     int size = qdict_get_int(qdict, "size");
1703     hwaddr addr = qdict_get_int(qdict, "addr");
1704
1705     memory_dump(mon, count, format, size, addr, 1);
1706 }
1707
1708 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1709 {
1710     MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1711                                                  addr, 1);
1712
1713     if (!mrs.mr) {
1714         error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1715         return NULL;
1716     }
1717
1718     if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1719         error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1720         memory_region_unref(mrs.mr);
1721         return NULL;
1722     }
1723
1724     *p_mr = mrs.mr;
1725     return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1726 }
1727
1728 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1729 {
1730     hwaddr addr = qdict_get_int(qdict, "addr");
1731     Error *local_err = NULL;
1732     MemoryRegion *mr = NULL;
1733     void *ptr;
1734
1735     ptr = gpa2hva(&mr, addr, &local_err);
1736     if (local_err) {
1737         error_report_err(local_err);
1738         return;
1739     }
1740
1741     monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1742                    " (%s) is %p\n",
1743                    addr, mr->name, ptr);
1744
1745     memory_region_unref(mr);
1746 }
1747
1748 #ifdef CONFIG_LINUX
1749 static uint64_t vtop(void *ptr, Error **errp)
1750 {
1751     uint64_t pinfo;
1752     uint64_t ret = -1;
1753     uintptr_t addr = (uintptr_t) ptr;
1754     uintptr_t pagesize = getpagesize();
1755     off_t offset = addr / pagesize * sizeof(pinfo);
1756     int fd;
1757
1758     fd = open("/proc/self/pagemap", O_RDONLY);
1759     if (fd == -1) {
1760         error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1761         return -1;
1762     }
1763
1764     /* Force copy-on-write if necessary.  */
1765     atomic_add((uint8_t *)ptr, 0);
1766
1767     if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1768         error_setg_errno(errp, errno, "Cannot read pagemap");
1769         goto out;
1770     }
1771     if ((pinfo & (1ull << 63)) == 0) {
1772         error_setg(errp, "Page not present");
1773         goto out;
1774     }
1775     ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1776
1777 out:
1778     close(fd);
1779     return ret;
1780 }
1781
1782 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1783 {
1784     hwaddr addr = qdict_get_int(qdict, "addr");
1785     Error *local_err = NULL;
1786     MemoryRegion *mr = NULL;
1787     void *ptr;
1788     uint64_t physaddr;
1789
1790     ptr = gpa2hva(&mr, addr, &local_err);
1791     if (local_err) {
1792         error_report_err(local_err);
1793         return;
1794     }
1795
1796     physaddr = vtop(ptr, &local_err);
1797     if (local_err) {
1798         error_report_err(local_err);
1799     } else {
1800         monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1801                        " (%s) is 0x%" PRIx64 "\n",
1802                        addr, mr->name, (uint64_t) physaddr);
1803     }
1804
1805     memory_region_unref(mr);
1806 }
1807 #endif
1808
1809 static void do_print(Monitor *mon, const QDict *qdict)
1810 {
1811     int format = qdict_get_int(qdict, "format");
1812     hwaddr val = qdict_get_int(qdict, "val");
1813
1814     switch(format) {
1815     case 'o':
1816         monitor_printf(mon, "%#" HWADDR_PRIo, val);
1817         break;
1818     case 'x':
1819         monitor_printf(mon, "%#" HWADDR_PRIx, val);
1820         break;
1821     case 'u':
1822         monitor_printf(mon, "%" HWADDR_PRIu, val);
1823         break;
1824     default:
1825     case 'd':
1826         monitor_printf(mon, "%" HWADDR_PRId, val);
1827         break;
1828     case 'c':
1829         monitor_printc(mon, val);
1830         break;
1831     }
1832     monitor_printf(mon, "\n");
1833 }
1834
1835 static void hmp_sum(Monitor *mon, const QDict *qdict)
1836 {
1837     uint32_t addr;
1838     uint16_t sum;
1839     uint32_t start = qdict_get_int(qdict, "start");
1840     uint32_t size = qdict_get_int(qdict, "size");
1841
1842     sum = 0;
1843     for(addr = start; addr < (start + size); addr++) {
1844         uint8_t val = address_space_ldub(&address_space_memory, addr,
1845                                          MEMTXATTRS_UNSPECIFIED, NULL);
1846         /* BSD sum algorithm ('sum' Unix command) */
1847         sum = (sum >> 1) | (sum << 15);
1848         sum += val;
1849     }
1850     monitor_printf(mon, "%05d\n", sum);
1851 }
1852
1853 static int mouse_button_state;
1854
1855 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1856 {
1857     int dx, dy, dz, button;
1858     const char *dx_str = qdict_get_str(qdict, "dx_str");
1859     const char *dy_str = qdict_get_str(qdict, "dy_str");
1860     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1861
1862     dx = strtol(dx_str, NULL, 0);
1863     dy = strtol(dy_str, NULL, 0);
1864     qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1865     qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1866
1867     if (dz_str) {
1868         dz = strtol(dz_str, NULL, 0);
1869         if (dz != 0) {
1870             button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1871             qemu_input_queue_btn(NULL, button, true);
1872             qemu_input_event_sync();
1873             qemu_input_queue_btn(NULL, button, false);
1874         }
1875     }
1876     qemu_input_event_sync();
1877 }
1878
1879 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1880 {
1881     static uint32_t bmap[INPUT_BUTTON__MAX] = {
1882         [INPUT_BUTTON_LEFT]       = MOUSE_EVENT_LBUTTON,
1883         [INPUT_BUTTON_MIDDLE]     = MOUSE_EVENT_MBUTTON,
1884         [INPUT_BUTTON_RIGHT]      = MOUSE_EVENT_RBUTTON,
1885     };
1886     int button_state = qdict_get_int(qdict, "button_state");
1887
1888     if (mouse_button_state == button_state) {
1889         return;
1890     }
1891     qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1892     qemu_input_event_sync();
1893     mouse_button_state = button_state;
1894 }
1895
1896 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1897 {
1898     int size = qdict_get_int(qdict, "size");
1899     int addr = qdict_get_int(qdict, "addr");
1900     int has_index = qdict_haskey(qdict, "index");
1901     uint32_t val;
1902     int suffix;
1903
1904     if (has_index) {
1905         int index = qdict_get_int(qdict, "index");
1906         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1907         addr++;
1908     }
1909     addr &= 0xffff;
1910
1911     switch(size) {
1912     default:
1913     case 1:
1914         val = cpu_inb(addr);
1915         suffix = 'b';
1916         break;
1917     case 2:
1918         val = cpu_inw(addr);
1919         suffix = 'w';
1920         break;
1921     case 4:
1922         val = cpu_inl(addr);
1923         suffix = 'l';
1924         break;
1925     }
1926     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1927                    suffix, addr, size * 2, val);
1928 }
1929
1930 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1931 {
1932     int size = qdict_get_int(qdict, "size");
1933     int addr = qdict_get_int(qdict, "addr");
1934     int val = qdict_get_int(qdict, "val");
1935
1936     addr &= IOPORTS_MASK;
1937
1938     switch (size) {
1939     default:
1940     case 1:
1941         cpu_outb(addr, val);
1942         break;
1943     case 2:
1944         cpu_outw(addr, val);
1945         break;
1946     case 4:
1947         cpu_outl(addr, val);
1948         break;
1949     }
1950 }
1951
1952 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1953 {
1954     Error *local_err = NULL;
1955     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1956
1957     qemu_boot_set(bootdevice, &local_err);
1958     if (local_err) {
1959         error_report_err(local_err);
1960     } else {
1961         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1962     }
1963 }
1964
1965 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1966 {
1967     bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1968     bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1969
1970     mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree);
1971 }
1972
1973 static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1974 {
1975     int i;
1976     NumaNodeMem *node_mem;
1977     CpuInfoList *cpu_list, *cpu;
1978
1979     cpu_list = qmp_query_cpus(&error_abort);
1980     node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1981
1982     query_numa_node_mem(node_mem);
1983     monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1984     for (i = 0; i < nb_numa_nodes; i++) {
1985         monitor_printf(mon, "node %d cpus:", i);
1986         for (cpu = cpu_list; cpu; cpu = cpu->next) {
1987             if (cpu->value->has_props && cpu->value->props->has_node_id &&
1988                 cpu->value->props->node_id == i) {
1989                 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1990             }
1991         }
1992         monitor_printf(mon, "\n");
1993         monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1994                        node_mem[i].node_mem >> 20);
1995         monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1996                        node_mem[i].node_plugged_mem >> 20);
1997     }
1998     qapi_free_CpuInfoList(cpu_list);
1999     g_free(node_mem);
2000 }
2001
2002 #ifdef CONFIG_PROFILER
2003
2004 int64_t tcg_time;
2005 int64_t dev_time;
2006
2007 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2008 {
2009     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
2010                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
2011     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
2012                    tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
2013     tcg_time = 0;
2014     dev_time = 0;
2015 }
2016 #else
2017 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
2018 {
2019     monitor_printf(mon, "Internal profiler not compiled\n");
2020 }
2021 #endif
2022
2023 /* Capture support */
2024 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2025
2026 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2027 {
2028     int i;
2029     CaptureState *s;
2030
2031     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2032         monitor_printf(mon, "[%d]: ", i);
2033         s->ops.info (s->opaque);
2034     }
2035 }
2036
2037 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2038 {
2039     int i;
2040     int n = qdict_get_int(qdict, "n");
2041     CaptureState *s;
2042
2043     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2044         if (i == n) {
2045             s->ops.destroy (s->opaque);
2046             QLIST_REMOVE (s, entries);
2047             g_free (s);
2048             return;
2049         }
2050     }
2051 }
2052
2053 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2054 {
2055     const char *path = qdict_get_str(qdict, "path");
2056     int has_freq = qdict_haskey(qdict, "freq");
2057     int freq = qdict_get_try_int(qdict, "freq", -1);
2058     int has_bits = qdict_haskey(qdict, "bits");
2059     int bits = qdict_get_try_int(qdict, "bits", -1);
2060     int has_channels = qdict_haskey(qdict, "nchannels");
2061     int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2062     CaptureState *s;
2063
2064     s = g_malloc0 (sizeof (*s));
2065
2066     freq = has_freq ? freq : 44100;
2067     bits = has_bits ? bits : 16;
2068     nchannels = has_channels ? nchannels : 2;
2069
2070     if (wav_start_capture (s, path, freq, bits, nchannels)) {
2071         monitor_printf(mon, "Failed to add wave capture\n");
2072         g_free (s);
2073         return;
2074     }
2075     QLIST_INSERT_HEAD (&capture_head, s, entries);
2076 }
2077
2078 static qemu_acl *find_acl(Monitor *mon, const char *name)
2079 {
2080     qemu_acl *acl = qemu_acl_find(name);
2081
2082     if (!acl) {
2083         monitor_printf(mon, "acl: unknown list '%s'\n", name);
2084     }
2085     return acl;
2086 }
2087
2088 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2089 {
2090     const char *aclname = qdict_get_str(qdict, "aclname");
2091     qemu_acl *acl = find_acl(mon, aclname);
2092     qemu_acl_entry *entry;
2093     int i = 0;
2094
2095     if (acl) {
2096         monitor_printf(mon, "policy: %s\n",
2097                        acl->defaultDeny ? "deny" : "allow");
2098         QTAILQ_FOREACH(entry, &acl->entries, next) {
2099             i++;
2100             monitor_printf(mon, "%d: %s %s\n", i,
2101                            entry->deny ? "deny" : "allow", entry->match);
2102         }
2103     }
2104 }
2105
2106 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2107 {
2108     const char *aclname = qdict_get_str(qdict, "aclname");
2109     qemu_acl *acl = find_acl(mon, aclname);
2110
2111     if (acl) {
2112         qemu_acl_reset(acl);
2113         monitor_printf(mon, "acl: removed all rules\n");
2114     }
2115 }
2116
2117 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2118 {
2119     const char *aclname = qdict_get_str(qdict, "aclname");
2120     const char *policy = qdict_get_str(qdict, "policy");
2121     qemu_acl *acl = find_acl(mon, aclname);
2122
2123     if (acl) {
2124         if (strcmp(policy, "allow") == 0) {
2125             acl->defaultDeny = 0;
2126             monitor_printf(mon, "acl: policy set to 'allow'\n");
2127         } else if (strcmp(policy, "deny") == 0) {
2128             acl->defaultDeny = 1;
2129             monitor_printf(mon, "acl: policy set to 'deny'\n");
2130         } else {
2131             monitor_printf(mon, "acl: unknown policy '%s', "
2132                            "expected 'deny' or 'allow'\n", policy);
2133         }
2134     }
2135 }
2136
2137 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2138 {
2139     const char *aclname = qdict_get_str(qdict, "aclname");
2140     const char *match = qdict_get_str(qdict, "match");
2141     const char *policy = qdict_get_str(qdict, "policy");
2142     int has_index = qdict_haskey(qdict, "index");
2143     int index = qdict_get_try_int(qdict, "index", -1);
2144     qemu_acl *acl = find_acl(mon, aclname);
2145     int deny, ret;
2146
2147     if (acl) {
2148         if (strcmp(policy, "allow") == 0) {
2149             deny = 0;
2150         } else if (strcmp(policy, "deny") == 0) {
2151             deny = 1;
2152         } else {
2153             monitor_printf(mon, "acl: unknown policy '%s', "
2154                            "expected 'deny' or 'allow'\n", policy);
2155             return;
2156         }
2157         if (has_index)
2158             ret = qemu_acl_insert(acl, deny, match, index);
2159         else
2160             ret = qemu_acl_append(acl, deny, match);
2161         if (ret < 0)
2162             monitor_printf(mon, "acl: unable to add acl entry\n");
2163         else
2164             monitor_printf(mon, "acl: added rule at position %d\n", ret);
2165     }
2166 }
2167
2168 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2169 {
2170     const char *aclname = qdict_get_str(qdict, "aclname");
2171     const char *match = qdict_get_str(qdict, "match");
2172     qemu_acl *acl = find_acl(mon, aclname);
2173     int ret;
2174
2175     if (acl) {
2176         ret = qemu_acl_remove(acl, match);
2177         if (ret < 0)
2178             monitor_printf(mon, "acl: no matching acl entry\n");
2179         else
2180             monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2181     }
2182 }
2183
2184 void qmp_getfd(const char *fdname, Error **errp)
2185 {
2186     mon_fd_t *monfd;
2187     int fd;
2188
2189     fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2190     if (fd == -1) {
2191         error_setg(errp, QERR_FD_NOT_SUPPLIED);
2192         return;
2193     }
2194
2195     if (qemu_isdigit(fdname[0])) {
2196         close(fd);
2197         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2198                    "a name not starting with a digit");
2199         return;
2200     }
2201
2202     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2203         if (strcmp(monfd->name, fdname) != 0) {
2204             continue;
2205         }
2206
2207         close(monfd->fd);
2208         monfd->fd = fd;
2209         return;
2210     }
2211
2212     monfd = g_malloc0(sizeof(mon_fd_t));
2213     monfd->name = g_strdup(fdname);
2214     monfd->fd = fd;
2215
2216     QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2217 }
2218
2219 void qmp_closefd(const char *fdname, Error **errp)
2220 {
2221     mon_fd_t *monfd;
2222
2223     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2224         if (strcmp(monfd->name, fdname) != 0) {
2225             continue;
2226         }
2227
2228         QLIST_REMOVE(monfd, next);
2229         close(monfd->fd);
2230         g_free(monfd->name);
2231         g_free(monfd);
2232         return;
2233     }
2234
2235     error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2236 }
2237
2238 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2239 {
2240     mon_fd_t *monfd;
2241
2242     QLIST_FOREACH(monfd, &mon->fds, next) {
2243         int fd;
2244
2245         if (strcmp(monfd->name, fdname) != 0) {
2246             continue;
2247         }
2248
2249         fd = monfd->fd;
2250
2251         /* caller takes ownership of fd */
2252         QLIST_REMOVE(monfd, next);
2253         g_free(monfd->name);
2254         g_free(monfd);
2255
2256         return fd;
2257     }
2258
2259     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2260     return -1;
2261 }
2262
2263 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2264 {
2265     MonFdsetFd *mon_fdset_fd;
2266     MonFdsetFd *mon_fdset_fd_next;
2267
2268     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2269         if ((mon_fdset_fd->removed ||
2270                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2271                 runstate_is_running()) {
2272             close(mon_fdset_fd->fd);
2273             g_free(mon_fdset_fd->opaque);
2274             QLIST_REMOVE(mon_fdset_fd, next);
2275             g_free(mon_fdset_fd);
2276         }
2277     }
2278
2279     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2280         QLIST_REMOVE(mon_fdset, next);
2281         g_free(mon_fdset);
2282     }
2283 }
2284
2285 static void monitor_fdsets_cleanup(void)
2286 {
2287     MonFdset *mon_fdset;
2288     MonFdset *mon_fdset_next;
2289
2290     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2291         monitor_fdset_cleanup(mon_fdset);
2292     }
2293 }
2294
2295 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2296                       const char *opaque, Error **errp)
2297 {
2298     int fd;
2299     Monitor *mon = cur_mon;
2300     AddfdInfo *fdinfo;
2301
2302     fd = qemu_chr_fe_get_msgfd(&mon->chr);
2303     if (fd == -1) {
2304         error_setg(errp, QERR_FD_NOT_SUPPLIED);
2305         goto error;
2306     }
2307
2308     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2309                                   has_opaque, opaque, errp);
2310     if (fdinfo) {
2311         return fdinfo;
2312     }
2313
2314 error:
2315     if (fd != -1) {
2316         close(fd);
2317     }
2318     return NULL;
2319 }
2320
2321 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2322 {
2323     MonFdset *mon_fdset;
2324     MonFdsetFd *mon_fdset_fd;
2325     char fd_str[60];
2326
2327     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2328         if (mon_fdset->id != fdset_id) {
2329             continue;
2330         }
2331         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2332             if (has_fd) {
2333                 if (mon_fdset_fd->fd != fd) {
2334                     continue;
2335                 }
2336                 mon_fdset_fd->removed = true;
2337                 break;
2338             } else {
2339                 mon_fdset_fd->removed = true;
2340             }
2341         }
2342         if (has_fd && !mon_fdset_fd) {
2343             goto error;
2344         }
2345         monitor_fdset_cleanup(mon_fdset);
2346         return;
2347     }
2348
2349 error:
2350     if (has_fd) {
2351         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2352                  fdset_id, fd);
2353     } else {
2354         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2355     }
2356     error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2357 }
2358
2359 FdsetInfoList *qmp_query_fdsets(Error **errp)
2360 {
2361     MonFdset *mon_fdset;
2362     MonFdsetFd *mon_fdset_fd;
2363     FdsetInfoList *fdset_list = NULL;
2364
2365     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2366         FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2367         FdsetFdInfoList *fdsetfd_list = NULL;
2368
2369         fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2370         fdset_info->value->fdset_id = mon_fdset->id;
2371
2372         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2373             FdsetFdInfoList *fdsetfd_info;
2374
2375             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2376             fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2377             fdsetfd_info->value->fd = mon_fdset_fd->fd;
2378             if (mon_fdset_fd->opaque) {
2379                 fdsetfd_info->value->has_opaque = true;
2380                 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2381             } else {
2382                 fdsetfd_info->value->has_opaque = false;
2383             }
2384
2385             fdsetfd_info->next = fdsetfd_list;
2386             fdsetfd_list = fdsetfd_info;
2387         }
2388
2389         fdset_info->value->fds = fdsetfd_list;
2390
2391         fdset_info->next = fdset_list;
2392         fdset_list = fdset_info;
2393     }
2394
2395     return fdset_list;
2396 }
2397
2398 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2399                                 bool has_opaque, const char *opaque,
2400                                 Error **errp)
2401 {
2402     MonFdset *mon_fdset = NULL;
2403     MonFdsetFd *mon_fdset_fd;
2404     AddfdInfo *fdinfo;
2405
2406     if (has_fdset_id) {
2407         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2408             /* Break if match found or match impossible due to ordering by ID */
2409             if (fdset_id <= mon_fdset->id) {
2410                 if (fdset_id < mon_fdset->id) {
2411                     mon_fdset = NULL;
2412                 }
2413                 break;
2414             }
2415         }
2416     }
2417
2418     if (mon_fdset == NULL) {
2419         int64_t fdset_id_prev = -1;
2420         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2421
2422         if (has_fdset_id) {
2423             if (fdset_id < 0) {
2424                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2425                            "a non-negative value");
2426                 return NULL;
2427             }
2428             /* Use specified fdset ID */
2429             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2430                 mon_fdset_cur = mon_fdset;
2431                 if (fdset_id < mon_fdset_cur->id) {
2432                     break;
2433                 }
2434             }
2435         } else {
2436             /* Use first available fdset ID */
2437             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2438                 mon_fdset_cur = mon_fdset;
2439                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2440                     fdset_id_prev = mon_fdset_cur->id;
2441                     continue;
2442                 }
2443                 break;
2444             }
2445         }
2446
2447         mon_fdset = g_malloc0(sizeof(*mon_fdset));
2448         if (has_fdset_id) {
2449             mon_fdset->id = fdset_id;
2450         } else {
2451             mon_fdset->id = fdset_id_prev + 1;
2452         }
2453
2454         /* The fdset list is ordered by fdset ID */
2455         if (!mon_fdset_cur) {
2456             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2457         } else if (mon_fdset->id < mon_fdset_cur->id) {
2458             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2459         } else {
2460             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2461         }
2462     }
2463
2464     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2465     mon_fdset_fd->fd = fd;
2466     mon_fdset_fd->removed = false;
2467     if (has_opaque) {
2468         mon_fdset_fd->opaque = g_strdup(opaque);
2469     }
2470     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2471
2472     fdinfo = g_malloc0(sizeof(*fdinfo));
2473     fdinfo->fdset_id = mon_fdset->id;
2474     fdinfo->fd = mon_fdset_fd->fd;
2475
2476     return fdinfo;
2477 }
2478
2479 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2480 {
2481 #ifndef _WIN32
2482     MonFdset *mon_fdset;
2483     MonFdsetFd *mon_fdset_fd;
2484     int mon_fd_flags;
2485
2486     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2487         if (mon_fdset->id != fdset_id) {
2488             continue;
2489         }
2490         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2491             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2492             if (mon_fd_flags == -1) {
2493                 return -1;
2494             }
2495
2496             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2497                 return mon_fdset_fd->fd;
2498             }
2499         }
2500         errno = EACCES;
2501         return -1;
2502     }
2503 #endif
2504
2505     errno = ENOENT;
2506     return -1;
2507 }
2508
2509 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2510 {
2511     MonFdset *mon_fdset;
2512     MonFdsetFd *mon_fdset_fd_dup;
2513
2514     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2515         if (mon_fdset->id != fdset_id) {
2516             continue;
2517         }
2518         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2519             if (mon_fdset_fd_dup->fd == dup_fd) {
2520                 return -1;
2521             }
2522         }
2523         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2524         mon_fdset_fd_dup->fd = dup_fd;
2525         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2526         return 0;
2527     }
2528     return -1;
2529 }
2530
2531 static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2532 {
2533     MonFdset *mon_fdset;
2534     MonFdsetFd *mon_fdset_fd_dup;
2535
2536     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2537         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2538             if (mon_fdset_fd_dup->fd == dup_fd) {
2539                 if (remove) {
2540                     QLIST_REMOVE(mon_fdset_fd_dup, next);
2541                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2542                         monitor_fdset_cleanup(mon_fdset);
2543                     }
2544                     return -1;
2545                 } else {
2546                     return mon_fdset->id;
2547                 }
2548             }
2549         }
2550     }
2551     return -1;
2552 }
2553
2554 int monitor_fdset_dup_fd_find(int dup_fd)
2555 {
2556     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2557 }
2558
2559 void monitor_fdset_dup_fd_remove(int dup_fd)
2560 {
2561     monitor_fdset_dup_fd_find_remove(dup_fd, true);
2562 }
2563
2564 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2565 {
2566     int fd;
2567     Error *local_err = NULL;
2568
2569     if (!qemu_isdigit(fdname[0]) && mon) {
2570         fd = monitor_get_fd(mon, fdname, &local_err);
2571     } else {
2572         fd = qemu_parse_fd(fdname);
2573         if (fd == -1) {
2574             error_setg(&local_err, "Invalid file descriptor number '%s'",
2575                        fdname);
2576         }
2577     }
2578     if (local_err) {
2579         error_propagate(errp, local_err);
2580         assert(fd == -1);
2581     } else {
2582         assert(fd != -1);
2583     }
2584
2585     return fd;
2586 }
2587
2588 /* Please update hmp-commands.hx when adding or changing commands */
2589 static mon_cmd_t info_cmds[] = {
2590 #include "hmp-commands-info.h"
2591     { NULL, NULL, },
2592 };
2593
2594 /* mon_cmds and info_cmds would be sorted at runtime */
2595 static mon_cmd_t mon_cmds[] = {
2596 #include "hmp-commands.h"
2597     { NULL, NULL, },
2598 };
2599
2600 /*******************************************************************/
2601
2602 static const char *pch;
2603 static sigjmp_buf expr_env;
2604
2605
2606 static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2607 expr_error(Monitor *mon, const char *fmt, ...)
2608 {
2609     va_list ap;
2610     va_start(ap, fmt);
2611     monitor_vprintf(mon, fmt, ap);
2612     monitor_printf(mon, "\n");
2613     va_end(ap);
2614     siglongjmp(expr_env, 1);
2615 }
2616
2617 /* return 0 if OK, -1 if not found */
2618 static int get_monitor_def(target_long *pval, const char *name)
2619 {
2620     const MonitorDef *md = target_monitor_defs();
2621     CPUState *cs = mon_get_cpu();
2622     void *ptr;
2623     uint64_t tmp = 0;
2624     int ret;
2625
2626     if (cs == NULL || md == NULL) {
2627         return -1;
2628     }
2629
2630     for(; md->name != NULL; md++) {
2631         if (compare_cmd(name, md->name)) {
2632             if (md->get_value) {
2633                 *pval = md->get_value(md, md->offset);
2634             } else {
2635                 CPUArchState *env = mon_get_cpu_env();
2636                 ptr = (uint8_t *)env + md->offset;
2637                 switch(md->type) {
2638                 case MD_I32:
2639                     *pval = *(int32_t *)ptr;
2640                     break;
2641                 case MD_TLONG:
2642                     *pval = *(target_long *)ptr;
2643                     break;
2644                 default:
2645                     *pval = 0;
2646                     break;
2647                 }
2648             }
2649             return 0;
2650         }
2651     }
2652
2653     ret = target_get_monitor_def(cs, name, &tmp);
2654     if (!ret) {
2655         *pval = (target_long) tmp;
2656     }
2657
2658     return ret;
2659 }
2660
2661 static void next(void)
2662 {
2663     if (*pch != '\0') {
2664         pch++;
2665         while (qemu_isspace(*pch))
2666             pch++;
2667     }
2668 }
2669
2670 static int64_t expr_sum(Monitor *mon);
2671
2672 static int64_t expr_unary(Monitor *mon)
2673 {
2674     int64_t n;
2675     char *p;
2676     int ret;
2677
2678     switch(*pch) {
2679     case '+':
2680         next();
2681         n = expr_unary(mon);
2682         break;
2683     case '-':
2684         next();
2685         n = -expr_unary(mon);
2686         break;
2687     case '~':
2688         next();
2689         n = ~expr_unary(mon);
2690         break;
2691     case '(':
2692         next();
2693         n = expr_sum(mon);
2694         if (*pch != ')') {
2695             expr_error(mon, "')' expected");
2696         }
2697         next();
2698         break;
2699     case '\'':
2700         pch++;
2701         if (*pch == '\0')
2702             expr_error(mon, "character constant expected");
2703         n = *pch;
2704         pch++;
2705         if (*pch != '\'')
2706             expr_error(mon, "missing terminating \' character");
2707         next();
2708         break;
2709     case '$':
2710         {
2711             char buf[128], *q;
2712             target_long reg=0;
2713
2714             pch++;
2715             q = buf;
2716             while ((*pch >= 'a' && *pch <= 'z') ||
2717                    (*pch >= 'A' && *pch <= 'Z') ||
2718                    (*pch >= '0' && *pch <= '9') ||
2719                    *pch == '_' || *pch == '.') {
2720                 if ((q - buf) < sizeof(buf) - 1)
2721                     *q++ = *pch;
2722                 pch++;
2723             }
2724             while (qemu_isspace(*pch))
2725                 pch++;
2726             *q = 0;
2727             ret = get_monitor_def(&reg, buf);
2728             if (ret < 0)
2729                 expr_error(mon, "unknown register");
2730             n = reg;
2731         }
2732         break;
2733     case '\0':
2734         expr_error(mon, "unexpected end of expression");
2735         n = 0;
2736         break;
2737     default:
2738         errno = 0;
2739         n = strtoull(pch, &p, 0);
2740         if (errno == ERANGE) {
2741             expr_error(mon, "number too large");
2742         }
2743         if (pch == p) {
2744             expr_error(mon, "invalid char '%c' in expression", *p);
2745         }
2746         pch = p;
2747         while (qemu_isspace(*pch))
2748             pch++;
2749         break;
2750     }
2751     return n;
2752 }
2753
2754
2755 static int64_t expr_prod(Monitor *mon)
2756 {
2757     int64_t val, val2;
2758     int op;
2759
2760     val = expr_unary(mon);
2761     for(;;) {
2762         op = *pch;
2763         if (op != '*' && op != '/' && op != '%')
2764             break;
2765         next();
2766         val2 = expr_unary(mon);
2767         switch(op) {
2768         default:
2769         case '*':
2770             val *= val2;
2771             break;
2772         case '/':
2773         case '%':
2774             if (val2 == 0)
2775                 expr_error(mon, "division by zero");
2776             if (op == '/')
2777                 val /= val2;
2778             else
2779                 val %= val2;
2780             break;
2781         }
2782     }
2783     return val;
2784 }
2785
2786 static int64_t expr_logic(Monitor *mon)
2787 {
2788     int64_t val, val2;
2789     int op;
2790
2791     val = expr_prod(mon);
2792     for(;;) {
2793         op = *pch;
2794         if (op != '&' && op != '|' && op != '^')
2795             break;
2796         next();
2797         val2 = expr_prod(mon);
2798         switch(op) {
2799         default:
2800         case '&':
2801             val &= val2;
2802             break;
2803         case '|':
2804             val |= val2;
2805             break;
2806         case '^':
2807             val ^= val2;
2808             break;
2809         }
2810     }
2811     return val;
2812 }
2813
2814 static int64_t expr_sum(Monitor *mon)
2815 {
2816     int64_t val, val2;
2817     int op;
2818
2819     val = expr_logic(mon);
2820     for(;;) {
2821         op = *pch;
2822         if (op != '+' && op != '-')
2823             break;
2824         next();
2825         val2 = expr_logic(mon);
2826         if (op == '+')
2827             val += val2;
2828         else
2829             val -= val2;
2830     }
2831     return val;
2832 }
2833
2834 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2835 {
2836     pch = *pp;
2837     if (sigsetjmp(expr_env, 0)) {
2838         *pp = pch;
2839         return -1;
2840     }
2841     while (qemu_isspace(*pch))
2842         pch++;
2843     *pval = expr_sum(mon);
2844     *pp = pch;
2845     return 0;
2846 }
2847
2848 static int get_double(Monitor *mon, double *pval, const char **pp)
2849 {
2850     const char *p = *pp;
2851     char *tailp;
2852     double d;
2853
2854     d = strtod(p, &tailp);
2855     if (tailp == p) {
2856         monitor_printf(mon, "Number expected\n");
2857         return -1;
2858     }
2859     if (d != d || d - d != 0) {
2860         /* NaN or infinity */
2861         monitor_printf(mon, "Bad number\n");
2862         return -1;
2863     }
2864     *pval = d;
2865     *pp = tailp;
2866     return 0;
2867 }
2868
2869 /*
2870  * Store the command-name in cmdname, and return a pointer to
2871  * the remaining of the command string.
2872  */
2873 static const char *get_command_name(const char *cmdline,
2874                                     char *cmdname, size_t nlen)
2875 {
2876     size_t len;
2877     const char *p, *pstart;
2878
2879     p = cmdline;
2880     while (qemu_isspace(*p))
2881         p++;
2882     if (*p == '\0')
2883         return NULL;
2884     pstart = p;
2885     while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2886         p++;
2887     len = p - pstart;
2888     if (len > nlen - 1)
2889         len = nlen - 1;
2890     memcpy(cmdname, pstart, len);
2891     cmdname[len] = '\0';
2892     return p;
2893 }
2894
2895 /**
2896  * Read key of 'type' into 'key' and return the current
2897  * 'type' pointer.
2898  */
2899 static char *key_get_info(const char *type, char **key)
2900 {
2901     size_t len;
2902     char *p, *str;
2903
2904     if (*type == ',')
2905         type++;
2906
2907     p = strchr(type, ':');
2908     if (!p) {
2909         *key = NULL;
2910         return NULL;
2911     }
2912     len = p - type;
2913
2914     str = g_malloc(len + 1);
2915     memcpy(str, type, len);
2916     str[len] = '\0';
2917
2918     *key = str;
2919     return ++p;
2920 }
2921
2922 static int default_fmt_format = 'x';
2923 static int default_fmt_size = 4;
2924
2925 static int is_valid_option(const char *c, const char *typestr)
2926 {
2927     char option[3];
2928
2929     option[0] = '-';
2930     option[1] = *c;
2931     option[2] = '\0';
2932
2933     typestr = strstr(typestr, option);
2934     return (typestr != NULL);
2935 }
2936
2937 static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2938                                               const char *cmdname)
2939 {
2940     const mon_cmd_t *cmd;
2941
2942     for (cmd = disp_table; cmd->name != NULL; cmd++) {
2943         if (compare_cmd(cmdname, cmd->name)) {
2944             return cmd;
2945         }
2946     }
2947
2948     return NULL;
2949 }
2950
2951 /*
2952  * Parse command name from @cmdp according to command table @table.
2953  * If blank, return NULL.
2954  * Else, if no valid command can be found, report to @mon, and return
2955  * NULL.
2956  * Else, change @cmdp to point right behind the name, and return its
2957  * command table entry.
2958  * Do not assume the return value points into @table!  It doesn't when
2959  * the command is found in a sub-command table.
2960  */
2961 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2962                                               const char *cmdp_start,
2963                                               const char **cmdp,
2964                                               mon_cmd_t *table)
2965 {
2966     const char *p;
2967     const mon_cmd_t *cmd;
2968     char cmdname[256];
2969
2970     /* extract the command name */
2971     p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2972     if (!p)
2973         return NULL;
2974
2975     cmd = search_dispatch_table(table, cmdname);
2976     if (!cmd) {
2977         monitor_printf(mon, "unknown command: '%.*s'\n",
2978                        (int)(p - cmdp_start), cmdp_start);
2979         return NULL;
2980     }
2981
2982     /* filter out following useless space */
2983     while (qemu_isspace(*p)) {
2984         p++;
2985     }
2986
2987     *cmdp = p;
2988     /* search sub command */
2989     if (cmd->sub_table != NULL && *p != '\0') {
2990         return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
2991     }
2992
2993     return cmd;
2994 }
2995
2996 /*
2997  * Parse arguments for @cmd.
2998  * If it can't be parsed, report to @mon, and return NULL.
2999  * Else, insert command arguments into a QDict, and return it.
3000  * Note: On success, caller has to free the QDict structure.
3001  */
3002
3003 static QDict *monitor_parse_arguments(Monitor *mon,
3004                                       const char **endp,
3005                                       const mon_cmd_t *cmd)
3006 {
3007     const char *typestr;
3008     char *key;
3009     int c;
3010     const char *p = *endp;
3011     char buf[1024];
3012     QDict *qdict = qdict_new();
3013
3014     /* parse the parameters */
3015     typestr = cmd->args_type;
3016     for(;;) {
3017         typestr = key_get_info(typestr, &key);
3018         if (!typestr)
3019             break;
3020         c = *typestr;
3021         typestr++;
3022         switch(c) {
3023         case 'F':
3024         case 'B':
3025         case 's':
3026             {
3027                 int ret;
3028
3029                 while (qemu_isspace(*p))
3030                     p++;
3031                 if (*typestr == '?') {
3032                     typestr++;
3033                     if (*p == '\0') {
3034                         /* no optional string: NULL argument */
3035                         break;
3036                     }
3037                 }
3038                 ret = get_str(buf, sizeof(buf), &p);
3039                 if (ret < 0) {
3040                     switch(c) {
3041                     case 'F':
3042                         monitor_printf(mon, "%s: filename expected\n",
3043                                        cmd->name);
3044                         break;
3045                     case 'B':
3046                         monitor_printf(mon, "%s: block device name expected\n",
3047                                        cmd->name);
3048                         break;
3049                     default:
3050                         monitor_printf(mon, "%s: string expected\n", cmd->name);
3051                         break;
3052                     }
3053                     goto fail;
3054                 }
3055                 qdict_put_str(qdict, key, buf);
3056             }
3057             break;
3058         case 'O':
3059             {
3060                 QemuOptsList *opts_list;
3061                 QemuOpts *opts;
3062
3063                 opts_list = qemu_find_opts(key);
3064                 if (!opts_list || opts_list->desc->name) {
3065                     goto bad_type;
3066                 }
3067                 while (qemu_isspace(*p)) {
3068                     p++;
3069                 }
3070                 if (!*p)
3071                     break;
3072                 if (get_str(buf, sizeof(buf), &p) < 0) {
3073                     goto fail;
3074                 }
3075                 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3076                 if (!opts) {
3077                     goto fail;
3078                 }
3079                 qemu_opts_to_qdict(opts, qdict);
3080                 qemu_opts_del(opts);
3081             }
3082             break;
3083         case '/':
3084             {
3085                 int count, format, size;
3086
3087                 while (qemu_isspace(*p))
3088                     p++;
3089                 if (*p == '/') {
3090                     /* format found */
3091                     p++;
3092                     count = 1;
3093                     if (qemu_isdigit(*p)) {
3094                         count = 0;
3095                         while (qemu_isdigit(*p)) {
3096                             count = count * 10 + (*p - '0');
3097                             p++;
3098                         }
3099                     }
3100                     size = -1;
3101                     format = -1;
3102                     for(;;) {
3103                         switch(*p) {
3104                         case 'o':
3105                         case 'd':
3106                         case 'u':
3107                         case 'x':
3108                         case 'i':
3109                         case 'c':
3110                             format = *p++;
3111                             break;
3112                         case 'b':
3113                             size = 1;
3114                             p++;
3115                             break;
3116                         case 'h':
3117                             size = 2;
3118                             p++;
3119                             break;
3120                         case 'w':
3121                             size = 4;
3122                             p++;
3123                             break;
3124                         case 'g':
3125                         case 'L':
3126                             size = 8;
3127                             p++;
3128                             break;
3129                         default:
3130                             goto next;
3131                         }
3132                     }
3133                 next:
3134                     if (*p != '\0' && !qemu_isspace(*p)) {
3135                         monitor_printf(mon, "invalid char in format: '%c'\n",
3136                                        *p);
3137                         goto fail;
3138                     }
3139                     if (format < 0)
3140                         format = default_fmt_format;
3141                     if (format != 'i') {
3142                         /* for 'i', not specifying a size gives -1 as size */
3143                         if (size < 0)
3144                             size = default_fmt_size;
3145                         default_fmt_size = size;
3146                     }
3147                     default_fmt_format = format;
3148                 } else {
3149                     count = 1;
3150                     format = default_fmt_format;
3151                     if (format != 'i') {
3152                         size = default_fmt_size;
3153                     } else {
3154                         size = -1;
3155                     }
3156                 }
3157                 qdict_put_int(qdict, "count", count);
3158                 qdict_put_int(qdict, "format", format);
3159                 qdict_put_int(qdict, "size", size);
3160             }
3161             break;
3162         case 'i':
3163         case 'l':
3164         case 'M':
3165             {
3166                 int64_t val;
3167
3168                 while (qemu_isspace(*p))
3169                     p++;
3170                 if (*typestr == '?' || *typestr == '.') {
3171                     if (*typestr == '?') {
3172                         if (*p == '\0') {
3173                             typestr++;
3174                             break;
3175                         }
3176                     } else {
3177                         if (*p == '.') {
3178                             p++;
3179                             while (qemu_isspace(*p))
3180                                 p++;
3181                         } else {
3182                             typestr++;
3183                             break;
3184                         }
3185                     }
3186                     typestr++;
3187                 }
3188                 if (get_expr(mon, &val, &p))
3189                     goto fail;
3190                 /* Check if 'i' is greater than 32-bit */
3191                 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3192                     monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3193                     monitor_printf(mon, "integer is for 32-bit values\n");
3194                     goto fail;
3195                 } else if (c == 'M') {
3196                     if (val < 0) {
3197                         monitor_printf(mon, "enter a positive value\n");
3198                         goto fail;
3199                     }
3200                     val <<= 20;
3201                 }
3202                 qdict_put_int(qdict, key, val);
3203             }
3204             break;
3205         case 'o':
3206             {
3207                 int ret;
3208                 uint64_t val;
3209                 char *end;
3210
3211                 while (qemu_isspace(*p)) {
3212                     p++;
3213                 }
3214                 if (*typestr == '?') {
3215                     typestr++;
3216                     if (*p == '\0') {
3217                         break;
3218                     }
3219                 }
3220                 ret = qemu_strtosz_MiB(p, &end, &val);
3221                 if (ret < 0 || val > INT64_MAX) {
3222                     monitor_printf(mon, "invalid size\n");
3223                     goto fail;
3224                 }
3225                 qdict_put_int(qdict, key, val);
3226                 p = end;
3227             }
3228             break;
3229         case 'T':
3230             {
3231                 double val;
3232
3233                 while (qemu_isspace(*p))
3234                     p++;
3235                 if (*typestr == '?') {
3236                     typestr++;
3237                     if (*p == '\0') {
3238                         break;
3239                     }
3240                 }
3241                 if (get_double(mon, &val, &p) < 0) {
3242                     goto fail;
3243                 }
3244                 if (p[0] && p[1] == 's') {
3245                     switch (*p) {
3246                     case 'm':
3247                         val /= 1e3; p += 2; break;
3248                     case 'u':
3249                         val /= 1e6; p += 2; break;
3250                     case 'n':
3251                         val /= 1e9; p += 2; break;
3252                     }
3253                 }
3254                 if (*p && !qemu_isspace(*p)) {
3255                     monitor_printf(mon, "Unknown unit suffix\n");
3256                     goto fail;
3257                 }
3258                 qdict_put(qdict, key, qnum_from_double(val));
3259             }
3260             break;
3261         case 'b':
3262             {
3263                 const char *beg;
3264                 bool val;
3265
3266                 while (qemu_isspace(*p)) {
3267                     p++;
3268                 }
3269                 beg = p;
3270                 while (qemu_isgraph(*p)) {
3271                     p++;
3272                 }
3273                 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3274                     val = true;
3275                 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3276                     val = false;
3277                 } else {
3278                     monitor_printf(mon, "Expected 'on' or 'off'\n");
3279                     goto fail;
3280                 }
3281                 qdict_put_bool(qdict, key, val);
3282             }
3283             break;
3284         case '-':
3285             {
3286                 const char *tmp = p;
3287                 int skip_key = 0;
3288                 /* option */
3289
3290                 c = *typestr++;
3291                 if (c == '\0')
3292                     goto bad_type;
3293                 while (qemu_isspace(*p))
3294                     p++;
3295                 if (*p == '-') {
3296                     p++;
3297                     if(c != *p) {
3298                         if(!is_valid_option(p, typestr)) {
3299
3300                             monitor_printf(mon, "%s: unsupported option -%c\n",
3301                                            cmd->name, *p);
3302                             goto fail;
3303                         } else {
3304                             skip_key = 1;
3305                         }
3306                     }
3307                     if(skip_key) {
3308                         p = tmp;
3309                     } else {
3310                         /* has option */
3311                         p++;
3312                         qdict_put_bool(qdict, key, true);
3313                     }
3314                 }
3315             }
3316             break;
3317         case 'S':
3318             {
3319                 /* package all remaining string */
3320                 int len;
3321
3322                 while (qemu_isspace(*p)) {
3323                     p++;
3324                 }
3325                 if (*typestr == '?') {
3326                     typestr++;
3327                     if (*p == '\0') {
3328                         /* no remaining string: NULL argument */
3329                         break;
3330                     }
3331                 }
3332                 len = strlen(p);
3333                 if (len <= 0) {
3334                     monitor_printf(mon, "%s: string expected\n",
3335                                    cmd->name);
3336                     goto fail;
3337                 }
3338                 qdict_put_str(qdict, key, p);
3339                 p += len;
3340             }
3341             break;
3342         default:
3343         bad_type:
3344             monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3345             goto fail;
3346         }
3347         g_free(key);
3348         key = NULL;
3349     }
3350     /* check that all arguments were parsed */
3351     while (qemu_isspace(*p))
3352         p++;
3353     if (*p != '\0') {
3354         monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3355                        cmd->name);
3356         goto fail;
3357     }
3358
3359     return qdict;
3360
3361 fail:
3362     qobject_unref(qdict);
3363     g_free(key);
3364     return NULL;
3365 }
3366
3367 static void handle_hmp_command(Monitor *mon, const char *cmdline)
3368 {
3369     QDict *qdict;
3370     const mon_cmd_t *cmd;
3371
3372     trace_handle_hmp_command(mon, cmdline);
3373
3374     cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3375     if (!cmd) {
3376         return;
3377     }
3378
3379     qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3380     if (!qdict) {
3381         monitor_printf(mon, "Try \"help %s\" for more information\n",
3382                        cmd->name);
3383         return;
3384     }
3385
3386     cmd->cmd(mon, qdict);
3387     qobject_unref(qdict);
3388 }
3389
3390 static void cmd_completion(Monitor *mon, const char *name, const char *list)
3391 {
3392     const char *p, *pstart;
3393     char cmd[128];
3394     int len;
3395
3396     p = list;
3397     for(;;) {
3398         pstart = p;
3399         p = strchr(p, '|');
3400         if (!p)
3401             p = pstart + strlen(pstart);
3402         len = p - pstart;
3403         if (len > sizeof(cmd) - 2)
3404             len = sizeof(cmd) - 2;
3405         memcpy(cmd, pstart, len);
3406         cmd[len] = '\0';
3407         if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3408             readline_add_completion(mon->rs, cmd);
3409         }
3410         if (*p == '\0')
3411             break;
3412         p++;
3413     }
3414 }
3415
3416 static void file_completion(Monitor *mon, const char *input)
3417 {
3418     DIR *ffs;
3419     struct dirent *d;
3420     char path[1024];
3421     char file[1024], file_prefix[1024];
3422     int input_path_len;
3423     const char *p;
3424
3425     p = strrchr(input, '/');
3426     if (!p) {
3427         input_path_len = 0;
3428         pstrcpy(file_prefix, sizeof(file_prefix), input);
3429         pstrcpy(path, sizeof(path), ".");
3430     } else {
3431         input_path_len = p - input + 1;
3432         memcpy(path, input, input_path_len);
3433         if (input_path_len > sizeof(path) - 1)
3434             input_path_len = sizeof(path) - 1;
3435         path[input_path_len] = '\0';
3436         pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3437     }
3438
3439     ffs = opendir(path);
3440     if (!ffs)
3441         return;
3442     for(;;) {
3443         struct stat sb;
3444         d = readdir(ffs);
3445         if (!d)
3446             break;
3447
3448         if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3449             continue;
3450         }
3451
3452         if (strstart(d->d_name, file_prefix, NULL)) {
3453             memcpy(file, input, input_path_len);
3454             if (input_path_len < sizeof(file))
3455                 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3456                         d->d_name);
3457             /* stat the file to find out if it's a directory.
3458              * In that case add a slash to speed up typing long paths
3459              */
3460             if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3461                 pstrcat(file, sizeof(file), "/");
3462             }
3463             readline_add_completion(mon->rs, file);
3464         }
3465     }
3466     closedir(ffs);
3467 }
3468
3469 static const char *next_arg_type(const char *typestr)
3470 {
3471     const char *p = strchr(typestr, ':');
3472     return (p != NULL ? ++p : typestr);
3473 }
3474
3475 static void add_completion_option(ReadLineState *rs, const char *str,
3476                                   const char *option)
3477 {
3478     if (!str || !option) {
3479         return;
3480     }
3481     if (!strncmp(option, str, strlen(str))) {
3482         readline_add_completion(rs, option);
3483     }
3484 }
3485
3486 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3487 {
3488     size_t len;
3489     ChardevBackendInfoList *list, *start;
3490
3491     if (nb_args != 2) {
3492         return;
3493     }
3494     len = strlen(str);
3495     readline_set_completion_index(rs, len);
3496
3497     start = list = qmp_query_chardev_backends(NULL);
3498     while (list) {
3499         const char *chr_name = list->value->name;
3500
3501         if (!strncmp(chr_name, str, len)) {
3502             readline_add_completion(rs, chr_name);
3503         }
3504         list = list->next;
3505     }
3506     qapi_free_ChardevBackendInfoList(start);
3507 }
3508
3509 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3510 {
3511     size_t len;
3512     int i;
3513
3514     if (nb_args != 2) {
3515         return;
3516     }
3517     len = strlen(str);
3518     readline_set_completion_index(rs, len);
3519     for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3520         add_completion_option(rs, str, NetClientDriver_str(i));
3521     }
3522 }
3523
3524 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3525 {
3526     GSList *list, *elt;
3527     size_t len;
3528
3529     if (nb_args != 2) {
3530         return;
3531     }
3532
3533     len = strlen(str);
3534     readline_set_completion_index(rs, len);
3535     list = elt = object_class_get_list(TYPE_DEVICE, false);
3536     while (elt) {
3537         const char *name;
3538         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3539                                              TYPE_DEVICE);
3540         name = object_class_get_name(OBJECT_CLASS(dc));
3541
3542         if (dc->user_creatable
3543             && !strncmp(name, str, len)) {
3544             readline_add_completion(rs, name);
3545         }
3546         elt = elt->next;
3547     }
3548     g_slist_free(list);
3549 }
3550
3551 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3552 {
3553     GSList *list, *elt;
3554     size_t len;
3555
3556     if (nb_args != 2) {
3557         return;
3558     }
3559
3560     len = strlen(str);
3561     readline_set_completion_index(rs, len);
3562     list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3563     while (elt) {
3564         const char *name;
3565
3566         name = object_class_get_name(OBJECT_CLASS(elt->data));
3567         if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3568             readline_add_completion(rs, name);
3569         }
3570         elt = elt->next;
3571     }
3572     g_slist_free(list);
3573 }
3574
3575 static void peripheral_device_del_completion(ReadLineState *rs,
3576                                              const char *str, size_t len)
3577 {
3578     Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3579     GSList *list, *item;
3580
3581     list = qdev_build_hotpluggable_device_list(peripheral);
3582     if (!list) {
3583         return;
3584     }
3585
3586     for (item = list; item; item = g_slist_next(item)) {
3587         DeviceState *dev = item->data;
3588
3589         if (dev->id && !strncmp(str, dev->id, len)) {
3590             readline_add_completion(rs, dev->id);
3591         }
3592     }
3593
3594     g_slist_free(list);
3595 }
3596
3597 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3598 {
3599     size_t len;
3600     ChardevInfoList *list, *start;
3601
3602     if (nb_args != 2) {
3603         return;
3604     }
3605     len = strlen(str);
3606     readline_set_completion_index(rs, len);
3607
3608     start = list = qmp_query_chardev(NULL);
3609     while (list) {
3610         ChardevInfo *chr = list->value;
3611
3612         if (!strncmp(chr->label, str, len)) {
3613             readline_add_completion(rs, chr->label);
3614         }
3615         list = list->next;
3616     }
3617     qapi_free_ChardevInfoList(start);
3618 }
3619
3620 static void ringbuf_completion(ReadLineState *rs, const char *str)
3621 {
3622     size_t len;
3623     ChardevInfoList *list, *start;
3624
3625     len = strlen(str);
3626     readline_set_completion_index(rs, len);
3627
3628     start = list = qmp_query_chardev(NULL);
3629     while (list) {
3630         ChardevInfo *chr_info = list->value;
3631
3632         if (!strncmp(chr_info->label, str, len)) {
3633             Chardev *chr = qemu_chr_find(chr_info->label);
3634             if (chr && CHARDEV_IS_RINGBUF(chr)) {
3635                 readline_add_completion(rs, chr_info->label);
3636             }
3637         }
3638         list = list->next;
3639     }
3640     qapi_free_ChardevInfoList(start);
3641 }
3642
3643 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3644 {
3645     if (nb_args != 2) {
3646         return;
3647     }
3648     ringbuf_completion(rs, str);
3649 }
3650
3651 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3652 {
3653     size_t len;
3654
3655     if (nb_args != 2) {
3656         return;
3657     }
3658
3659     len = strlen(str);
3660     readline_set_completion_index(rs, len);
3661     peripheral_device_del_completion(rs, str, len);
3662 }
3663
3664 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3665 {
3666     ObjectPropertyInfoList *list, *start;
3667     size_t len;
3668
3669     if (nb_args != 2) {
3670         return;
3671     }
3672     len = strlen(str);
3673     readline_set_completion_index(rs, len);
3674
3675     start = list = qmp_qom_list("/objects", NULL);
3676     while (list) {
3677         ObjectPropertyInfo *info = list->value;
3678
3679         if (!strncmp(info->type, "child<", 5)
3680             && !strncmp(info->name, str, len)) {
3681             readline_add_completion(rs, info->name);
3682         }
3683         list = list->next;
3684     }
3685     qapi_free_ObjectPropertyInfoList(start);
3686 }
3687
3688 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3689 {
3690     int i;
3691     char *sep;
3692     size_t len;
3693
3694     if (nb_args != 2) {
3695         return;
3696     }
3697     sep = strrchr(str, '-');
3698     if (sep) {
3699         str = sep + 1;
3700     }
3701     len = strlen(str);
3702     readline_set_completion_index(rs, len);
3703     for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3704         if (!strncmp(str, QKeyCode_str(i), len)) {
3705             readline_add_completion(rs, QKeyCode_str(i));
3706         }
3707     }
3708 }
3709
3710 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3711 {
3712     size_t len;
3713
3714     len = strlen(str);
3715     readline_set_completion_index(rs, len);
3716     if (nb_args == 2) {
3717         NetClientState *ncs[MAX_QUEUE_NUM];
3718         int count, i;
3719         count = qemu_find_net_clients_except(NULL, ncs,
3720                                              NET_CLIENT_DRIVER_NONE,
3721                                              MAX_QUEUE_NUM);
3722         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3723             const char *name = ncs[i]->name;
3724             if (!strncmp(str, name, len)) {
3725                 readline_add_completion(rs, name);
3726             }
3727         }
3728     } else if (nb_args == 3) {
3729         add_completion_option(rs, str, "on");
3730         add_completion_option(rs, str, "off");
3731     }
3732 }
3733
3734 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3735 {
3736     int len, count, i;
3737     NetClientState *ncs[MAX_QUEUE_NUM];
3738
3739     if (nb_args != 2) {
3740         return;
3741     }
3742
3743     len = strlen(str);
3744     readline_set_completion_index(rs, len);
3745     count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3746                                          MAX_QUEUE_NUM);
3747     for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3748         QemuOpts *opts;
3749         const char *name = ncs[i]->name;
3750         if (strncmp(str, name, len)) {
3751             continue;
3752         }
3753         opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3754         if (opts) {
3755             readline_add_completion(rs, name);
3756         }
3757     }
3758 }
3759
3760 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3761 {
3762     size_t len;
3763
3764     len = strlen(str);
3765     readline_set_completion_index(rs, len);
3766     if (nb_args == 2) {
3767         TraceEventIter iter;
3768         TraceEvent *ev;
3769         char *pattern = g_strdup_printf("%s*", str);
3770         trace_event_iter_init(&iter, pattern);
3771         while ((ev = trace_event_iter_next(&iter)) != NULL) {
3772             readline_add_completion(rs, trace_event_get_name(ev));
3773         }
3774         g_free(pattern);
3775     }
3776 }
3777
3778 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3779 {
3780     size_t len;
3781
3782     len = strlen(str);
3783     readline_set_completion_index(rs, len);
3784     if (nb_args == 2) {
3785         TraceEventIter iter;
3786         TraceEvent *ev;
3787         char *pattern = g_strdup_printf("%s*", str);
3788         trace_event_iter_init(&iter, pattern);
3789         while ((ev = trace_event_iter_next(&iter)) != NULL) {
3790             readline_add_completion(rs, trace_event_get_name(ev));
3791         }
3792         g_free(pattern);
3793     } else if (nb_args == 3) {
3794         add_completion_option(rs, str, "on");
3795         add_completion_option(rs, str, "off");
3796     }
3797 }
3798
3799 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3800 {
3801     int i;
3802
3803     if (nb_args != 2) {
3804         return;
3805     }
3806     readline_set_completion_index(rs, strlen(str));
3807     for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3808         add_completion_option(rs, str, WatchdogAction_str(i));
3809     }
3810 }
3811
3812 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3813                                        const char *str)
3814 {
3815     size_t len;
3816
3817     len = strlen(str);
3818     readline_set_completion_index(rs, len);
3819     if (nb_args == 2) {
3820         int i;
3821         for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3822             const char *name = MigrationCapability_str(i);
3823             if (!strncmp(str, name, len)) {
3824                 readline_add_completion(rs, name);
3825             }
3826         }
3827     } else if (nb_args == 3) {
3828         add_completion_option(rs, str, "on");
3829         add_completion_option(rs, str, "off");
3830     }
3831 }
3832
3833 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3834                                       const char *str)
3835 {
3836     size_t len;
3837
3838     len = strlen(str);
3839     readline_set_completion_index(rs, len);
3840     if (nb_args == 2) {
3841         int i;
3842         for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3843             const char *name = MigrationParameter_str(i);
3844             if (!strncmp(str, name, len)) {
3845                 readline_add_completion(rs, name);
3846             }
3847         }
3848     }
3849 }
3850
3851 static void vm_completion(ReadLineState *rs, const char *str)
3852 {
3853     size_t len;
3854     BlockDriverState *bs;
3855     BdrvNextIterator it;
3856
3857     len = strlen(str);
3858     readline_set_completion_index(rs, len);
3859
3860     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3861         SnapshotInfoList *snapshots, *snapshot;
3862         AioContext *ctx = bdrv_get_aio_context(bs);
3863         bool ok = false;
3864
3865         aio_context_acquire(ctx);
3866         if (bdrv_can_snapshot(bs)) {
3867             ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3868         }
3869         aio_context_release(ctx);
3870         if (!ok) {
3871             continue;
3872         }
3873
3874         snapshot = snapshots;
3875         while (snapshot) {
3876             char *completion = snapshot->value->name;
3877             if (!strncmp(str, completion, len)) {
3878                 readline_add_completion(rs, completion);
3879             }
3880             completion = snapshot->value->id;
3881             if (!strncmp(str, completion, len)) {
3882                 readline_add_completion(rs, completion);
3883             }
3884             snapshot = snapshot->next;
3885         }
3886         qapi_free_SnapshotInfoList(snapshots);
3887     }
3888
3889 }
3890
3891 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3892 {
3893     if (nb_args == 2) {
3894         vm_completion(rs, str);
3895     }
3896 }
3897
3898 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3899 {
3900     if (nb_args == 2) {
3901         vm_completion(rs, str);
3902     }
3903 }
3904
3905 static void monitor_find_completion_by_table(Monitor *mon,
3906                                              const mon_cmd_t *cmd_table,
3907                                              char **args,
3908                                              int nb_args)
3909 {
3910     const char *cmdname;
3911     int i;
3912     const char *ptype, *old_ptype, *str, *name;
3913     const mon_cmd_t *cmd;
3914     BlockBackend *blk = NULL;
3915
3916     if (nb_args <= 1) {
3917         /* command completion */
3918         if (nb_args == 0)
3919             cmdname = "";
3920         else
3921             cmdname = args[0];
3922         readline_set_completion_index(mon->rs, strlen(cmdname));
3923         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3924             cmd_completion(mon, cmdname, cmd->name);
3925         }
3926     } else {
3927         /* find the command */
3928         for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3929             if (compare_cmd(args[0], cmd->name)) {
3930                 break;
3931             }
3932         }
3933         if (!cmd->name) {
3934             return;
3935         }
3936
3937         if (cmd->sub_table) {
3938             /* do the job again */
3939             monitor_find_completion_by_table(mon, cmd->sub_table,
3940                                              &args[1], nb_args - 1);
3941             return;
3942         }
3943         if (cmd->command_completion) {
3944             cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3945             return;
3946         }
3947
3948         ptype = next_arg_type(cmd->args_type);
3949         for(i = 0; i < nb_args - 2; i++) {
3950             if (*ptype != '\0') {
3951                 ptype = next_arg_type(ptype);
3952                 while (*ptype == '?')
3953                     ptype = next_arg_type(ptype);
3954             }
3955         }
3956         str = args[nb_args - 1];
3957         old_ptype = NULL;
3958         while (*ptype == '-' && old_ptype != ptype) {
3959             old_ptype = ptype;
3960             ptype = next_arg_type(ptype);
3961         }
3962         switch(*ptype) {
3963         case 'F':
3964             /* file completion */
3965             readline_set_completion_index(mon->rs, strlen(str));
3966             file_completion(mon, str);
3967             break;
3968         case 'B':
3969             /* block device name completion */
3970             readline_set_completion_index(mon->rs, strlen(str));
3971             while ((blk = blk_next(blk)) != NULL) {
3972                 name = blk_name(blk);
3973                 if (str[0] == '\0' ||
3974                     !strncmp(name, str, strlen(str))) {
3975                     readline_add_completion(mon->rs, name);
3976                 }
3977             }
3978             break;
3979         case 's':
3980         case 'S':
3981             if (!strcmp(cmd->name, "help|?")) {
3982                 monitor_find_completion_by_table(mon, cmd_table,
3983                                                  &args[1], nb_args - 1);
3984             }
3985             break;
3986         default:
3987             break;
3988         }
3989     }
3990 }
3991
3992 static void monitor_find_completion(void *opaque,
3993                                     const char *cmdline)
3994 {
3995     Monitor *mon = opaque;
3996     char *args[MAX_ARGS];
3997     int nb_args, len;
3998
3999     /* 1. parse the cmdline */
4000     if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4001         return;
4002     }
4003
4004     /* if the line ends with a space, it means we want to complete the
4005        next arg */
4006     len = strlen(cmdline);
4007     if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4008         if (nb_args >= MAX_ARGS) {
4009             goto cleanup;
4010         }
4011         args[nb_args++] = g_strdup("");
4012     }
4013
4014     /* 2. auto complete according to args */
4015     monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4016
4017 cleanup:
4018     free_cmdline_args(args, nb_args);
4019 }
4020
4021 static int monitor_can_read(void *opaque)
4022 {
4023     Monitor *mon = opaque;
4024
4025     return !atomic_mb_read(&mon->suspend_cnt);
4026 }
4027
4028 /*
4029  * 1. This function takes ownership of rsp, err, and id.
4030  * 2. rsp, err, and id may be NULL.
4031  * 3. If err != NULL then rsp must be NULL.
4032  */
4033 static void monitor_qmp_respond(Monitor *mon, QObject *rsp,
4034                                 Error *err, QObject *id)
4035 {
4036     QDict *qdict = NULL;
4037
4038     if (err) {
4039         assert(!rsp);
4040         qdict = qdict_new();
4041         qdict_put_obj(qdict, "error", qmp_build_error_object(err));
4042         error_free(err);
4043         rsp = QOBJECT(qdict);
4044     }
4045
4046     if (rsp) {
4047         if (id) {
4048             qdict_put_obj(qobject_to(QDict, rsp), "id", qobject_ref(id));
4049         }
4050
4051         monitor_json_emitter(mon, rsp);
4052     }
4053
4054     qobject_unref(id);
4055     qobject_unref(rsp);
4056 }
4057
4058 /*
4059  * Dispatch one single QMP request. The function will free the req_obj
4060  * and objects inside it before return.
4061  */
4062 static void monitor_qmp_dispatch_one(QMPRequest *req_obj)
4063 {
4064     Monitor *mon, *old_mon;
4065     QObject *req, *rsp = NULL, *id;
4066     bool need_resume;
4067
4068     req = req_obj->req;
4069     mon = req_obj->mon;
4070     id = req_obj->id;
4071     need_resume = req_obj->need_resume;
4072
4073     g_free(req_obj);
4074
4075     if (trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4076         QString *req_json = qobject_to_json(req);
4077         trace_handle_qmp_command(mon, qstring_get_str(req_json));
4078         qobject_unref(req_json);
4079     }
4080
4081     old_mon = cur_mon;
4082     cur_mon = mon;
4083
4084     rsp = qmp_dispatch(mon->qmp.commands, req);
4085
4086     cur_mon = old_mon;
4087
4088     /* Respond if necessary */
4089     monitor_qmp_respond(mon, rsp, NULL, id);
4090
4091     /* This pairs with the monitor_suspend() in handle_qmp_command(). */
4092     if (need_resume) {
4093         monitor_resume(mon);
4094     }
4095
4096     qobject_unref(req);
4097 }
4098
4099 /*
4100  * Pop one QMP request from monitor queues, return NULL if not found.
4101  * We are using round-robin fashion to pop the request, to avoid
4102  * processing commands only on a very busy monitor.  To achieve that,
4103  * when we process one request on a specific monitor, we put that
4104  * monitor to the end of mon_list queue.
4105  */
4106 static QMPRequest *monitor_qmp_requests_pop_one(void)
4107 {
4108     QMPRequest *req_obj = NULL;
4109     Monitor *mon;
4110
4111     qemu_mutex_lock(&monitor_lock);
4112
4113     QTAILQ_FOREACH(mon, &mon_list, entry) {
4114         qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4115         req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4116         qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4117         if (req_obj) {
4118             break;
4119         }
4120     }
4121
4122     if (req_obj) {
4123         /*
4124          * We found one request on the monitor. Degrade this monitor's
4125          * priority to lowest by re-inserting it to end of queue.
4126          */
4127         QTAILQ_REMOVE(&mon_list, mon, entry);
4128         QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4129     }
4130
4131     qemu_mutex_unlock(&monitor_lock);
4132
4133     return req_obj;
4134 }
4135
4136 static void monitor_qmp_bh_dispatcher(void *data)
4137 {
4138     QMPRequest *req_obj = monitor_qmp_requests_pop_one();
4139
4140     if (req_obj) {
4141         trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4142         monitor_qmp_dispatch_one(req_obj);
4143         /* Reschedule instead of looping so the main loop stays responsive */
4144         qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4145     }
4146 }
4147
4148 #define  QMP_REQ_QUEUE_LEN_MAX  (8)
4149
4150 static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
4151 {
4152     QObject *req, *id = NULL;
4153     QDict *qdict = NULL;
4154     MonitorQMP *mon_qmp = container_of(parser, MonitorQMP, parser);
4155     Monitor *mon = container_of(mon_qmp, Monitor, qmp);
4156     Error *err = NULL;
4157     QMPRequest *req_obj;
4158
4159     req = json_parser_parse_err(tokens, NULL, &err);
4160     if (!req && !err) {
4161         /* json_parser_parse_err() sucks: can fail without setting @err */
4162         error_setg(&err, QERR_JSON_PARSING);
4163     }
4164     if (err) {
4165         goto err;
4166     }
4167
4168     /* Check against the request in general layout */
4169     qdict = qmp_dispatch_check_obj(req, &err);
4170     if (!qdict) {
4171         goto err;
4172     }
4173
4174     /* Check against OOB specific */
4175     if (!qmp_cmd_oob_check(mon, qdict, &err)) {
4176         goto err;
4177     }
4178
4179     id = qdict_get(qdict, "id");
4180
4181     /* When OOB is enabled, the "id" field is mandatory. */
4182     if (qmp_oob_enabled(mon) && !id) {
4183         error_setg(&err, "Out-Of-Band capability requires that "
4184                    "every command contains an 'id' field");
4185         goto err;
4186     }
4187
4188     req_obj = g_new0(QMPRequest, 1);
4189     req_obj->mon = mon;
4190     req_obj->id = qobject_ref(id);
4191     req_obj->req = req;
4192     req_obj->need_resume = false;
4193
4194     qdict_del(qdict, "id");
4195
4196     if (qmp_is_oob(qdict)) {
4197         /* Out-Of-Band (OOB) requests are executed directly in parser. */
4198         trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(req_obj->id)
4199                                           ?: "");
4200         monitor_qmp_dispatch_one(req_obj);
4201         return;
4202     }
4203
4204     /* Protect qmp_requests and fetching its length. */
4205     qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4206
4207     /*
4208      * If OOB is not enabled on the current monitor, we'll emulate the
4209      * old behavior that we won't process the current monitor any more
4210      * until it has responded.  This helps make sure that as long as
4211      * OOB is not enabled, the server will never drop any command.
4212      */
4213     if (!qmp_oob_enabled(mon)) {
4214         monitor_suspend(mon);
4215         req_obj->need_resume = true;
4216     } else {
4217         /* Drop the request if queue is full. */
4218         if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4219             qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4220             qapi_event_send_command_dropped(id,
4221                                             COMMAND_DROP_REASON_QUEUE_FULL,
4222                                             &error_abort);
4223             qmp_request_free(req_obj);
4224             return;
4225         }
4226     }
4227
4228     /*
4229      * Put the request to the end of queue so that requests will be
4230      * handled in time order.  Ownership for req_obj, req, id,
4231      * etc. will be delivered to the handler side.
4232      */
4233     g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4234     qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4235
4236     /* Kick the dispatcher routine */
4237     qemu_bh_schedule(mon_global.qmp_dispatcher_bh);
4238     return;
4239
4240 err:
4241     monitor_qmp_respond(mon, NULL, err, NULL);
4242     qobject_unref(req);
4243 }
4244
4245 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4246 {
4247     Monitor *mon = opaque;
4248
4249     json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4250 }
4251
4252 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4253 {
4254     Monitor *old_mon = cur_mon;
4255     int i;
4256
4257     cur_mon = opaque;
4258
4259     if (cur_mon->rs) {
4260         for (i = 0; i < size; i++)
4261             readline_handle_byte(cur_mon->rs, buf[i]);
4262     } else {
4263         if (size == 0 || buf[size - 1] != 0)
4264             monitor_printf(cur_mon, "corrupted command\n");
4265         else
4266             handle_hmp_command(cur_mon, (char *)buf);
4267     }
4268
4269     cur_mon = old_mon;
4270 }
4271
4272 static void monitor_command_cb(void *opaque, const char *cmdline,
4273                                void *readline_opaque)
4274 {
4275     Monitor *mon = opaque;
4276
4277     monitor_suspend(mon);
4278     handle_hmp_command(mon, cmdline);
4279     monitor_resume(mon);
4280 }
4281
4282 int monitor_suspend(Monitor *mon)
4283 {
4284     if (monitor_is_hmp_non_interactive(mon)) {
4285         return -ENOTTY;
4286     }
4287
4288     atomic_inc(&mon->suspend_cnt);
4289
4290     if (monitor_is_qmp(mon)) {
4291         /*
4292          * Kick iothread to make sure this takes effect.  It'll be
4293          * evaluated again in prepare() of the watch object.
4294          */
4295         aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4296     }
4297
4298     trace_monitor_suspend(mon, 1);
4299     return 0;
4300 }
4301
4302 void monitor_resume(Monitor *mon)
4303 {
4304     if (monitor_is_hmp_non_interactive(mon)) {
4305         return;
4306     }
4307
4308     if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4309         if (monitor_is_qmp(mon)) {
4310             /*
4311              * For QMP monitors that are running in IOThread, let's
4312              * kick the thread in case it's sleeping.
4313              */
4314             if (mon->use_io_thr) {
4315                 aio_notify(iothread_get_aio_context(mon_global.mon_iothread));
4316             }
4317         } else {
4318             assert(mon->rs);
4319             readline_show_prompt(mon->rs);
4320         }
4321     }
4322     trace_monitor_suspend(mon, -1);
4323 }
4324
4325 static QObject *get_qmp_greeting(Monitor *mon)
4326 {
4327     QList *cap_list = qlist_new();
4328     QObject *ver = NULL;
4329     QMPCapability cap;
4330
4331     qmp_marshal_query_version(NULL, &ver, NULL);
4332
4333     for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4334         if (!mon->use_io_thr && cap == QMP_CAPABILITY_OOB) {
4335             /* Monitors that are not using IOThread won't support OOB */
4336             continue;
4337         }
4338         qlist_append_str(cap_list, QMPCapability_str(cap));
4339     }
4340
4341     return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': %p}}",
4342                               ver, cap_list);
4343 }
4344
4345 static void monitor_qmp_caps_reset(Monitor *mon)
4346 {
4347     memset(mon->qmp.qmp_caps, 0, sizeof(mon->qmp.qmp_caps));
4348 }
4349
4350 static void monitor_qmp_event(void *opaque, int event)
4351 {
4352     QObject *data;
4353     Monitor *mon = opaque;
4354
4355     switch (event) {
4356     case CHR_EVENT_OPENED:
4357         mon->qmp.commands = &qmp_cap_negotiation_commands;
4358         monitor_qmp_caps_reset(mon);
4359         data = get_qmp_greeting(mon);
4360         monitor_json_emitter(mon, data);
4361         qobject_unref(data);
4362         mon_refcount++;
4363         break;
4364     case CHR_EVENT_CLOSED:
4365         monitor_qmp_cleanup_queues(mon);
4366         json_message_parser_destroy(&mon->qmp.parser);
4367         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4368         mon_refcount--;
4369         monitor_fdsets_cleanup();
4370         break;
4371     }
4372 }
4373
4374 static void monitor_event(void *opaque, int event)
4375 {
4376     Monitor *mon = opaque;
4377
4378     switch (event) {
4379     case CHR_EVENT_MUX_IN:
4380         qemu_mutex_lock(&mon->out_lock);
4381         mon->mux_out = 0;
4382         qemu_mutex_unlock(&mon->out_lock);
4383         if (mon->reset_seen) {
4384             readline_restart(mon->rs);
4385             monitor_resume(mon);
4386             monitor_flush(mon);
4387         } else {
4388             atomic_mb_set(&mon->suspend_cnt, 0);
4389         }
4390         break;
4391
4392     case CHR_EVENT_MUX_OUT:
4393         if (mon->reset_seen) {
4394             if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4395                 monitor_printf(mon, "\n");
4396             }
4397             monitor_flush(mon);
4398             monitor_suspend(mon);
4399         } else {
4400             atomic_inc(&mon->suspend_cnt);
4401         }
4402         qemu_mutex_lock(&mon->out_lock);
4403         mon->mux_out = 1;
4404         qemu_mutex_unlock(&mon->out_lock);
4405         break;
4406
4407     case CHR_EVENT_OPENED:
4408         monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4409                        "information\n", QEMU_VERSION);
4410         if (!mon->mux_out) {
4411             readline_restart(mon->rs);
4412             readline_show_prompt(mon->rs);
4413         }
4414         mon->reset_seen = 1;
4415         mon_refcount++;
4416         break;
4417
4418     case CHR_EVENT_CLOSED:
4419         mon_refcount--;
4420         monitor_fdsets_cleanup();
4421         break;
4422     }
4423 }
4424
4425 static int
4426 compare_mon_cmd(const void *a, const void *b)
4427 {
4428     return strcmp(((const mon_cmd_t *)a)->name,
4429             ((const mon_cmd_t *)b)->name);
4430 }
4431
4432 static void sortcmdlist(void)
4433 {
4434     int array_num;
4435     int elem_size = sizeof(mon_cmd_t);
4436
4437     array_num = sizeof(mon_cmds)/elem_size-1;
4438     qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4439
4440     array_num = sizeof(info_cmds)/elem_size-1;
4441     qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4442 }
4443
4444 static GMainContext *monitor_get_io_context(void)
4445 {
4446     return iothread_get_g_main_context(mon_global.mon_iothread);
4447 }
4448
4449 static AioContext *monitor_get_aio_context(void)
4450 {
4451     return iothread_get_aio_context(mon_global.mon_iothread);
4452 }
4453
4454 static void monitor_iothread_init(void)
4455 {
4456     mon_global.mon_iothread = iothread_create("mon_iothread",
4457                                               &error_abort);
4458
4459     /*
4460      * This MUST be on main loop thread since we have commands that
4461      * have assumption to be run on main loop thread.  It would be
4462      * nice that one day we can remove this assumption in the future.
4463      */
4464     mon_global.qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4465                                               monitor_qmp_bh_dispatcher,
4466                                               NULL);
4467
4468     /*
4469      * Unlike the dispatcher BH, this must be run on the monitor IO
4470      * thread, so that monitors that are using IO thread will make
4471      * sure read/write operations are all done on the IO thread.
4472      */
4473     mon_global.qmp_respond_bh = aio_bh_new(monitor_get_aio_context(),
4474                                            monitor_qmp_bh_responder,
4475                                            NULL);
4476 }
4477
4478 void monitor_init_globals(void)
4479 {
4480     monitor_init_qmp_commands();
4481     monitor_qapi_event_init();
4482     sortcmdlist();
4483     qemu_mutex_init(&monitor_lock);
4484     monitor_iothread_init();
4485 }
4486
4487 /* These functions just adapt the readline interface in a typesafe way.  We
4488  * could cast function pointers but that discards compiler checks.
4489  */
4490 static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4491                                                        const char *fmt, ...)
4492 {
4493     va_list ap;
4494     va_start(ap, fmt);
4495     monitor_vprintf(opaque, fmt, ap);
4496     va_end(ap);
4497 }
4498
4499 static void monitor_readline_flush(void *opaque)
4500 {
4501     monitor_flush(opaque);
4502 }
4503
4504 /*
4505  * Print to current monitor if we have one, else to stderr.
4506  * TODO should return int, so callers can calculate width, but that
4507  * requires surgery to monitor_vprintf().  Left for another day.
4508  */
4509 void error_vprintf(const char *fmt, va_list ap)
4510 {
4511     if (cur_mon && !monitor_cur_is_qmp()) {
4512         monitor_vprintf(cur_mon, fmt, ap);
4513     } else {
4514         vfprintf(stderr, fmt, ap);
4515     }
4516 }
4517
4518 void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4519 {
4520     if (cur_mon && !monitor_cur_is_qmp()) {
4521         monitor_vprintf(cur_mon, fmt, ap);
4522     } else if (!cur_mon) {
4523         vfprintf(stderr, fmt, ap);
4524     }
4525 }
4526
4527 static void monitor_list_append(Monitor *mon)
4528 {
4529     qemu_mutex_lock(&monitor_lock);
4530     QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4531     qemu_mutex_unlock(&monitor_lock);
4532 }
4533
4534 static void monitor_qmp_setup_handlers_bh(void *opaque)
4535 {
4536     Monitor *mon = opaque;
4537     GMainContext *context;
4538
4539     if (mon->use_io_thr) {
4540         /*
4541          * When use_io_thr is set, we use the global shared dedicated
4542          * IO thread for this monitor to handle input/output.
4543          */
4544         context = monitor_get_io_context();
4545         /* We should have inited globals before reaching here. */
4546         assert(context);
4547     } else {
4548         /* The default main loop, which is the main thread */
4549         context = NULL;
4550     }
4551
4552     qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4553                              monitor_qmp_event, NULL, mon, context, true);
4554     monitor_list_append(mon);
4555 }
4556
4557 void monitor_init(Chardev *chr, int flags)
4558 {
4559     Monitor *mon = g_malloc(sizeof(*mon));
4560     bool use_readline = flags & MONITOR_USE_READLINE;
4561     bool use_oob = flags & MONITOR_USE_OOB;
4562
4563     if (use_oob) {
4564         if (CHARDEV_IS_MUX(chr)) {
4565             error_report("Monitor Out-Of-Band is not supported with "
4566                          "MUX typed chardev backend");
4567             exit(1);
4568         }
4569         if (use_readline) {
4570             error_report("Monitor Out-Of-band is only supported by QMP");
4571             exit(1);
4572         }
4573     }
4574
4575     monitor_data_init(mon, false, use_oob);
4576
4577     qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4578     mon->flags = flags;
4579     if (use_readline) {
4580         mon->rs = readline_init(monitor_readline_printf,
4581                                 monitor_readline_flush,
4582                                 mon,
4583                                 monitor_find_completion);
4584         monitor_read_command(mon, 0);
4585     }
4586
4587     if (monitor_is_qmp(mon)) {
4588         qemu_chr_fe_set_echo(&mon->chr, true);
4589         json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
4590         if (mon->use_io_thr) {
4591             /*
4592              * Make sure the old iowatch is gone.  It's possible when
4593              * e.g. the chardev is in client mode, with wait=on.
4594              */
4595             remove_fd_in_watch(chr);
4596             /*
4597              * We can't call qemu_chr_fe_set_handlers() directly here
4598              * since during the procedure the chardev will be active
4599              * and running in monitor iothread, while we'll still do
4600              * something before returning from it, which is a possible
4601              * race too.  To avoid that, we just create a BH to setup
4602              * the handlers.
4603              */
4604             aio_bh_schedule_oneshot(monitor_get_aio_context(),
4605                                     monitor_qmp_setup_handlers_bh, mon);
4606             /* We'll add this to mon_list in the BH when setup done */
4607             return;
4608         } else {
4609             qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4610                                      monitor_qmp_read, monitor_qmp_event,
4611                                      NULL, mon, NULL, true);
4612         }
4613     } else {
4614         qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4615                                  monitor_event, NULL, mon, NULL, true);
4616     }
4617
4618     monitor_list_append(mon);
4619 }
4620
4621 void monitor_cleanup(void)
4622 {
4623     Monitor *mon, *next;
4624
4625     /*
4626      * We need to explicitly stop the iothread (but not destroy it),
4627      * cleanup the monitor resources, then destroy the iothread since
4628      * we need to unregister from chardev below in
4629      * monitor_data_destroy(), and chardev is not thread-safe yet
4630      */
4631     iothread_stop(mon_global.mon_iothread);
4632
4633     /*
4634      * After we have IOThread to send responses, it's possible that
4635      * when we stop the IOThread there are still replies queued in the
4636      * responder queue.  Flush all of them.  Note that even after this
4637      * flush it's still possible that out buffer is not flushed.
4638      * It'll be done in below monitor_flush() as the last resort.
4639      */
4640     monitor_qmp_bh_responder(NULL);
4641
4642     qemu_mutex_lock(&monitor_lock);
4643     QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4644         QTAILQ_REMOVE(&mon_list, mon, entry);
4645         monitor_flush(mon);
4646         monitor_data_destroy(mon);
4647         g_free(mon);
4648     }
4649     qemu_mutex_unlock(&monitor_lock);
4650
4651     /* QEMUBHs needs to be deleted before destroying the IOThread. */
4652     qemu_bh_delete(mon_global.qmp_dispatcher_bh);
4653     mon_global.qmp_dispatcher_bh = NULL;
4654     qemu_bh_delete(mon_global.qmp_respond_bh);
4655     mon_global.qmp_respond_bh = NULL;
4656
4657     iothread_destroy(mon_global.mon_iothread);
4658     mon_global.mon_iothread = NULL;
4659 }
4660
4661 QemuOptsList qemu_mon_opts = {
4662     .name = "mon",
4663     .implied_opt_name = "chardev",
4664     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4665     .desc = {
4666         {
4667             .name = "mode",
4668             .type = QEMU_OPT_STRING,
4669         },{
4670             .name = "chardev",
4671             .type = QEMU_OPT_STRING,
4672         },{
4673             .name = "pretty",
4674             .type = QEMU_OPT_BOOL,
4675         },{
4676             .name = "x-oob",
4677             .type = QEMU_OPT_BOOL,
4678         },
4679         { /* end of list */ }
4680     },
4681 };
4682
4683 #ifndef TARGET_I386
4684 void qmp_rtc_reset_reinjection(Error **errp)
4685 {
4686     error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4687 }
4688
4689 SevInfo *qmp_query_sev(Error **errp)
4690 {
4691     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4692     return NULL;
4693 }
4694
4695 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4696 {
4697     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4698     return NULL;
4699 }
4700
4701 SevCapability *qmp_query_sev_capabilities(Error **errp)
4702 {
4703     error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4704     return NULL;
4705 }
4706 #endif
4707
4708 #ifndef TARGET_S390X
4709 void qmp_dump_skeys(const char *filename, Error **errp)
4710 {
4711     error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4712 }
4713 #endif
4714
4715 #ifndef TARGET_ARM
4716 GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4717 {
4718     error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4719     return NULL;
4720 }
4721 #endif
4722
4723 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4724 {
4725     MachineState *ms = MACHINE(qdev_get_machine());
4726     MachineClass *mc = MACHINE_GET_CLASS(ms);
4727
4728     if (!mc->has_hotpluggable_cpus) {
4729         error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4730         return NULL;
4731     }
4732
4733     return machine_query_hotpluggable_cpus(ms);
4734 }