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