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