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