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