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