monitor/misc.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 "monitor-internal.h"
  27 #include "cpu.h"
  28 #include "monitor/qdev.h"
  29 #include "hw/usb.h"
  30 #include "hw/pci/pci.h"
  31 #include "sysemu/watchdog.h"
  32 #include "hw/loader.h"
  33 #include "exec/gdbstub.h"
  34 #include "net/net.h"
  35 #include "net/slirp.h"
  36 #include "chardev/char-mux.h"
  37 #include "ui/qemu-spice.h"
  38 #include "qemu/config-file.h"
  39 #include "qemu/ctype.h"
  40 #include "ui/console.h"
  41 #include "ui/input.h"
  42 #include "audio/audio.h"
  43 #include "disas/disas.h"
  44 #include "sysemu/balloon.h"
  45 #include "qemu/timer.h"
  46 #include "sysemu/hw_accel.h"
  47 #include "sysemu/runstate.h"
  48 #include "authz/list.h"
  49 #include "qapi/util.h"
  50 #include "sysemu/blockdev.h"
  51 #include "sysemu/sysemu.h"
  52 #include "sysemu/tcg.h"
  53 #include "sysemu/tpm.h"
  54 #include "qapi/qmp/qdict.h"
  55 #include "qapi/qmp/qerror.h"
  56 #include "qapi/qmp/qstring.h"
  57 #include "qom/object_interfaces.h"
  58 #include "trace/control.h"
  59 #include "monitor/hmp-target.h"
  60 #include "monitor/hmp.h"
  61 #ifdef CONFIG_TRACE_SIMPLE
  62 #include "trace/simple.h"
  63 #endif
  64 #include "exec/memory.h"
  65 #include "exec/exec-all.h"
  66 #include "qemu/option.h"
  67 #include "qemu/thread.h"
  68 #include "block/qapi.h"
  69 #include "qapi/qapi-commands-char.h"
  70 #include "qapi/qapi-commands-control.h"
  71 #include "qapi/qapi-commands-migration.h"
  72 #include "qapi/qapi-commands-misc.h"
  73 #include "qapi/qapi-commands-qom.h"
  74 #include "qapi/qapi-commands-trace.h"
  75 #include "qapi/qapi-init-commands.h"
  76 #include "qapi/error.h"
  77 #include "qapi/qmp-event.h"
  78 #include "qapi/qapi-introspect.h"
  79 #include "sysemu/cpus.h"
  80 #include "qemu/cutils.h"
  81 #include "tcg/tcg.h"
  82
  83 #if defined(TARGET_S390X)
  84 #include "hw/s390x/storage-keys.h"
  85 #include "hw/s390x/storage-attributes.h"
  86 #endif
  87
  88 /* file descriptors passed via SCM_RIGHTS */
  89 typedef struct mon_fd_t mon_fd_t;
  90 struct mon_fd_t {
  91     char *name;
  92     int fd;
  93     QLIST_ENTRY(mon_fd_t) next;
  94 };
  95
  96 /* file descriptor associated with a file descriptor set */
  97 typedef struct MonFdsetFd MonFdsetFd;
  98 struct MonFdsetFd {
  99     int fd;
 100     bool removed;
 101     char *opaque;
 102     QLIST_ENTRY(MonFdsetFd) next;
 103 };
 104
 105 /* file descriptor set containing fds passed via SCM_RIGHTS */
 106 typedef struct MonFdset MonFdset;
 107 struct MonFdset {
 108     int64_t id;
 109     QLIST_HEAD(, MonFdsetFd) fds;
 110     QLIST_HEAD(, MonFdsetFd) dup_fds;
 111     QLIST_ENTRY(MonFdset) next;
 112 };
 113
 114 /* Protects mon_fdsets */
 115 static QemuMutex mon_fdsets_lock;
 116 static QLIST_HEAD(, MonFdset) mon_fdsets;
 117
 118 static HMPCommand hmp_info_cmds[];
 119
 120 char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
 121                                 int64_t cpu_index, Error **errp)
 122 {
 123     char *output = NULL;
 124     Monitor *old_mon;
 125     MonitorHMP hmp = {};
 126
 127     monitor_data_init(&hmp.common, false, true, false);
 128
 129     old_mon = cur_mon;
 130     cur_mon = &hmp.common;
 131
 132     if (has_cpu_index) {
 133         int ret = monitor_set_cpu(cpu_index);
 134         if (ret < 0) {
 135             cur_mon = old_mon;
 136             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
 137                        "a CPU number");
 138             goto out;
 139         }
 140     }
 141
 142     handle_hmp_command(&hmp, command_line);
 143     cur_mon = old_mon;
 144
 145     qemu_mutex_lock(&hmp.common.mon_lock);
 146     if (qstring_get_length(hmp.common.outbuf) > 0) {
 147         output = g_strdup(qstring_get_str(hmp.common.outbuf));
 148     } else {
 149         output = g_strdup("");
 150     }
 151     qemu_mutex_unlock(&hmp.common.mon_lock);
 152
 153 out:
 154     monitor_data_destroy(&hmp.common);
 155     return output;
 156 }
 157
 158 /**
 159  * Is @name in the '|' separated list of names @list?
 160  */
 161 int hmp_compare_cmd(const char *name, const char *list)
 162 {
 163     const char *p, *pstart;
 164     int len;
 165     len = strlen(name);
 166     p = list;
 167     for (;;) {
 168         pstart = p;
 169         p = qemu_strchrnul(p, '|');
 170         if ((p - pstart) == len && !memcmp(pstart, name, len)) {
 171             return 1;
 172         }
 173         if (*p == '\0') {
 174             break;
 175         }
 176         p++;
 177     }
 178     return 0;
 179 }
 180
 181 static void do_help_cmd(Monitor *mon, const QDict *qdict)
 182 {
 183     help_cmd(mon, qdict_get_try_str(qdict, "name"));
 184 }
 185
 186 static void hmp_trace_event(Monitor *mon, const QDict *qdict)
 187 {
 188     const char *tp_name = qdict_get_str(qdict, "name");
 189     bool new_state = qdict_get_bool(qdict, "option");
 190     bool has_vcpu = qdict_haskey(qdict, "vcpu");
 191     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
 192     Error *local_err = NULL;
 193
 194     if (vcpu < 0) {
 195         monitor_printf(mon, "argument vcpu must be positive");
 196         return;
 197     }
 198
 199     qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
 200     if (local_err) {
 201         error_report_err(local_err);
 202     }
 203 }
 204
 205 #ifdef CONFIG_TRACE_SIMPLE
 206 static void hmp_trace_file(Monitor *mon, const QDict *qdict)
 207 {
 208     const char *op = qdict_get_try_str(qdict, "op");
 209     const char *arg = qdict_get_try_str(qdict, "arg");
 210
 211     if (!op) {
 212         st_print_trace_file_status();
 213     } else if (!strcmp(op, "on")) {
 214         st_set_trace_file_enabled(true);
 215     } else if (!strcmp(op, "off")) {
 216         st_set_trace_file_enabled(false);
 217     } else if (!strcmp(op, "flush")) {
 218         st_flush_trace_buffer();
 219     } else if (!strcmp(op, "set")) {
 220         if (arg) {
 221             st_set_trace_file(arg);
 222         }
 223     } else {
 224         monitor_printf(mon, "unexpected argument \"%s\"\n", op);
 225         help_cmd(mon, "trace-file");
 226     }
 227 }
 228 #endif
 229
 230 static void hmp_info_help(Monitor *mon, const QDict *qdict)
 231 {
 232     help_cmd(mon, "info");
 233 }
 234
 235 /*
 236  * Minor hack: generated marshalling suppressed for this command
 237  * ('gen': false in the schema) so we can parse the JSON string
 238  * directly into QObject instead of first parsing it with
 239  * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
 240  * to QObject with generated output marshallers, every time.  Instead,
 241  * we do it in test-qobject-input-visitor.c, just to make sure
 242  * qapi-gen.py's output actually conforms to the schema.
 243  */
 244 static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
 245                                  Error **errp)
 246 {
 247     *ret_data = qobject_from_qlit(&qmp_schema_qlit);
 248 }
 249
 250 static void monitor_init_qmp_commands(void)
 251 {
 252     /*
 253      * Two command lists:
 254      * - qmp_commands contains all QMP commands
 255      * - qmp_cap_negotiation_commands contains just
 256      *   "qmp_capabilities", to enforce capability negotiation
 257      */
 258
 259     qmp_init_marshal(&qmp_commands);
 260
 261     qmp_register_command(&qmp_commands, "query-qmp-schema",
 262                          qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
 263     qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
 264                          QCO_NO_OPTIONS);
 265     qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
 266                          QCO_NO_OPTIONS);
 267
 268     QTAILQ_INIT(&qmp_cap_negotiation_commands);
 269     qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
 270                          qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
 271 }
 272
 273 /* Set the current CPU defined by the user. Callers must hold BQL. */
 274 int monitor_set_cpu(int cpu_index)
 275 {
 276     CPUState *cpu;
 277
 278     cpu = qemu_get_cpu(cpu_index);
 279     if (cpu == NULL) {
 280         return -1;
 281     }
 282     g_free(cur_mon->mon_cpu_path);
 283     cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
 284     return 0;
 285 }
 286
 287 /* Callers must hold BQL. */
 288 static CPUState *mon_get_cpu_sync(bool synchronize)
 289 {
 290     CPUState *cpu = NULL;
 291
 292     if (cur_mon->mon_cpu_path) {
 293         cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
 294                                                     TYPE_CPU, NULL);
 295         if (!cpu) {
 296             g_free(cur_mon->mon_cpu_path);
 297             cur_mon->mon_cpu_path = NULL;
 298         }
 299     }
 300     if (!cur_mon->mon_cpu_path) {
 301         if (!first_cpu) {
 302             return NULL;
 303         }
 304         monitor_set_cpu(first_cpu->cpu_index);
 305         cpu = first_cpu;
 306     }
 307     assert(cpu != NULL);
 308     if (synchronize) {
 309         cpu_synchronize_state(cpu);
 310     }
 311     return cpu;
 312 }
 313
 314 CPUState *mon_get_cpu(void)
 315 {
 316     return mon_get_cpu_sync(true);
 317 }
 318
 319 CPUArchState *mon_get_cpu_env(void)
 320 {
 321     CPUState *cs = mon_get_cpu();
 322
 323     return cs ? cs->env_ptr : NULL;
 324 }
 325
 326 int monitor_get_cpu_index(void)
 327 {
 328     CPUState *cs = mon_get_cpu_sync(false);
 329
 330     return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
 331 }
 332
 333 static void hmp_info_registers(Monitor *mon, const QDict *qdict)
 334 {
 335     bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
 336     CPUState *cs;
 337
 338     if (all_cpus) {
 339         CPU_FOREACH(cs) {
 340             monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
 341             cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
 342         }
 343     } else {
 344         cs = mon_get_cpu();
 345
 346         if (!cs) {
 347             monitor_printf(mon, "No CPU available\n");
 348             return;
 349         }
 350
 351         cpu_dump_state(cs, NULL, CPU_DUMP_FPU);
 352     }
 353 }
 354
 355 #ifdef CONFIG_TCG
 356 static void hmp_info_jit(Monitor *mon, const QDict *qdict)
 357 {
 358     if (!tcg_enabled()) {
 359         error_report("JIT information is only available with accel=tcg");
 360         return;
 361     }
 362
 363     dump_exec_info();
 364     dump_drift_info();
 365 }
 366
 367 static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
 368 {
 369     dump_opcount_info();
 370 }
 371 #endif
 372
 373 static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
 374 {
 375     int64_t max = qdict_get_try_int(qdict, "max", 10);
 376     bool mean = qdict_get_try_bool(qdict, "mean", false);
 377     bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
 378     enum QSPSortBy sort_by;
 379
 380     sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
 381     qsp_report(max, sort_by, coalesce);
 382 }
 383
 384 static void hmp_info_history(Monitor *mon, const QDict *qdict)
 385 {
 386     MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
 387     int i;
 388     const char *str;
 389
 390     if (!hmp_mon->rs) {
 391         return;
 392     }
 393     i = 0;
 394     for(;;) {
 395         str = readline_get_history(hmp_mon->rs, i);
 396         if (!str) {
 397             break;
 398         }
 399         monitor_printf(mon, "%d: '%s'\n", i, str);
 400         i++;
 401     }
 402 }
 403
 404 static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
 405 {
 406     CPUState *cs = mon_get_cpu();
 407
 408     if (!cs) {
 409         monitor_printf(mon, "No CPU available\n");
 410         return;
 411     }
 412     cpu_dump_statistics(cs, 0);
 413 }
 414
 415 static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
 416 {
 417     const char *name = qdict_get_try_str(qdict, "name");
 418     bool has_vcpu = qdict_haskey(qdict, "vcpu");
 419     int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
 420     TraceEventInfoList *events;
 421     TraceEventInfoList *elem;
 422     Error *local_err = NULL;
 423
 424     if (name == NULL) {
 425         name = "*";
 426     }
 427     if (vcpu < 0) {
 428         monitor_printf(mon, "argument vcpu must be positive");
 429         return;
 430     }
 431
 432     events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
 433     if (local_err) {
 434         error_report_err(local_err);
 435         return;
 436     }
 437
 438     for (elem = events; elem != NULL; elem = elem->next) {
 439         monitor_printf(mon, "%s : state %u\n",
 440                        elem->value->name,
 441                        elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
 442     }
 443     qapi_free_TraceEventInfoList(events);
 444 }
 445
 446 void qmp_client_migrate_info(const char *protocol, const char *hostname,
 447                              bool has_port, int64_t port,
 448                              bool has_tls_port, int64_t tls_port,
 449                              bool has_cert_subject, const char *cert_subject,
 450                              Error **errp)
 451 {
 452     if (strcmp(protocol, "spice") == 0) {
 453         if (!qemu_using_spice(errp)) {
 454             return;
 455         }
 456
 457         if (!has_port && !has_tls_port) {
 458             error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
 459             return;
 460         }
 461
 462         if (qemu_spice_migrate_info(hostname,
 463                                     has_port ? port : -1,
 464                                     has_tls_port ? tls_port : -1,
 465                                     cert_subject)) {
 466             error_setg(errp, QERR_UNDEFINED_ERROR);
 467             return;
 468         }
 469         return;
 470     }
 471
 472     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
 473 }
 474
 475 static void hmp_logfile(Monitor *mon, const QDict *qdict)
 476 {
 477     Error *err = NULL;
 478
 479     qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
 480     if (err) {
 481         error_report_err(err);
 482     }
 483 }
 484
 485 static void hmp_log(Monitor *mon, const QDict *qdict)
 486 {
 487     int mask;
 488     const char *items = qdict_get_str(qdict, "items");
 489
 490     if (!strcmp(items, "none")) {
 491         mask = 0;
 492     } else {
 493         mask = qemu_str_to_log_mask(items);
 494         if (!mask) {
 495             help_cmd(mon, "log");
 496             return;
 497         }
 498     }
 499     qemu_set_log(mask);
 500 }
 501
 502 static void hmp_singlestep(Monitor *mon, const QDict *qdict)
 503 {
 504     const char *option = qdict_get_try_str(qdict, "option");
 505     if (!option || !strcmp(option, "on")) {
 506         singlestep = 1;
 507     } else if (!strcmp(option, "off")) {
 508         singlestep = 0;
 509     } else {
 510         monitor_printf(mon, "unexpected option %s\n", option);
 511     }
 512 }
 513
 514 static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
 515 {
 516     const char *device = qdict_get_try_str(qdict, "device");
 517     if (!device)
 518         device = "tcp::" DEFAULT_GDBSTUB_PORT;
 519     if (gdbserver_start(device) < 0) {
 520         monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
 521                        device);
 522     } else if (strcmp(device, "none") == 0) {
 523         monitor_printf(mon, "Disabled gdbserver\n");
 524     } else {
 525         monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
 526                        device);
 527     }
 528 }
 529
 530 static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
 531 {
 532     const char *action = qdict_get_str(qdict, "action");
 533     if (select_watchdog_action(action) == -1) {
 534         monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
 535     }
 536 }
 537
 538 static void monitor_printc(Monitor *mon, int c)
 539 {
 540     monitor_printf(mon, "'");
 541     switch(c) {
 542     case '\'':
 543         monitor_printf(mon, "\\'");
 544         break;
 545     case '\\':
 546         monitor_printf(mon, "\\\\");
 547         break;
 548     case '\n':
 549         monitor_printf(mon, "\\n");
 550         break;
 551     case '\r':
 552         monitor_printf(mon, "\\r");
 553         break;
 554     default:
 555         if (c >= 32 && c <= 126) {
 556             monitor_printf(mon, "%c", c);
 557         } else {
 558             monitor_printf(mon, "\\x%02x", c);
 559         }
 560         break;
 561     }
 562     monitor_printf(mon, "'");
 563 }
 564
 565 static void memory_dump(Monitor *mon, int count, int format, int wsize,
 566                         hwaddr addr, int is_physical)
 567 {
 568     int l, line_size, i, max_digits, len;
 569     uint8_t buf[16];
 570     uint64_t v;
 571     CPUState *cs = mon_get_cpu();
 572
 573     if (!cs && (format == 'i' || !is_physical)) {
 574         monitor_printf(mon, "Can not dump without CPU\n");
 575         return;
 576     }
 577
 578     if (format == 'i') {
 579         monitor_disas(mon, cs, addr, count, is_physical);
 580         return;
 581     }
 582
 583     len = wsize * count;
 584     if (wsize == 1)
 585         line_size = 8;
 586     else
 587         line_size = 16;
 588     max_digits = 0;
 589
 590     switch(format) {
 591     case 'o':
 592         max_digits = DIV_ROUND_UP(wsize * 8, 3);
 593         break;
 594     default:
 595     case 'x':
 596         max_digits = (wsize * 8) / 4;
 597         break;
 598     case 'u':
 599     case 'd':
 600         max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
 601         break;
 602     case 'c':
 603         wsize = 1;
 604         break;
 605     }
 606
 607     while (len > 0) {
 608         if (is_physical)
 609             monitor_printf(mon, TARGET_FMT_plx ":", addr);
 610         else
 611             monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
 612         l = len;
 613         if (l > line_size)
 614             l = line_size;
 615         if (is_physical) {
 616             AddressSpace *as = cs ? cs->as : &address_space_memory;
 617             MemTxResult r = address_space_read(as, addr,
 618                                                MEMTXATTRS_UNSPECIFIED, buf, l);
 619             if (r != MEMTX_OK) {
 620                 monitor_printf(mon, " Cannot access memory\n");
 621                 break;
 622             }
 623         } else {
 624             if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
 625                 monitor_printf(mon, " Cannot access memory\n");
 626                 break;
 627             }
 628         }
 629         i = 0;
 630         while (i < l) {
 631             switch(wsize) {
 632             default:
 633             case 1:
 634                 v = ldub_p(buf + i);
 635                 break;
 636             case 2:
 637                 v = lduw_p(buf + i);
 638                 break;
 639             case 4:
 640                 v = (uint32_t)ldl_p(buf + i);
 641                 break;
 642             case 8:
 643                 v = ldq_p(buf + i);
 644                 break;
 645             }
 646             monitor_printf(mon, " ");
 647             switch(format) {
 648             case 'o':
 649                 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
 650                 break;
 651             case 'x':
 652                 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
 653                 break;
 654             case 'u':
 655                 monitor_printf(mon, "%*" PRIu64, max_digits, v);
 656                 break;
 657             case 'd':
 658                 monitor_printf(mon, "%*" PRId64, max_digits, v);
 659                 break;
 660             case 'c':
 661                 monitor_printc(mon, v);
 662                 break;
 663             }
 664             i += wsize;
 665         }
 666         monitor_printf(mon, "\n");
 667         addr += l;
 668         len -= l;
 669     }
 670 }
 671
 672 static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
 673 {
 674     int count = qdict_get_int(qdict, "count");
 675     int format = qdict_get_int(qdict, "format");
 676     int size = qdict_get_int(qdict, "size");
 677     target_long addr = qdict_get_int(qdict, "addr");
 678
 679     memory_dump(mon, count, format, size, addr, 0);
 680 }
 681
 682 static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
 683 {
 684     int count = qdict_get_int(qdict, "count");
 685     int format = qdict_get_int(qdict, "format");
 686     int size = qdict_get_int(qdict, "size");
 687     hwaddr addr = qdict_get_int(qdict, "addr");
 688
 689     memory_dump(mon, count, format, size, addr, 1);
 690 }
 691
 692 static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
 693 {
 694     MemoryRegionSection mrs = memory_region_find(get_system_memory(),
 695                                                  addr, 1);
 696
 697     if (!mrs.mr) {
 698         error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
 699         return NULL;
 700     }
 701
 702     if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
 703         error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
 704         memory_region_unref(mrs.mr);
 705         return NULL;
 706     }
 707
 708     *p_mr = mrs.mr;
 709     return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
 710 }
 711
 712 static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
 713 {
 714     hwaddr addr = qdict_get_int(qdict, "addr");
 715     Error *local_err = NULL;
 716     MemoryRegion *mr = NULL;
 717     void *ptr;
 718
 719     ptr = gpa2hva(&mr, addr, &local_err);
 720     if (local_err) {
 721         error_report_err(local_err);
 722         return;
 723     }
 724
 725     monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
 726                    " (%s) is %p\n",
 727                    addr, mr->name, ptr);
 728
 729     memory_region_unref(mr);
 730 }
 731
 732 static void hmp_gva2gpa(Monitor *mon, const QDict *qdict)
 733 {
 734     target_ulong addr = qdict_get_int(qdict, "addr");
 735     MemTxAttrs attrs;
 736     CPUState *cs = mon_get_cpu();
 737     hwaddr gpa;
 738
 739     if (!cs) {
 740         monitor_printf(mon, "No cpu\n");
 741         return;
 742     }
 743
 744     gpa  = cpu_get_phys_page_attrs_debug(cs, addr & TARGET_PAGE_MASK, &attrs);
 745     if (gpa == -1) {
 746         monitor_printf(mon, "Unmapped\n");
 747     } else {
 748         monitor_printf(mon, "gpa: %#" HWADDR_PRIx "\n",
 749                        gpa + (addr & ~TARGET_PAGE_MASK));
 750     }
 751 }
 752
 753 #ifdef CONFIG_LINUX
 754 static uint64_t vtop(void *ptr, Error **errp)
 755 {
 756     uint64_t pinfo;
 757     uint64_t ret = -1;
 758     uintptr_t addr = (uintptr_t) ptr;
 759     uintptr_t pagesize = qemu_real_host_page_size;
 760     off_t offset = addr / pagesize * sizeof(pinfo);
 761     int fd;
 762
 763     fd = open("/proc/self/pagemap", O_RDONLY);
 764     if (fd == -1) {
 765         error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
 766         return -1;
 767     }
 768
 769     /* Force copy-on-write if necessary.  */
 770     atomic_add((uint8_t *)ptr, 0);
 771
 772     if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
 773         error_setg_errno(errp, errno, "Cannot read pagemap");
 774         goto out;
 775     }
 776     if ((pinfo & (1ull << 63)) == 0) {
 777         error_setg(errp, "Page not present");
 778         goto out;
 779     }
 780     ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
 781
 782 out:
 783     close(fd);
 784     return ret;
 785 }
 786
 787 static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
 788 {
 789     hwaddr addr = qdict_get_int(qdict, "addr");
 790     Error *local_err = NULL;
 791     MemoryRegion *mr = NULL;
 792     void *ptr;
 793     uint64_t physaddr;
 794
 795     ptr = gpa2hva(&mr, addr, &local_err);
 796     if (local_err) {
 797         error_report_err(local_err);
 798         return;
 799     }
 800
 801     physaddr = vtop(ptr, &local_err);
 802     if (local_err) {
 803         error_report_err(local_err);
 804     } else {
 805         monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
 806                        " (%s) is 0x%" PRIx64 "\n",
 807                        addr, mr->name, (uint64_t) physaddr);
 808     }
 809
 810     memory_region_unref(mr);
 811 }
 812 #endif
 813
 814 static void do_print(Monitor *mon, const QDict *qdict)
 815 {
 816     int format = qdict_get_int(qdict, "format");
 817     hwaddr val = qdict_get_int(qdict, "val");
 818
 819     switch(format) {
 820     case 'o':
 821         monitor_printf(mon, "%#" HWADDR_PRIo, val);
 822         break;
 823     case 'x':
 824         monitor_printf(mon, "%#" HWADDR_PRIx, val);
 825         break;
 826     case 'u':
 827         monitor_printf(mon, "%" HWADDR_PRIu, val);
 828         break;
 829     default:
 830     case 'd':
 831         monitor_printf(mon, "%" HWADDR_PRId, val);
 832         break;
 833     case 'c':
 834         monitor_printc(mon, val);
 835         break;
 836     }
 837     monitor_printf(mon, "\n");
 838 }
 839
 840 static void hmp_sum(Monitor *mon, const QDict *qdict)
 841 {
 842     uint32_t addr;
 843     uint16_t sum;
 844     uint32_t start = qdict_get_int(qdict, "start");
 845     uint32_t size = qdict_get_int(qdict, "size");
 846
 847     sum = 0;
 848     for(addr = start; addr < (start + size); addr++) {
 849         uint8_t val = address_space_ldub(&address_space_memory, addr,
 850                                          MEMTXATTRS_UNSPECIFIED, NULL);
 851         /* BSD sum algorithm ('sum' Unix command) */
 852         sum = (sum >> 1) | (sum << 15);
 853         sum += val;
 854     }
 855     monitor_printf(mon, "%05d\n", sum);
 856 }
 857
 858 static int mouse_button_state;
 859
 860 static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
 861 {
 862     int dx, dy, dz, button;
 863     const char *dx_str = qdict_get_str(qdict, "dx_str");
 864     const char *dy_str = qdict_get_str(qdict, "dy_str");
 865     const char *dz_str = qdict_get_try_str(qdict, "dz_str");
 866
 867     dx = strtol(dx_str, NULL, 0);
 868     dy = strtol(dy_str, NULL, 0);
 869     qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
 870     qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
 871
 872     if (dz_str) {
 873         dz = strtol(dz_str, NULL, 0);
 874         if (dz != 0) {
 875             button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
 876             qemu_input_queue_btn(NULL, button, true);
 877             qemu_input_event_sync();
 878             qemu_input_queue_btn(NULL, button, false);
 879         }
 880     }
 881     qemu_input_event_sync();
 882 }
 883
 884 static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
 885 {
 886     static uint32_t bmap[INPUT_BUTTON__MAX] = {
 887         [INPUT_BUTTON_LEFT]       = MOUSE_EVENT_LBUTTON,
 888         [INPUT_BUTTON_MIDDLE]     = MOUSE_EVENT_MBUTTON,
 889         [INPUT_BUTTON_RIGHT]      = MOUSE_EVENT_RBUTTON,
 890     };
 891     int button_state = qdict_get_int(qdict, "button_state");
 892
 893     if (mouse_button_state == button_state) {
 894         return;
 895     }
 896     qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
 897     qemu_input_event_sync();
 898     mouse_button_state = button_state;
 899 }
 900
 901 static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
 902 {
 903     int size = qdict_get_int(qdict, "size");
 904     int addr = qdict_get_int(qdict, "addr");
 905     int has_index = qdict_haskey(qdict, "index");
 906     uint32_t val;
 907     int suffix;
 908
 909     if (has_index) {
 910         int index = qdict_get_int(qdict, "index");
 911         cpu_outb(addr & IOPORTS_MASK, index & 0xff);
 912         addr++;
 913     }
 914     addr &= 0xffff;
 915
 916     switch(size) {
 917     default:
 918     case 1:
 919         val = cpu_inb(addr);
 920         suffix = 'b';
 921         break;
 922     case 2:
 923         val = cpu_inw(addr);
 924         suffix = 'w';
 925         break;
 926     case 4:
 927         val = cpu_inl(addr);
 928         suffix = 'l';
 929         break;
 930     }
 931     monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
 932                    suffix, addr, size * 2, val);
 933 }
 934
 935 static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
 936 {
 937     int size = qdict_get_int(qdict, "size");
 938     int addr = qdict_get_int(qdict, "addr");
 939     int val = qdict_get_int(qdict, "val");
 940
 941     addr &= IOPORTS_MASK;
 942
 943     switch (size) {
 944     default:
 945     case 1:
 946         cpu_outb(addr, val);
 947         break;
 948     case 2:
 949         cpu_outw(addr, val);
 950         break;
 951     case 4:
 952         cpu_outl(addr, val);
 953         break;
 954     }
 955 }
 956
 957 static void hmp_boot_set(Monitor *mon, const QDict *qdict)
 958 {
 959     Error *local_err = NULL;
 960     const char *bootdevice = qdict_get_str(qdict, "bootdevice");
 961
 962     qemu_boot_set(bootdevice, &local_err);
 963     if (local_err) {
 964         error_report_err(local_err);
 965     } else {
 966         monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
 967     }
 968 }
 969
 970 static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
 971 {
 972     bool flatview = qdict_get_try_bool(qdict, "flatview", false);
 973     bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
 974     bool owner = qdict_get_try_bool(qdict, "owner", false);
 975
 976     mtree_info(flatview, dispatch_tree, owner);
 977 }
 978
 979 #ifdef CONFIG_PROFILER
 980
 981 int64_t dev_time;
 982
 983 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
 984 {
 985     static int64_t last_cpu_exec_time;
 986     int64_t cpu_exec_time;
 987     int64_t delta;
 988
 989     cpu_exec_time = tcg_cpu_exec_time();
 990     delta = cpu_exec_time - last_cpu_exec_time;
 991
 992     monitor_printf(mon, "async time  %" PRId64 " (%0.3f)\n",
 993                    dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
 994     monitor_printf(mon, "qemu time   %" PRId64 " (%0.3f)\n",
 995                    delta, delta / (double)NANOSECONDS_PER_SECOND);
 996     last_cpu_exec_time = cpu_exec_time;
 997     dev_time = 0;
 998 }
 999 #else
1000 static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1001 {
1002     monitor_printf(mon, "Internal profiler not compiled\n");
1003 }
1004 #endif
1005
1006 /* Capture support */
1007 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
1008
1009 static void hmp_info_capture(Monitor *mon, const QDict *qdict)
1010 {
1011     int i;
1012     CaptureState *s;
1013
1014     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1015         monitor_printf(mon, "[%d]: ", i);
1016         s->ops.info (s->opaque);
1017     }
1018 }
1019
1020 static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
1021 {
1022     int i;
1023     int n = qdict_get_int(qdict, "n");
1024     CaptureState *s;
1025
1026     for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1027         if (i == n) {
1028             s->ops.destroy (s->opaque);
1029             QLIST_REMOVE (s, entries);
1030             g_free (s);
1031             return;
1032         }
1033     }
1034 }
1035
1036 static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
1037 {
1038     const char *path = qdict_get_str(qdict, "path");
1039     int freq = qdict_get_try_int(qdict, "freq", 44100);
1040     int bits = qdict_get_try_int(qdict, "bits", 16);
1041     int nchannels = qdict_get_try_int(qdict, "nchannels", 2);
1042     const char *audiodev = qdict_get_str(qdict, "audiodev");
1043     CaptureState *s;
1044     AudioState *as = audio_state_by_name(audiodev);
1045
1046     if (!as) {
1047         monitor_printf(mon, "Audiodev '%s' not found\n", audiodev);
1048         return;
1049     }
1050
1051     s = g_malloc0 (sizeof (*s));
1052
1053     if (wav_start_capture(as, s, path, freq, bits, nchannels)) {
1054         monitor_printf(mon, "Failed to add wave capture\n");
1055         g_free (s);
1056         return;
1057     }
1058     QLIST_INSERT_HEAD (&capture_head, s, entries);
1059 }
1060
1061 static QAuthZList *find_auth(Monitor *mon, const char *name)
1062 {
1063     Object *obj;
1064     Object *container;
1065
1066     container = object_get_objects_root();
1067     obj = object_resolve_path_component(container, name);
1068     if (!obj) {
1069         monitor_printf(mon, "acl: unknown list '%s'\n", name);
1070         return NULL;
1071     }
1072
1073     return QAUTHZ_LIST(obj);
1074 }
1075
1076 static bool warn_acl;
1077 static void hmp_warn_acl(void)
1078 {
1079     if (warn_acl) {
1080         return;
1081     }
1082     error_report("The acl_show, acl_reset, acl_policy, acl_add, acl_remove "
1083                  "commands are deprecated with no replacement. Authorization "
1084                  "for VNC should be performed using the pluggable QAuthZ "
1085                  "objects");
1086     warn_acl = true;
1087 }
1088
1089 static void hmp_acl_show(Monitor *mon, const QDict *qdict)
1090 {
1091     const char *aclname = qdict_get_str(qdict, "aclname");
1092     QAuthZList *auth = find_auth(mon, aclname);
1093     QAuthZListRuleList *rules;
1094     size_t i = 0;
1095
1096     hmp_warn_acl();
1097
1098     if (!auth) {
1099         return;
1100     }
1101
1102     monitor_printf(mon, "policy: %s\n",
1103                    QAuthZListPolicy_str(auth->policy));
1104
1105     rules = auth->rules;
1106     while (rules) {
1107         QAuthZListRule *rule = rules->value;
1108         i++;
1109         monitor_printf(mon, "%zu: %s %s\n", i,
1110                        QAuthZListPolicy_str(rule->policy),
1111                        rule->match);
1112         rules = rules->next;
1113     }
1114 }
1115
1116 static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
1117 {
1118     const char *aclname = qdict_get_str(qdict, "aclname");
1119     QAuthZList *auth = find_auth(mon, aclname);
1120
1121     hmp_warn_acl();
1122
1123     if (!auth) {
1124         return;
1125     }
1126
1127     auth->policy = QAUTHZ_LIST_POLICY_DENY;
1128     qapi_free_QAuthZListRuleList(auth->rules);
1129     auth->rules = NULL;
1130     monitor_printf(mon, "acl: removed all rules\n");
1131 }
1132
1133 static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
1134 {
1135     const char *aclname = qdict_get_str(qdict, "aclname");
1136     const char *policy = qdict_get_str(qdict, "policy");
1137     QAuthZList *auth = find_auth(mon, aclname);
1138     int val;
1139     Error *err = NULL;
1140
1141     hmp_warn_acl();
1142
1143     if (!auth) {
1144         return;
1145     }
1146
1147     val = qapi_enum_parse(&QAuthZListPolicy_lookup,
1148                           policy,
1149                           QAUTHZ_LIST_POLICY_DENY,
1150                           &err);
1151     if (err) {
1152         error_free(err);
1153         monitor_printf(mon, "acl: unknown policy '%s', "
1154                        "expected 'deny' or 'allow'\n", policy);
1155     } else {
1156         auth->policy = val;
1157         if (auth->policy == QAUTHZ_LIST_POLICY_ALLOW) {
1158             monitor_printf(mon, "acl: policy set to 'allow'\n");
1159         } else {
1160             monitor_printf(mon, "acl: policy set to 'deny'\n");
1161         }
1162     }
1163 }
1164
1165 static QAuthZListFormat hmp_acl_get_format(const char *match)
1166 {
1167     if (strchr(match, '*')) {
1168         return QAUTHZ_LIST_FORMAT_GLOB;
1169     } else {
1170         return QAUTHZ_LIST_FORMAT_EXACT;
1171     }
1172 }
1173
1174 static void hmp_acl_add(Monitor *mon, const QDict *qdict)
1175 {
1176     const char *aclname = qdict_get_str(qdict, "aclname");
1177     const char *match = qdict_get_str(qdict, "match");
1178     const char *policystr = qdict_get_str(qdict, "policy");
1179     int has_index = qdict_haskey(qdict, "index");
1180     int index = qdict_get_try_int(qdict, "index", -1);
1181     QAuthZList *auth = find_auth(mon, aclname);
1182     Error *err = NULL;
1183     QAuthZListPolicy policy;
1184     QAuthZListFormat format;
1185     size_t i = 0;
1186
1187     hmp_warn_acl();
1188
1189     if (!auth) {
1190         return;
1191     }
1192
1193     policy = qapi_enum_parse(&QAuthZListPolicy_lookup,
1194                              policystr,
1195                              QAUTHZ_LIST_POLICY_DENY,
1196                              &err);
1197     if (err) {
1198         error_free(err);
1199         monitor_printf(mon, "acl: unknown policy '%s', "
1200                        "expected 'deny' or 'allow'\n", policystr);
1201         return;
1202     }
1203
1204     format = hmp_acl_get_format(match);
1205
1206     if (has_index && index == 0) {
1207         monitor_printf(mon, "acl: unable to add acl entry\n");
1208         return;
1209     }
1210
1211     if (has_index) {
1212         i = qauthz_list_insert_rule(auth, match, policy,
1213                                     format, index - 1, &err);
1214     } else {
1215         i = qauthz_list_append_rule(auth, match, policy,
1216                                     format, &err);
1217     }
1218     if (err) {
1219         monitor_printf(mon, "acl: unable to add rule: %s",
1220                        error_get_pretty(err));
1221         error_free(err);
1222     } else {
1223         monitor_printf(mon, "acl: added rule at position %zu\n", i + 1);
1224     }
1225 }
1226
1227 static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
1228 {
1229     const char *aclname = qdict_get_str(qdict, "aclname");
1230     const char *match = qdict_get_str(qdict, "match");
1231     QAuthZList *auth = find_auth(mon, aclname);
1232     ssize_t i = 0;
1233
1234     hmp_warn_acl();
1235
1236     if (!auth) {
1237         return;
1238     }
1239
1240     i = qauthz_list_delete_rule(auth, match);
1241     if (i >= 0) {
1242         monitor_printf(mon, "acl: removed rule at position %zu\n", i + 1);
1243     } else {
1244         monitor_printf(mon, "acl: no matching acl entry\n");
1245     }
1246 }
1247
1248 void qmp_getfd(const char *fdname, Error **errp)
1249 {
1250     mon_fd_t *monfd;
1251     int fd, tmp_fd;
1252
1253     fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
1254     if (fd == -1) {
1255         error_setg(errp, QERR_FD_NOT_SUPPLIED);
1256         return;
1257     }
1258
1259     if (qemu_isdigit(fdname[0])) {
1260         close(fd);
1261         error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1262                    "a name not starting with a digit");
1263         return;
1264     }
1265
1266     qemu_mutex_lock(&cur_mon->mon_lock);
1267     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1268         if (strcmp(monfd->name, fdname) != 0) {
1269             continue;
1270         }
1271
1272         tmp_fd = monfd->fd;
1273         monfd->fd = fd;
1274         qemu_mutex_unlock(&cur_mon->mon_lock);
1275         /* Make sure close() is outside critical section */
1276         close(tmp_fd);
1277         return;
1278     }
1279
1280     monfd = g_malloc0(sizeof(mon_fd_t));
1281     monfd->name = g_strdup(fdname);
1282     monfd->fd = fd;
1283
1284     QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
1285     qemu_mutex_unlock(&cur_mon->mon_lock);
1286 }
1287
1288 void qmp_closefd(const char *fdname, Error **errp)
1289 {
1290     mon_fd_t *monfd;
1291     int tmp_fd;
1292
1293     qemu_mutex_lock(&cur_mon->mon_lock);
1294     QLIST_FOREACH(monfd, &cur_mon->fds, next) {
1295         if (strcmp(monfd->name, fdname) != 0) {
1296             continue;
1297         }
1298
1299         QLIST_REMOVE(monfd, next);
1300         tmp_fd = monfd->fd;
1301         g_free(monfd->name);
1302         g_free(monfd);
1303         qemu_mutex_unlock(&cur_mon->mon_lock);
1304         /* Make sure close() is outside critical section */
1305         close(tmp_fd);
1306         return;
1307     }
1308
1309     qemu_mutex_unlock(&cur_mon->mon_lock);
1310     error_setg(errp, QERR_FD_NOT_FOUND, fdname);
1311 }
1312
1313 int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
1314 {
1315     mon_fd_t *monfd;
1316
1317     qemu_mutex_lock(&mon->mon_lock);
1318     QLIST_FOREACH(monfd, &mon->fds, next) {
1319         int fd;
1320
1321         if (strcmp(monfd->name, fdname) != 0) {
1322             continue;
1323         }
1324
1325         fd = monfd->fd;
1326
1327         /* caller takes ownership of fd */
1328         QLIST_REMOVE(monfd, next);
1329         g_free(monfd->name);
1330         g_free(monfd);
1331         qemu_mutex_unlock(&mon->mon_lock);
1332
1333         return fd;
1334     }
1335
1336     qemu_mutex_unlock(&mon->mon_lock);
1337     error_setg(errp, "File descriptor named '%s' has not been found", fdname);
1338     return -1;
1339 }
1340
1341 static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1342 {
1343     MonFdsetFd *mon_fdset_fd;
1344     MonFdsetFd *mon_fdset_fd_next;
1345
1346     QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
1347         if ((mon_fdset_fd->removed ||
1348                 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1349                 runstate_is_running()) {
1350             close(mon_fdset_fd->fd);
1351             g_free(mon_fdset_fd->opaque);
1352             QLIST_REMOVE(mon_fdset_fd, next);
1353             g_free(mon_fdset_fd);
1354         }
1355     }
1356
1357     if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
1358         QLIST_REMOVE(mon_fdset, next);
1359         g_free(mon_fdset);
1360     }
1361 }
1362
1363 void monitor_fdsets_cleanup(void)
1364 {
1365     MonFdset *mon_fdset;
1366     MonFdset *mon_fdset_next;
1367
1368     qemu_mutex_lock(&mon_fdsets_lock);
1369     QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
1370         monitor_fdset_cleanup(mon_fdset);
1371     }
1372     qemu_mutex_unlock(&mon_fdsets_lock);
1373 }
1374
1375 AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
1376                       const char *opaque, Error **errp)
1377 {
1378     int fd;
1379     Monitor *mon = cur_mon;
1380     AddfdInfo *fdinfo;
1381
1382     fd = qemu_chr_fe_get_msgfd(&mon->chr);
1383     if (fd == -1) {
1384         error_setg(errp, QERR_FD_NOT_SUPPLIED);
1385         goto error;
1386     }
1387
1388     fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
1389                                   has_opaque, opaque, errp);
1390     if (fdinfo) {
1391         return fdinfo;
1392     }
1393
1394 error:
1395     if (fd != -1) {
1396         close(fd);
1397     }
1398     return NULL;
1399 }
1400
1401 void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
1402 {
1403     MonFdset *mon_fdset;
1404     MonFdsetFd *mon_fdset_fd;
1405     char fd_str[60];
1406
1407     qemu_mutex_lock(&mon_fdsets_lock);
1408     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1409         if (mon_fdset->id != fdset_id) {
1410             continue;
1411         }
1412         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1413             if (has_fd) {
1414                 if (mon_fdset_fd->fd != fd) {
1415                     continue;
1416                 }
1417                 mon_fdset_fd->removed = true;
1418                 break;
1419             } else {
1420                 mon_fdset_fd->removed = true;
1421             }
1422         }
1423         if (has_fd && !mon_fdset_fd) {
1424             goto error;
1425         }
1426         monitor_fdset_cleanup(mon_fdset);
1427         qemu_mutex_unlock(&mon_fdsets_lock);
1428         return;
1429     }
1430
1431 error:
1432     qemu_mutex_unlock(&mon_fdsets_lock);
1433     if (has_fd) {
1434         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
1435                  fdset_id, fd);
1436     } else {
1437         snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
1438     }
1439     error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
1440 }
1441
1442 FdsetInfoList *qmp_query_fdsets(Error **errp)
1443 {
1444     MonFdset *mon_fdset;
1445     MonFdsetFd *mon_fdset_fd;
1446     FdsetInfoList *fdset_list = NULL;
1447
1448     qemu_mutex_lock(&mon_fdsets_lock);
1449     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1450         FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
1451         FdsetFdInfoList *fdsetfd_list = NULL;
1452
1453         fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
1454         fdset_info->value->fdset_id = mon_fdset->id;
1455
1456         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1457             FdsetFdInfoList *fdsetfd_info;
1458
1459             fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
1460             fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
1461             fdsetfd_info->value->fd = mon_fdset_fd->fd;
1462             if (mon_fdset_fd->opaque) {
1463                 fdsetfd_info->value->has_opaque = true;
1464                 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
1465             } else {
1466                 fdsetfd_info->value->has_opaque = false;
1467             }
1468
1469             fdsetfd_info->next = fdsetfd_list;
1470             fdsetfd_list = fdsetfd_info;
1471         }
1472
1473         fdset_info->value->fds = fdsetfd_list;
1474
1475         fdset_info->next = fdset_list;
1476         fdset_list = fdset_info;
1477     }
1478     qemu_mutex_unlock(&mon_fdsets_lock);
1479
1480     return fdset_list;
1481 }
1482
1483 AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
1484                                 bool has_opaque, const char *opaque,
1485                                 Error **errp)
1486 {
1487     MonFdset *mon_fdset = NULL;
1488     MonFdsetFd *mon_fdset_fd;
1489     AddfdInfo *fdinfo;
1490
1491     qemu_mutex_lock(&mon_fdsets_lock);
1492     if (has_fdset_id) {
1493         QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1494             /* Break if match found or match impossible due to ordering by ID */
1495             if (fdset_id <= mon_fdset->id) {
1496                 if (fdset_id < mon_fdset->id) {
1497                     mon_fdset = NULL;
1498                 }
1499                 break;
1500             }
1501         }
1502     }
1503
1504     if (mon_fdset == NULL) {
1505         int64_t fdset_id_prev = -1;
1506         MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
1507
1508         if (has_fdset_id) {
1509             if (fdset_id < 0) {
1510                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
1511                            "a non-negative value");
1512                 qemu_mutex_unlock(&mon_fdsets_lock);
1513                 return NULL;
1514             }
1515             /* Use specified fdset ID */
1516             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1517                 mon_fdset_cur = mon_fdset;
1518                 if (fdset_id < mon_fdset_cur->id) {
1519                     break;
1520                 }
1521             }
1522         } else {
1523             /* Use first available fdset ID */
1524             QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1525                 mon_fdset_cur = mon_fdset;
1526                 if (fdset_id_prev == mon_fdset_cur->id - 1) {
1527                     fdset_id_prev = mon_fdset_cur->id;
1528                     continue;
1529                 }
1530                 break;
1531             }
1532         }
1533
1534         mon_fdset = g_malloc0(sizeof(*mon_fdset));
1535         if (has_fdset_id) {
1536             mon_fdset->id = fdset_id;
1537         } else {
1538             mon_fdset->id = fdset_id_prev + 1;
1539         }
1540
1541         /* The fdset list is ordered by fdset ID */
1542         if (!mon_fdset_cur) {
1543             QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
1544         } else if (mon_fdset->id < mon_fdset_cur->id) {
1545             QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
1546         } else {
1547             QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
1548         }
1549     }
1550
1551     mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
1552     mon_fdset_fd->fd = fd;
1553     mon_fdset_fd->removed = false;
1554     if (has_opaque) {
1555         mon_fdset_fd->opaque = g_strdup(opaque);
1556     }
1557     QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
1558
1559     fdinfo = g_malloc0(sizeof(*fdinfo));
1560     fdinfo->fdset_id = mon_fdset->id;
1561     fdinfo->fd = mon_fdset_fd->fd;
1562
1563     qemu_mutex_unlock(&mon_fdsets_lock);
1564     return fdinfo;
1565 }
1566
1567 int monitor_fdset_get_fd(int64_t fdset_id, int flags)
1568 {
1569 #ifdef _WIN32
1570     return -ENOENT;
1571 #else
1572     MonFdset *mon_fdset;
1573     MonFdsetFd *mon_fdset_fd;
1574     int mon_fd_flags;
1575     int ret;
1576
1577     qemu_mutex_lock(&mon_fdsets_lock);
1578     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1579         if (mon_fdset->id != fdset_id) {
1580             continue;
1581         }
1582         QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
1583             mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
1584             if (mon_fd_flags == -1) {
1585                 ret = -errno;
1586                 goto out;
1587             }
1588
1589             if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
1590                 ret = mon_fdset_fd->fd;
1591                 goto out;
1592             }
1593         }
1594         ret = -EACCES;
1595         goto out;
1596     }
1597     ret = -ENOENT;
1598
1599 out:
1600     qemu_mutex_unlock(&mon_fdsets_lock);
1601     return ret;
1602 #endif
1603 }
1604
1605 int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
1606 {
1607     MonFdset *mon_fdset;
1608     MonFdsetFd *mon_fdset_fd_dup;
1609
1610     qemu_mutex_lock(&mon_fdsets_lock);
1611     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1612         if (mon_fdset->id != fdset_id) {
1613             continue;
1614         }
1615         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
1616             if (mon_fdset_fd_dup->fd == dup_fd) {
1617                 goto err;
1618             }
1619         }
1620         mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
1621         mon_fdset_fd_dup->fd = dup_fd;
1622         QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
1623         qemu_mutex_unlock(&mon_fdsets_lock);
1624         return 0;
1625     }
1626
1627 err:
1628     qemu_mutex_unlock(&mon_fdsets_lock);
1629     return -1;
1630 }
1631
1632 static int64_t monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
1633 {
1634     MonFdset *mon_fdset;
1635     MonFdsetFd *mon_fdset_fd_dup;
1636
1637     qemu_mutex_lock(&mon_fdsets_lock);
1638     QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
1639         QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
1640             if (mon_fdset_fd_dup->fd == dup_fd) {
1641                 if (remove) {
1642                     QLIST_REMOVE(mon_fdset_fd_dup, next);
1643                     g_free(mon_fdset_fd_dup);
1644                     if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
1645                         monitor_fdset_cleanup(mon_fdset);
1646                     }
1647                     goto err;
1648                 } else {
1649                     qemu_mutex_unlock(&mon_fdsets_lock);
1650                     return mon_fdset->id;
1651                 }
1652             }
1653         }
1654     }
1655
1656 err:
1657     qemu_mutex_unlock(&mon_fdsets_lock);
1658     return -1;
1659 }
1660
1661 int64_t monitor_fdset_dup_fd_find(int dup_fd)
1662 {
1663     return monitor_fdset_dup_fd_find_remove(dup_fd, false);
1664 }
1665
1666 void monitor_fdset_dup_fd_remove(int dup_fd)
1667 {
1668     monitor_fdset_dup_fd_find_remove(dup_fd, true);
1669 }
1670
1671 int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
1672 {
1673     int fd;
1674     Error *local_err = NULL;
1675
1676     if (!qemu_isdigit(fdname[0]) && mon) {
1677         fd = monitor_get_fd(mon, fdname, &local_err);
1678     } else {
1679         fd = qemu_parse_fd(fdname);
1680         if (fd == -1) {
1681             error_setg(&local_err, "Invalid file descriptor number '%s'",
1682                        fdname);
1683         }
1684     }
1685     if (local_err) {
1686         error_propagate(errp, local_err);
1687         assert(fd == -1);
1688     } else {
1689         assert(fd != -1);
1690     }
1691
1692     return fd;
1693 }
1694
1695 /* Please update hmp-commands.hx when adding or changing commands */
1696 static HMPCommand hmp_info_cmds[] = {
1697 #include "hmp-commands-info.h"
1698     { NULL, NULL, },
1699 };
1700
1701 /* hmp_cmds and hmp_info_cmds would be sorted at runtime */
1702 HMPCommand hmp_cmds[] = {
1703 #include "hmp-commands.h"
1704     { NULL, NULL, },
1705 };
1706
1707 /*
1708  * Set @pval to the value in the register identified by @name.
1709  * return 0 if OK, -1 if not found
1710  */
1711 int get_monitor_def(int64_t *pval, const char *name)
1712 {
1713     const MonitorDef *md = target_monitor_defs();
1714     CPUState *cs = mon_get_cpu();
1715     void *ptr;
1716     uint64_t tmp = 0;
1717     int ret;
1718
1719     if (cs == NULL || md == NULL) {
1720         return -1;
1721     }
1722
1723     for(; md->name != NULL; md++) {
1724         if (hmp_compare_cmd(name, md->name)) {
1725             if (md->get_value) {
1726                 *pval = md->get_value(md, md->offset);
1727             } else {
1728                 CPUArchState *env = mon_get_cpu_env();
1729                 ptr = (uint8_t *)env + md->offset;
1730                 switch(md->type) {
1731                 case MD_I32:
1732                     *pval = *(int32_t *)ptr;
1733                     break;
1734                 case MD_TLONG:
1735                     *pval = *(target_long *)ptr;
1736                     break;
1737                 default:
1738                     *pval = 0;
1739                     break;
1740                 }
1741             }
1742             return 0;
1743         }
1744     }
1745
1746     ret = target_get_monitor_def(cs, name, &tmp);
1747     if (!ret) {
1748         *pval = (target_long) tmp;
1749     }
1750
1751     return ret;
1752 }
1753
1754 static void add_completion_option(ReadLineState *rs, const char *str,
1755                                   const char *option)
1756 {
1757     if (!str || !option) {
1758         return;
1759     }
1760     if (!strncmp(option, str, strlen(str))) {
1761         readline_add_completion(rs, option);
1762     }
1763 }
1764
1765 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1766 {
1767     size_t len;
1768     ChardevBackendInfoList *list, *start;
1769
1770     if (nb_args != 2) {
1771         return;
1772     }
1773     len = strlen(str);
1774     readline_set_completion_index(rs, len);
1775
1776     start = list = qmp_query_chardev_backends(NULL);
1777     while (list) {
1778         const char *chr_name = list->value->name;
1779
1780         if (!strncmp(chr_name, str, len)) {
1781             readline_add_completion(rs, chr_name);
1782         }
1783         list = list->next;
1784     }
1785     qapi_free_ChardevBackendInfoList(start);
1786 }
1787
1788 void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
1789 {
1790     size_t len;
1791     int i;
1792
1793     if (nb_args != 2) {
1794         return;
1795     }
1796     len = strlen(str);
1797     readline_set_completion_index(rs, len);
1798     for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
1799         add_completion_option(rs, str, NetClientDriver_str(i));
1800     }
1801 }
1802
1803 void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
1804 {
1805     GSList *list, *elt;
1806     size_t len;
1807
1808     if (nb_args != 2) {
1809         return;
1810     }
1811
1812     len = strlen(str);
1813     readline_set_completion_index(rs, len);
1814     list = elt = object_class_get_list(TYPE_DEVICE, false);
1815     while (elt) {
1816         const char *name;
1817         DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
1818                                              TYPE_DEVICE);
1819         name = object_class_get_name(OBJECT_CLASS(dc));
1820
1821         if (dc->user_creatable
1822             && !strncmp(name, str, len)) {
1823             readline_add_completion(rs, name);
1824         }
1825         elt = elt->next;
1826     }
1827     g_slist_free(list);
1828 }
1829
1830 void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
1831 {
1832     GSList *list, *elt;
1833     size_t len;
1834
1835     if (nb_args != 2) {
1836         return;
1837     }
1838
1839     len = strlen(str);
1840     readline_set_completion_index(rs, len);
1841     list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
1842     while (elt) {
1843         const char *name;
1844
1845         name = object_class_get_name(OBJECT_CLASS(elt->data));
1846         if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
1847             readline_add_completion(rs, name);
1848         }
1849         elt = elt->next;
1850     }
1851     g_slist_free(list);
1852 }
1853
1854 static int qdev_add_hotpluggable_device(Object *obj, void *opaque)
1855 {
1856     GSList **list = opaque;
1857     DeviceState *dev = (DeviceState *)object_dynamic_cast(OBJECT(obj),
1858                                                           TYPE_DEVICE);
1859
1860     if (dev == NULL) {
1861         return 0;
1862     }
1863
1864     if (dev->realized && object_property_get_bool(obj, "hotpluggable", NULL)) {
1865         *list = g_slist_append(*list, dev);
1866     }
1867
1868     return 0;
1869 }
1870
1871 static GSList *qdev_build_hotpluggable_device_list(Object *peripheral)
1872 {
1873     GSList *list = NULL;
1874
1875     object_child_foreach(peripheral, qdev_add_hotpluggable_device, &list);
1876
1877     return list;
1878 }
1879
1880 static void peripheral_device_del_completion(ReadLineState *rs,
1881                                              const char *str, size_t len)
1882 {
1883     Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
1884     GSList *list, *item;
1885
1886     list = qdev_build_hotpluggable_device_list(peripheral);
1887     if (!list) {
1888         return;
1889     }
1890
1891     for (item = list; item; item = g_slist_next(item)) {
1892         DeviceState *dev = item->data;
1893
1894         if (dev->id && !strncmp(str, dev->id, len)) {
1895             readline_add_completion(rs, dev->id);
1896         }
1897     }
1898
1899     g_slist_free(list);
1900 }
1901
1902 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
1903 {
1904     size_t len;
1905     ChardevInfoList *list, *start;
1906
1907     if (nb_args != 2) {
1908         return;
1909     }
1910     len = strlen(str);
1911     readline_set_completion_index(rs, len);
1912
1913     start = list = qmp_query_chardev(NULL);
1914     while (list) {
1915         ChardevInfo *chr = list->value;
1916
1917         if (!strncmp(chr->label, str, len)) {
1918             readline_add_completion(rs, chr->label);
1919         }
1920         list = list->next;
1921     }
1922     qapi_free_ChardevInfoList(start);
1923 }
1924
1925 static void ringbuf_completion(ReadLineState *rs, const char *str)
1926 {
1927     size_t len;
1928     ChardevInfoList *list, *start;
1929
1930     len = strlen(str);
1931     readline_set_completion_index(rs, len);
1932
1933     start = list = qmp_query_chardev(NULL);
1934     while (list) {
1935         ChardevInfo *chr_info = list->value;
1936
1937         if (!strncmp(chr_info->label, str, len)) {
1938             Chardev *chr = qemu_chr_find(chr_info->label);
1939             if (chr && CHARDEV_IS_RINGBUF(chr)) {
1940                 readline_add_completion(rs, chr_info->label);
1941             }
1942         }
1943         list = list->next;
1944     }
1945     qapi_free_ChardevInfoList(start);
1946 }
1947
1948 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
1949 {
1950     if (nb_args != 2) {
1951         return;
1952     }
1953     ringbuf_completion(rs, str);
1954 }
1955
1956 void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
1957 {
1958     size_t len;
1959
1960     if (nb_args != 2) {
1961         return;
1962     }
1963
1964     len = strlen(str);
1965     readline_set_completion_index(rs, len);
1966     peripheral_device_del_completion(rs, str, len);
1967 }
1968
1969 void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
1970 {
1971     ObjectPropertyInfoList *list, *start;
1972     size_t len;
1973
1974     if (nb_args != 2) {
1975         return;
1976     }
1977     len = strlen(str);
1978     readline_set_completion_index(rs, len);
1979
1980     start = list = qmp_qom_list("/objects", NULL);
1981     while (list) {
1982         ObjectPropertyInfo *info = list->value;
1983
1984         if (!strncmp(info->type, "child<", 5)
1985             && !strncmp(info->name, str, len)) {
1986             readline_add_completion(rs, info->name);
1987         }
1988         list = list->next;
1989     }
1990     qapi_free_ObjectPropertyInfoList(start);
1991 }
1992
1993 void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
1994 {
1995     int i;
1996     char *sep;
1997     size_t len;
1998
1999     if (nb_args != 2) {
2000         return;
2001     }
2002     sep = strrchr(str, '-');
2003     if (sep) {
2004         str = sep + 1;
2005     }
2006     len = strlen(str);
2007     readline_set_completion_index(rs, len);
2008     for (i = 0; i < Q_KEY_CODE__MAX; i++) {
2009         if (!strncmp(str, QKeyCode_str(i), len)) {
2010             readline_add_completion(rs, QKeyCode_str(i));
2011         }
2012     }
2013 }
2014
2015 void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
2016 {
2017     size_t len;
2018
2019     len = strlen(str);
2020     readline_set_completion_index(rs, len);
2021     if (nb_args == 2) {
2022         NetClientState *ncs[MAX_QUEUE_NUM];
2023         int count, i;
2024         count = qemu_find_net_clients_except(NULL, ncs,
2025                                              NET_CLIENT_DRIVER_NONE,
2026                                              MAX_QUEUE_NUM);
2027         for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
2028             const char *name = ncs[i]->name;
2029             if (!strncmp(str, name, len)) {
2030                 readline_add_completion(rs, name);
2031             }
2032         }
2033     } else if (nb_args == 3) {
2034         add_completion_option(rs, str, "on");
2035         add_completion_option(rs, str, "off");
2036     }
2037 }
2038
2039 void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
2040 {
2041     int len, count, i;
2042     NetClientState *ncs[MAX_QUEUE_NUM];
2043
2044     if (nb_args != 2) {
2045         return;
2046     }
2047
2048     len = strlen(str);
2049     readline_set_completion_index(rs, len);
2050     count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
2051                                          MAX_QUEUE_NUM);
2052     for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
2053         QemuOpts *opts;
2054         const char *name = ncs[i]->name;
2055         if (strncmp(str, name, len)) {
2056             continue;
2057         }
2058         opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
2059         if (opts) {
2060             readline_add_completion(rs, name);
2061         }
2062     }
2063 }
2064
2065 void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
2066 {
2067     size_t len;
2068
2069     len = strlen(str);
2070     readline_set_completion_index(rs, len);
2071     if (nb_args == 2) {
2072         TraceEventIter iter;
2073         TraceEvent *ev;
2074         char *pattern = g_strdup_printf("%s*", str);
2075         trace_event_iter_init(&iter, pattern);
2076         while ((ev = trace_event_iter_next(&iter)) != NULL) {
2077             readline_add_completion(rs, trace_event_get_name(ev));
2078         }
2079         g_free(pattern);
2080     }
2081 }
2082
2083 void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
2084 {
2085     size_t len;
2086
2087     len = strlen(str);
2088     readline_set_completion_index(rs, len);
2089     if (nb_args == 2) {
2090         TraceEventIter iter;
2091         TraceEvent *ev;
2092         char *pattern = g_strdup_printf("%s*", str);
2093         trace_event_iter_init(&iter, pattern);
2094         while ((ev = trace_event_iter_next(&iter)) != NULL) {
2095             readline_add_completion(rs, trace_event_get_name(ev));
2096         }
2097         g_free(pattern);
2098     } else if (nb_args == 3) {
2099         add_completion_option(rs, str, "on");
2100         add_completion_option(rs, str, "off");
2101     }
2102 }
2103
2104 void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
2105 {
2106     int i;
2107
2108     if (nb_args != 2) {
2109         return;
2110     }
2111     readline_set_completion_index(rs, strlen(str));
2112     for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
2113         add_completion_option(rs, str, WatchdogAction_str(i));
2114     }
2115 }
2116
2117 void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
2118                                        const char *str)
2119 {
2120     size_t len;
2121
2122     len = strlen(str);
2123     readline_set_completion_index(rs, len);
2124     if (nb_args == 2) {
2125         int i;
2126         for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
2127             const char *name = MigrationCapability_str(i);
2128             if (!strncmp(str, name, len)) {
2129                 readline_add_completion(rs, name);
2130             }
2131         }
2132     } else if (nb_args == 3) {
2133         add_completion_option(rs, str, "on");
2134         add_completion_option(rs, str, "off");
2135     }
2136 }
2137
2138 void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
2139                                       const char *str)
2140 {
2141     size_t len;
2142
2143     len = strlen(str);
2144     readline_set_completion_index(rs, len);
2145     if (nb_args == 2) {
2146         int i;
2147         for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
2148             const char *name = MigrationParameter_str(i);
2149             if (!strncmp(str, name, len)) {
2150                 readline_add_completion(rs, name);
2151             }
2152         }
2153     }
2154 }
2155
2156 static void vm_completion(ReadLineState *rs, const char *str)
2157 {
2158     size_t len;
2159     BlockDriverState *bs;
2160     BdrvNextIterator it;
2161
2162     len = strlen(str);
2163     readline_set_completion_index(rs, len);
2164
2165     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
2166         SnapshotInfoList *snapshots, *snapshot;
2167         AioContext *ctx = bdrv_get_aio_context(bs);
2168         bool ok = false;
2169
2170         aio_context_acquire(ctx);
2171         if (bdrv_can_snapshot(bs)) {
2172             ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
2173         }
2174         aio_context_release(ctx);
2175         if (!ok) {
2176             continue;
2177         }
2178
2179         snapshot = snapshots;
2180         while (snapshot) {
2181             char *completion = snapshot->value->name;
2182             if (!strncmp(str, completion, len)) {
2183                 readline_add_completion(rs, completion);
2184             }
2185             completion = snapshot->value->id;
2186             if (!strncmp(str, completion, len)) {
2187                 readline_add_completion(rs, completion);
2188             }
2189             snapshot = snapshot->next;
2190         }
2191         qapi_free_SnapshotInfoList(snapshots);
2192     }
2193
2194 }
2195
2196 void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
2197 {
2198     if (nb_args == 2) {
2199         vm_completion(rs, str);
2200     }
2201 }
2202
2203 void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
2204 {
2205     if (nb_args == 2) {
2206         vm_completion(rs, str);
2207     }
2208 }
2209
2210 static int
2211 compare_mon_cmd(const void *a, const void *b)
2212 {
2213     return strcmp(((const HMPCommand *)a)->name,
2214             ((const HMPCommand *)b)->name);
2215 }
2216
2217 static void sortcmdlist(void)
2218 {
2219     qsort(hmp_cmds, ARRAY_SIZE(hmp_cmds) - 1,
2220           sizeof(*hmp_cmds),
2221           compare_mon_cmd);
2222     qsort(hmp_info_cmds, ARRAY_SIZE(hmp_info_cmds) - 1,
2223           sizeof(*hmp_info_cmds),
2224           compare_mon_cmd);
2225 }
2226
2227 void monitor_init_globals(void)
2228 {
2229     monitor_init_globals_core();
2230     monitor_init_qmp_commands();
2231     sortcmdlist();
2232     qemu_mutex_init(&mon_fdsets_lock);
2233 }