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