cbf819979b
This requires giving them external linkage. Rename do_help_cmd() to hmp_help(), and do_print() to hmp_print(). Signed-off-by: Markus Armbruster <armbru@redhat.com> Message-Id: <20230124121946.1139465-30-armbru@redhat.com>
444 lines
11 KiB
C
444 lines
11 KiB
C
/*
|
|
* Human Monitor Interface commands
|
|
*
|
|
* Copyright IBM, Corp. 2011
|
|
*
|
|
* Authors:
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
* the COPYING file in the top-level directory.
|
|
*
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "exec/address-spaces.h"
|
|
#include "exec/gdbstub.h"
|
|
#include "exec/ioport.h"
|
|
#include "monitor/hmp.h"
|
|
#include "qemu/help_option.h"
|
|
#include "monitor/monitor-internal.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qapi-commands-control.h"
|
|
#include "qapi/qapi-commands-misc.h"
|
|
#include "qapi/qmp/qdict.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#include "qemu/cutils.h"
|
|
#include "hw/intc/intc.h"
|
|
#include "qemu/log.h"
|
|
#include "sysemu/sysemu.h"
|
|
|
|
bool hmp_handle_error(Monitor *mon, Error *err)
|
|
{
|
|
if (err) {
|
|
error_reportf_err(err, "Error: ");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Split @str at comma.
|
|
* A null @str defaults to "".
|
|
*/
|
|
strList *hmp_split_at_comma(const char *str)
|
|
{
|
|
char **split = g_strsplit(str ?: "", ",", -1);
|
|
strList *res = NULL;
|
|
strList **tail = &res;
|
|
int i;
|
|
|
|
for (i = 0; split[i]; i++) {
|
|
QAPI_LIST_APPEND(tail, split[i]);
|
|
}
|
|
|
|
g_free(split);
|
|
return res;
|
|
}
|
|
|
|
void hmp_info_name(Monitor *mon, const QDict *qdict)
|
|
{
|
|
NameInfo *info;
|
|
|
|
info = qmp_query_name(NULL);
|
|
if (info->name) {
|
|
monitor_printf(mon, "%s\n", info->name);
|
|
}
|
|
qapi_free_NameInfo(info);
|
|
}
|
|
|
|
void hmp_info_version(Monitor *mon, const QDict *qdict)
|
|
{
|
|
VersionInfo *info;
|
|
|
|
info = qmp_query_version(NULL);
|
|
|
|
monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
|
|
info->qemu->major, info->qemu->minor, info->qemu->micro,
|
|
info->package);
|
|
|
|
qapi_free_VersionInfo(info);
|
|
}
|
|
|
|
static int hmp_info_pic_foreach(Object *obj, void *opaque)
|
|
{
|
|
InterruptStatsProvider *intc;
|
|
InterruptStatsProviderClass *k;
|
|
Monitor *mon = opaque;
|
|
|
|
if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
|
|
intc = INTERRUPT_STATS_PROVIDER(obj);
|
|
k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
|
|
if (k->print_info) {
|
|
k->print_info(intc, mon);
|
|
} else {
|
|
monitor_printf(mon, "Interrupt controller information not available for %s.\n",
|
|
object_get_typename(obj));
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void hmp_info_pic(Monitor *mon, const QDict *qdict)
|
|
{
|
|
object_child_foreach_recursive(object_get_root(),
|
|
hmp_info_pic_foreach, mon);
|
|
}
|
|
|
|
void hmp_quit(Monitor *mon, const QDict *qdict)
|
|
{
|
|
monitor_suspend(mon);
|
|
qmp_quit(NULL);
|
|
}
|
|
|
|
void hmp_stop(Monitor *mon, const QDict *qdict)
|
|
{
|
|
qmp_stop(NULL);
|
|
}
|
|
|
|
void hmp_sync_profile(Monitor *mon, const QDict *qdict)
|
|
{
|
|
const char *op = qdict_get_try_str(qdict, "op");
|
|
|
|
if (op == NULL) {
|
|
bool on = qsp_is_enabled();
|
|
|
|
monitor_printf(mon, "sync-profile is %s\n", on ? "on" : "off");
|
|
return;
|
|
}
|
|
if (!strcmp(op, "on")) {
|
|
qsp_enable();
|
|
} else if (!strcmp(op, "off")) {
|
|
qsp_disable();
|
|
} else if (!strcmp(op, "reset")) {
|
|
qsp_reset();
|
|
} else {
|
|
Error *err = NULL;
|
|
|
|
error_setg(&err, QERR_INVALID_PARAMETER, op);
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
}
|
|
|
|
void hmp_exit_preconfig(Monitor *mon, const QDict *qdict)
|
|
{
|
|
Error *err = NULL;
|
|
|
|
qmp_x_exit_preconfig(&err);
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
|
|
void hmp_cpu(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int64_t cpu_index;
|
|
|
|
/* XXX: drop the monitor_set_cpu() usage when all HMP commands that
|
|
use it are converted to the QAPI */
|
|
cpu_index = qdict_get_int(qdict, "index");
|
|
if (monitor_set_cpu(mon, cpu_index) < 0) {
|
|
monitor_printf(mon, "invalid CPU index\n");
|
|
}
|
|
}
|
|
|
|
void hmp_cont(Monitor *mon, const QDict *qdict)
|
|
{
|
|
Error *err = NULL;
|
|
|
|
qmp_cont(&err);
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
|
|
void hmp_change(Monitor *mon, const QDict *qdict)
|
|
{
|
|
const char *device = qdict_get_str(qdict, "device");
|
|
const char *target = qdict_get_str(qdict, "target");
|
|
const char *arg = qdict_get_try_str(qdict, "arg");
|
|
const char *read_only = qdict_get_try_str(qdict, "read-only-mode");
|
|
bool force = qdict_get_try_bool(qdict, "force", false);
|
|
Error *err = NULL;
|
|
|
|
#ifdef CONFIG_VNC
|
|
if (strcmp(device, "vnc") == 0) {
|
|
hmp_change_vnc(mon, device, target, arg, read_only, force, &err);
|
|
} else
|
|
#endif
|
|
{
|
|
hmp_change_medium(mon, device, target, arg, read_only, force, &err);
|
|
}
|
|
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
|
|
void hmp_getfd(Monitor *mon, const QDict *qdict)
|
|
{
|
|
const char *fdname = qdict_get_str(qdict, "fdname");
|
|
Error *err = NULL;
|
|
|
|
qmp_getfd(fdname, &err);
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
|
|
void hmp_closefd(Monitor *mon, const QDict *qdict)
|
|
{
|
|
const char *fdname = qdict_get_str(qdict, "fdname");
|
|
Error *err = NULL;
|
|
|
|
qmp_closefd(fdname, &err);
|
|
hmp_handle_error(mon, err);
|
|
}
|
|
|
|
void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
|
|
{
|
|
IOThreadInfoList *info_list = qmp_query_iothreads(NULL);
|
|
IOThreadInfoList *info;
|
|
IOThreadInfo *value;
|
|
|
|
for (info = info_list; info; info = info->next) {
|
|
value = info->value;
|
|
monitor_printf(mon, "%s:\n", value->id);
|
|
monitor_printf(mon, " thread_id=%" PRId64 "\n", value->thread_id);
|
|
monitor_printf(mon, " poll-max-ns=%" PRId64 "\n", value->poll_max_ns);
|
|
monitor_printf(mon, " poll-grow=%" PRId64 "\n", value->poll_grow);
|
|
monitor_printf(mon, " poll-shrink=%" PRId64 "\n", value->poll_shrink);
|
|
monitor_printf(mon, " aio-max-batch=%" PRId64 "\n",
|
|
value->aio_max_batch);
|
|
}
|
|
|
|
qapi_free_IOThreadInfoList(info_list);
|
|
}
|
|
|
|
void hmp_help(Monitor *mon, const QDict *qdict)
|
|
{
|
|
hmp_help_cmd(mon, qdict_get_try_str(qdict, "name"));
|
|
}
|
|
|
|
void hmp_info_help(Monitor *mon, const QDict *qdict)
|
|
{
|
|
hmp_help_cmd(mon, "info");
|
|
}
|
|
|
|
void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int64_t max = qdict_get_try_int(qdict, "max", 10);
|
|
bool mean = qdict_get_try_bool(qdict, "mean", false);
|
|
bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
|
|
enum QSPSortBy sort_by;
|
|
|
|
sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
|
|
qsp_report(max, sort_by, coalesce);
|
|
}
|
|
|
|
void hmp_info_history(Monitor *mon, const QDict *qdict)
|
|
{
|
|
MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
|
|
int i;
|
|
const char *str;
|
|
|
|
if (!hmp_mon->rs) {
|
|
return;
|
|
}
|
|
i = 0;
|
|
for(;;) {
|
|
str = readline_get_history(hmp_mon->rs, i);
|
|
if (!str) {
|
|
break;
|
|
}
|
|
monitor_printf(mon, "%d: '%s'\n", i, str);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
void hmp_logfile(Monitor *mon, const QDict *qdict)
|
|
{
|
|
Error *err = NULL;
|
|
|
|
if (!qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err)) {
|
|
error_report_err(err);
|
|
}
|
|
}
|
|
|
|
void hmp_log(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int mask;
|
|
const char *items = qdict_get_str(qdict, "items");
|
|
Error *err = NULL;
|
|
|
|
if (!strcmp(items, "none")) {
|
|
mask = 0;
|
|
} else {
|
|
mask = qemu_str_to_log_mask(items);
|
|
if (!mask) {
|
|
hmp_help_cmd(mon, "log");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!qemu_set_log(mask, &err)) {
|
|
error_report_err(err);
|
|
}
|
|
}
|
|
|
|
void hmp_gdbserver(Monitor *mon, const QDict *qdict)
|
|
{
|
|
const char *device = qdict_get_try_str(qdict, "device");
|
|
if (!device) {
|
|
device = "tcp::" DEFAULT_GDBSTUB_PORT;
|
|
}
|
|
|
|
if (gdbserver_start(device) < 0) {
|
|
monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
|
|
device);
|
|
} else if (strcmp(device, "none") == 0) {
|
|
monitor_printf(mon, "Disabled gdbserver\n");
|
|
} else {
|
|
monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
|
|
device);
|
|
}
|
|
}
|
|
|
|
void hmp_print(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int format = qdict_get_int(qdict, "format");
|
|
hwaddr val = qdict_get_int(qdict, "val");
|
|
|
|
switch(format) {
|
|
case 'o':
|
|
monitor_printf(mon, "%#" HWADDR_PRIo, val);
|
|
break;
|
|
case 'x':
|
|
monitor_printf(mon, "%#" HWADDR_PRIx, val);
|
|
break;
|
|
case 'u':
|
|
monitor_printf(mon, "%" HWADDR_PRIu, val);
|
|
break;
|
|
default:
|
|
case 'd':
|
|
monitor_printf(mon, "%" HWADDR_PRId, val);
|
|
break;
|
|
case 'c':
|
|
monitor_printc(mon, val);
|
|
break;
|
|
}
|
|
monitor_printf(mon, "\n");
|
|
}
|
|
|
|
void hmp_sum(Monitor *mon, const QDict *qdict)
|
|
{
|
|
uint32_t addr;
|
|
uint16_t sum;
|
|
uint32_t start = qdict_get_int(qdict, "start");
|
|
uint32_t size = qdict_get_int(qdict, "size");
|
|
|
|
sum = 0;
|
|
for(addr = start; addr < (start + size); addr++) {
|
|
uint8_t val = address_space_ldub(&address_space_memory, addr,
|
|
MEMTXATTRS_UNSPECIFIED, NULL);
|
|
/* BSD sum algorithm ('sum' Unix command) */
|
|
sum = (sum >> 1) | (sum << 15);
|
|
sum += val;
|
|
}
|
|
monitor_printf(mon, "%05d\n", sum);
|
|
}
|
|
|
|
void hmp_ioport_read(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int size = qdict_get_int(qdict, "size");
|
|
int addr = qdict_get_int(qdict, "addr");
|
|
int has_index = qdict_haskey(qdict, "index");
|
|
uint32_t val;
|
|
int suffix;
|
|
|
|
if (has_index) {
|
|
int index = qdict_get_int(qdict, "index");
|
|
cpu_outb(addr & IOPORTS_MASK, index & 0xff);
|
|
addr++;
|
|
}
|
|
addr &= 0xffff;
|
|
|
|
switch(size) {
|
|
default:
|
|
case 1:
|
|
val = cpu_inb(addr);
|
|
suffix = 'b';
|
|
break;
|
|
case 2:
|
|
val = cpu_inw(addr);
|
|
suffix = 'w';
|
|
break;
|
|
case 4:
|
|
val = cpu_inl(addr);
|
|
suffix = 'l';
|
|
break;
|
|
}
|
|
monitor_printf(mon, "port%c[0x%04x] = 0x%0*x\n",
|
|
suffix, addr, size * 2, val);
|
|
}
|
|
|
|
void hmp_ioport_write(Monitor *mon, const QDict *qdict)
|
|
{
|
|
int size = qdict_get_int(qdict, "size");
|
|
int addr = qdict_get_int(qdict, "addr");
|
|
int val = qdict_get_int(qdict, "val");
|
|
|
|
addr &= IOPORTS_MASK;
|
|
|
|
switch (size) {
|
|
default:
|
|
case 1:
|
|
cpu_outb(addr, val);
|
|
break;
|
|
case 2:
|
|
cpu_outw(addr, val);
|
|
break;
|
|
case 4:
|
|
cpu_outl(addr, val);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void hmp_boot_set(Monitor *mon, const QDict *qdict)
|
|
{
|
|
Error *local_err = NULL;
|
|
const char *bootdevice = qdict_get_str(qdict, "bootdevice");
|
|
|
|
qemu_boot_set(bootdevice, &local_err);
|
|
if (local_err) {
|
|
error_report_err(local_err);
|
|
} else {
|
|
monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
|
|
}
|
|
}
|
|
|
|
void hmp_info_mtree(Monitor *mon, const QDict *qdict)
|
|
{
|
|
bool flatview = qdict_get_try_bool(qdict, "flatview", false);
|
|
bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
|
|
bool owner = qdict_get_try_bool(qdict, "owner", false);
|
|
bool disabled = qdict_get_try_bool(qdict, "disabled", false);
|
|
|
|
mtree_info(flatview, dispatch_tree, owner, disabled);
|
|
}
|