qemu-irix/hmp.c at 7e91e82044f8d23acfb9949a2cdd667a6b239acd · camthesaxman/qemu-irix

History

B41A

* Human Monitor Interface

* 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 "hmp.h"

#include "net/net.h"

#include "net/eth.h"

#include "chardev/char.h"

#include "sysemu/block-backend.h"

#include "sysemu/sysemu.h"

#include "qemu/config-file.h"

#include "qemu/option.h"

#include "qemu/timer.h"

#include "qmp-commands.h"

#include "qemu/sockets.h"

#include "monitor/monitor.h"

#include "monitor/qdev.h"

#include "qapi/opts-visitor.h"

#include "qapi/qmp/qerror.h"

#include "qapi/string-input-visitor.h"

#include "qapi/string-output-visitor.h"

#include "qapi/util.h"

#include "qapi-visit.h"

#include "qom/object_interfaces.h"

#include "ui/console.h"

#include "block/nbd.h"

#include "block/qapi.h"

#include "qemu-io.h"

#include "qemu/cutils.h"

#include "qemu/error-report.h"

#include "exec/ramlist.h"

#include "hw/intc/intc.h"

#include "migration/snapshot.h"

#include "migration/misc.h"

#ifdef CONFIG_SPICE

#include <spice/enums.h>

#endif

static void hmp_handle_error(Monitor *mon, Error **errp)

{

assert(errp);

if (*errp) {

error_report_err(*errp);

}

void hmp_info_name(Monitor *mon, const QDict *qdict)

{

NameInfo *info;

info = qmp_query_name(NULL);

if (info->has_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);

}

void hmp_info_kvm(Monitor *mon, const QDict *qdict)

{

KvmInfo *info;

info = qmp_query_kvm(NULL);

monitor_printf(mon, "kvm support: ");

if (info->present) {

monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");

} else {

monitor_printf(mon, "not compiled\n");

}

qapi_free_KvmInfo(info);

}

void hmp_info_status(Monitor *mon, const QDict *qdict)

{

StatusInfo *info;

info = qmp_query_status(NULL);

monitor_printf(mon, "VM status: %s%s",

info->running ? "running" : "paused",

info->singlestep ? " (single step mode)" : "");

if (!info->running && info->status != RUN_STATE_PAUSED) {

monitor_printf(mon, " (%s)", RunState_lookup[info->status]);

}

monitor_printf(mon, "\n");

qapi_free_StatusInfo(info);

}

void hmp_info_uuid(Monitor *mon, const QDict *qdict)

{

UuidInfo *info;

info = qmp_query_uuid(NULL);

monitor_printf(mon, "%s\n", info->UUID);

qapi_free_UuidInfo(info);

}

void hmp_info_chardev(Monitor *mon, const QDict *qdict)

{

ChardevInfoList *char_info, *info;

char_info = qmp_query_chardev(NULL);

for (info = char_info; info; info = info->next) {

monitor_printf(mon, "%s: filename=%s\n", info->value->label,

info->value->filename);

}

qapi_free_ChardevInfoList(char_info);

}

void hmp_info_mice(Monitor *mon, const QDict *qdict)

{

MouseInfoList *mice_list, *mouse;

mice_list = qmp_query_mice(NULL);

if (!mice_list) {

monitor_printf(mon, "No mouse devices connected\n");

return;

}

for (mouse = mice_list; mouse; mouse = mouse->next) {

monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",

mouse->value->current ? '*' : ' ',

mouse->value->index, mouse->value->name,

mouse->value->absolute ? " (absolute)" : "");

}

qapi_free_MouseInfoList(mice_list);

}

void hmp_info_migrate(Monitor *mon, const QDict *qdict)

{

MigrationInfo *info;

MigrationCapabilityStatusList *caps, *cap;

info = qmp_query_migrate(NULL);

caps = qmp_query_migrate_capabilities(NULL);

migration_global_dump(mon);

/* do not display parameters during setup */

if (info->has_status && caps) {

monitor_printf(mon, "capabilities: ");

for (cap = caps; cap; cap = cap->next) {

monitor_printf(mon, "%s: %s ",

MigrationCapability_lookup[cap->value->capability],

cap->value->state ? "on" : "off");

}

monitor_printf(mon, "\n");

}

if (info->has_status) {

monitor_printf(mon, "Migration status: %s",

MigrationStatus_lookup[info->status]);

if (info->status == MIGRATION_STATUS_FAILED &&

info->has_error_desc) {

monitor_printf(mon, " (%s)\n", info->error_desc);

} else {

monitor_printf(mon, "\n");

}

monitor_printf(mon, "total time: %" PRIu64 " milliseconds\n",

info->total_time);

if (info->has_expected_downtime) {

monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",

info->expected_downtime);

}

if (info->has_downtime) {

monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",

info->downtime);

}

if (info->has_setup_time) {

monitor_printf(mon, "setup: %" PRIu64 " milliseconds\n",

info->setup_time);

}

if (info->has_ram) {

monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",

info->ram->transferred >> 10);

monitor_printf(mon, "throughput: %0.2f mbps\n",

info->ram->mbps);

monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",

info->ram->remaining >> 10);

monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",

info->ram->total >> 10);

monitor_printf(mon, "duplicate: %" PRIu64 " pages\n",

info->ram->duplicate);

monitor_printf(mon, "skipped: %" PRIu64 " pages\n",

info->ram->skipped);

monitor_printf(mon, "normal: %" PRIu64 " pages\n",

info->ram->normal);

monitor_printf(mon, "normal bytes: %" PRIu64 " kbytes\n",

info->ram->normal_bytes >> 10);

monitor_printf(mon, "dirty sync count: %" PRIu64 "\n",

info->ram->dirty_sync_count);

monitor_printf(mon, "page size: %" PRIu64 " kbytes\n",

info->ram->page_size >> 10);

if (info->ram->dirty_pages_rate) {

monitor_printf(mon, "dirty pages rate: %" PRIu64 " pages\n",

info->ram->dirty_pages_rate);

}

if (info->ram->postcopy_requests) {

monitor_printf(mon, "postcopy request count: %" PRIu64 "\n",

info->ram->postcopy_requests);

}

if (info->has_disk) {

monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",

info->disk->transferred >> 10);

monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",

info->disk->remaining >> 10);

monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",

info->disk->total >> 10);

}

if (info->has_xbzrle_cache) {

monitor_printf(mon, "cache size: %" PRIu64 " bytes\n",

info->xbzrle_cache->cache_size);

monitor_printf(mon, "xbzrle transferred: %" PRIu64 " kbytes\n",

info->xbzrle_cache->bytes >> 10);

monitor_printf(mon, "xbzrle pages: %" PRIu64 " pages\n",

info->xbzrle_cache->pages);

monitor_printf(mon, "xbzrle cache miss: %" PRIu64 "\n",

info->xbzrle_cache->cache_miss);

monitor_printf(mon, "xbzrle cache miss rate: %0.2f\n",

info->xbzrle_cache->cache_miss_rate);

monitor_printf(mon, "xbzrle overflow : %" PRIu64 "\n",

info->xbzrle_cache->overflow);

}

if (info->has_cpu_throttle_percentage) {

monitor_printf(mon, "cpu throttle percentage: %" PRIu64 "\n",

info->cpu_throttle_percentage);

}

qapi_free_MigrationInfo(info);

qapi_free_MigrationCapabilityStatusList(caps);

}

void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)

{

MigrationCapabilityStatusList *caps, *cap;

caps = qmp_query_migrate_capabilities(NULL);

if (caps) {

for (cap = caps; cap; cap = cap->next) {

monitor_printf(mon, "%s: %s\n",

MigrationCapability_lookup[cap->value->capability],

cap->value->state ? "on" : "off");

}

qapi_free_MigrationCapabilityStatusList(caps);

}

void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)

{

MigrationParameters *params;

params = qmp_query_migrate_parameters(NULL);

if (params) {

assert(params->has_compress_level);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_LEVEL],

params->compress_level);

assert(params->has_compress_threads);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_THREADS],

params->compress_threads);

assert(params->has_decompress_threads);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_DECOMPRESS_THREADS],

params->decompress_threads);

assert(params->has_cpu_throttle_initial);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL],

params->cpu_throttle_initial);

assert(params->has_cpu_throttle_increment);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT],

params->cpu_throttle_increment);

monitor_printf(mon, "%s: '%s'\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_CREDS],

params->has_tls_creds ? params->tls_creds : "");

monitor_printf(mon, "%s: '%s'\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_HOSTNAME],

params->has_tls_hostname ? params->tls_hostname : "");

assert(params->has_max_bandwidth);

monitor_printf(mon, "%s: %" PRId64 " bytes/second\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_MAX_BANDWIDTH],

params->max_bandwidth);

assert(params->has_downtime_limit);

monitor_printf(mon, "%s: %" PRId64 " milliseconds\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_DOWNTIME_LIMIT],

params->downtime_limit);

assert(params->has_x_checkpoint_delay);

monitor_printf(mon, "%s: %" PRId64 "\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_X_CHECKPOINT_DELAY],

params->x_checkpoint_delay);

assert(params->has_block_incremental);

monitor_printf(mon, "%s: %s\n",

MigrationParameter_lookup[MIGRATION_PARAMETER_BLOCK_INCREMENTAL],

params->block_incremental ? "on" : "off");

}

qapi_free_MigrationParameters(params);

}

void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)

{

monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",

qmp_query_migrate_cache_size(NULL) >> 10);

}

void hmp_info_cpus(Monitor *mon, const QDict *qdict)

{

CpuInfoList *cpu_list, *cpu;

cpu_list = qmp_query_cpus(NULL);

for (cpu = cpu_list; cpu; cpu = cpu->next) {

int active = ' ';

if (cpu->value->CPU == monitor_get_cpu_index()) {

active = '*';

}

monitor_printf(mon, "%c CPU #%" PRId64 ":", active, cpu->value->CPU);

switch (cpu->value->arch) {

case CPU_INFO_ARCH_X86:

monitor_printf(mon, " pc=0x%016" PRIx64, cpu->value->u.x86.pc);

break;

case CPU_INFO_ARCH_PPC:

monitor_printf(mon, " nip=0x%016" PRIx64, cpu->value->u.ppc.nip);

break;

case CPU_INFO_ARCH_SPARC:

monitor_printf(mon, " pc=0x%016" PRIx64,

cpu->value->u.q_sparc.pc);

monitor_printf(mon, " npc=0x%016" PRIx64,

cpu->value->u.q_sparc.npc);

break;

case CPU_INFO_ARCH_MIPS:

monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->u.q_mips.PC);

break;

case CPU_INFO_ARCH_TRICORE:

monitor_printf(mon, " PC=0x%016" PRIx64, cpu->value->u.tricore.PC);

break;

default:

break;

}

if (cpu->value->halted) {

monitor_printf(mon, " (halted)");

}

monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);

}

qapi_free_CpuInfoList(cpu_list);

}

static void print_block_info(Monitor *mon, BlockInfo *info,

BlockDeviceInfo *inserted, bool verbose)

{

ImageInfo *image_info;

assert(!info || !info->has_inserted || info->inserted == inserted);

if (info && *info->device) {

monitor_printf(mon, "%s", info->device);

if (inserted && inserted->has_node_name) {

monitor_printf(mon, " (%s)", inserted->node_name);

}

} else {

assert(info || inserted);

monitor_printf(mon, "%s",

inserted && inserted->has_node_name ? inserted->node_name

: info && info->has_qdev ? info->qdev

: "<anonymous>");

}

if (inserted) {

monitor_printf(mon, ": %s (%s%s%s)\n",

inserted->file,

inserted->drv,

inserted->ro ? ", read-only" : "",

inserted->encrypted ? ", encrypted" : "");

} else {

monitor_printf(mon, ": [not inserted]\n");

}

if (info) {

if (info->has_qdev) {

monitor_printf(mon, " Attached to: %s\n", info->qdev);

}

if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {

monitor_printf(mon, " I/O status: %s\n",

BlockDeviceIoStatus_lookup[info->io_status]);

}

if (info->removable) {

monitor_printf(mon, " Removable device: %slocked, tray %s\n",

info->locked ? "" : "not ",

info->tray_open ? "open" : "closed");

}

if (!inserted) {

return;

}

monitor_printf(mon, " Cache mode: %s%s%s\n",

inserted->cache->writeback ? "writeback" : "writethrough",

inserted->cache->direct ? ", direct" : "",

inserted->cache->no_flush ? ", ignore flushes" : "");

if (inserted->has_backing_file) {

monitor_printf(mon,

" Backing file: %s "

"(chain depth: %" PRId64 ")\n",

inserted->backing_file,

inserted->backing_file_depth);

}

if (inserted->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF) {

monitor_printf(mon, " Detect zeroes: %s\n",

BlockdevDetectZeroesOptions_lookup[inserted->detect_zeroes]);

}

if (inserted->bps || inserted->bps_rd || inserted->bps_wr ||

inserted->iops || inserted->iops_rd || inserted->iops_wr)

{

monitor_printf(mon, " I/O throttling: bps=%" PRId64

" bps_rd=%" PRId64 " bps_wr=%" PRId64

" bps_max=%" PRId64

" bps_rd_max=%" PRId64

" bps_wr_max=%" PRId64

" iops=%" PRId64 " iops_rd=%" PRId64

" iops_wr=%" PRId64

" iops_max=%" PRId64

" iops_rd_max=%" PRId64

" iops_wr_max=%" PRId64

" iops_size=%" PRId64

" group=%s\n",

inserted->bps,

inserted->bps_rd,

inserted->bps_wr,

inserted->bps_max,

inserted->bps_rd_max,

inserted->bps_wr_max,

inserted->iops,

inserted->iops_rd,

inserted->iops_wr,

inserted->iops_max,

inserted->iops_rd_max,

inserted->iops_wr_max,

inserted->iops_size,

inserted->group);

}

if (verbose) {

monitor_printf(mon, "\nImages:\n");

image_info = inserted->image;

while (1) {

bdrv_image_info_dump((fprintf_function)monitor_printf,

mon, image_info);

if (image_info->has_backing_image) {

image_info = image_info->backing_image;

} else {

break;

}

void hmp_info_block(Monitor *mon, const QDict *qdict)

{

BlockInfoList *block_list, *info;

BlockDeviceInfoList *blockdev_list, *blockdev;

const char *device = qdict_get_try_str(qdict, "device");

bool verbose = qdict_get_try_bool(qdict, "verbose", false);

bool nodes = qdict_get_try_bool(qdict, "nodes", false);

bool printed = false;

/* Print BlockBackend information */

if (!nodes) {

block_list = qmp_query_block(NULL);

} else {

block_list = NULL;

}

for (info = block_list; info; info = info->next) {

if (device && strcmp(device, info->value->device)) {

continue;

}

if (info != block_list) {

monitor_printf(mon, "\n");

}

print_block_info(mon, info->value, info->value->has_inserted

? info->value->inserted : NULL,

verbose);

printed = true;

}

qapi_free_BlockInfoList(block_list);

if ((!device && !nodes) || printed) {

return;

}

/* 10000 Print node information */

blockdev_list = qmp_query_named_block_nodes(NULL);

for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {

assert(blockdev->value->has_node_name);

if (device && strcmp(device, blockdev->value->node_name)) {

continue;

}

if (blockdev != blockdev_list) {

monitor_printf(mon, "\n");

}

print_block_info(mon, NULL, blockdev->value, verbose);

}

qapi_free_BlockDeviceInfoList(blockdev_list);

}

void hmp_info_blockstats(Monitor *mon, const QDict *qdict)

{

BlockStatsList *stats_list, *stats;

stats_list = qmp_query_blockstats(false, false, NULL);

for (stats = stats_list; stats; stats = stats->next) {

if (!stats->value->has_device) {

continue;

}

monitor_printf(mon, "%s:", stats->value->device);

monitor_printf(mon, " rd_bytes=%" PRId64

" wr_bytes=%" PRId64

" rd_operations=%" PRId64

" wr_operations=%" PRId64

" flush_operations=%" PRId64

" wr_total_time_ns=%" PRId64

" rd_total_time_ns=%" PRId64

" flush_total_time_ns=%" PRId64

" rd_merged=%" PRId64

" wr_merged=%" PRId64

" idle_time_ns=%" PRId64

"\n",

stats->value->stats->rd_bytes,

stats->value->stats->wr_bytes,

stats->value->stats->rd_operations,

stats->value->stats->wr_operations,

stats->value->stats->flush_operations,

stats->value->stats->wr_total_time_ns,

stats->value->stats->rd_total_time_ns,

stats->value->stats->flush_total_time_ns,

stats->value->stats->rd_merged,

stats->value->stats->wr_merged,

stats->value->stats->idle_time_ns);

}

qapi_free_BlockStatsList(stats_list);

}

/* Helper for hmp_info_vnc_clients, _servers */

static void hmp_info_VncBasicInfo(Monitor *mon, VncBasicInfo *info,

const char *name)

{

monitor_printf(mon, " %s: %s:%s (%s%s)\n",

name,

info->host,

info->service,

NetworkAddressFamily_lookup[info->family],

info->websocket ? " (Websocket)" : "");

}

/* Helper displaying and auth and crypt info */

static void hmp_info_vnc_authcrypt(Monitor *mon, const char *indent,

VncPrimaryAuth auth,

VncVencryptSubAuth *vencrypt)

{

monitor_printf(mon, "%sAuth: %s (Sub: %s)\n", indent,

VncPrimaryAuth_lookup[auth],

vencrypt ? VncVencryptSubAuth_lookup[*vencrypt] : "none");

}

static void hmp_info_vnc_clients(Monitor *mon, VncClientInfoList *client)

{

while (client) {

VncClientInfo *cinfo = client->value;

hmp_info_VncBasicInfo(mon, qapi_VncClientInfo_base(cinfo), "Client");

monitor_printf(mon, " x509_dname: %s\n",

cinfo->has_x509_dname ?

cinfo->x509_dname : "none");

monitor_printf(mon, " sasl_username: %s\n",

cinfo->has_sasl_username ?

cinfo->sasl_username : "none");

client = client->next;

}

static void hmp_info_vnc_servers(Monitor *mon, VncServerInfo2List *server)

{

while (server) {

VncServerInfo2 *sinfo = server->value;

hmp_info_VncBasicInfo(mon, qapi_VncServerInfo2_base(sinfo), "Server");

hmp_info_vnc_authcrypt(mon, " ", sinfo->auth,

sinfo->has_vencrypt ? &sinfo->vencrypt : NULL);

server = server->next;

}

void hmp_info_vnc(Monitor *mon, const QDict *qdict)

{

VncInfo2List *info2l;

Error *err = NULL;

info2l = qmp_query_vnc_servers(&err);

if (err) {

error_report_err(err);

return;

}

if (!info2l) {

monitor_printf(mon, "None\n");

return;

}

while (info2l) {

VncInfo2 *info = info2l->value;

monitor_printf(mon, "%s:\n", info->id);

hmp_info_vnc_servers(mon, info->server);

hmp_info_vnc_clients(mon, info->clients);

if (!info->server) {

/* The server entry displays its auth, we only

* need to display in the case of 'reverse' connections

* where there's no server.

hmp_info_vnc_authcrypt(mon, " ", info->auth,

info->has_vencrypt ? &info->vencrypt : NULL);

}

if (info->has_display) {

monitor_printf(mon, " Display: %s\n", info->display);

}

info2l = info2l->next;

}

qapi_free_VncInfo2List(info2l);

}

#ifdef CONFIG_SPICE

void hmp_info_spice(Monitor *mon, const QDict *qdict)

{

SpiceChannelList *chan;

SpiceInfo *info;

const char *channel_name;

const char * const channel_names[] = {

[SPICE_CHANNEL_MAIN] = "main",

[SPICE_CHANNEL_DISPLAY] = "display",

[SPICE_CHANNEL_INPUTS] = "inputs",

[SPICE_CHANNEL_CURSOR] = "cursor",

[SPICE_CHANNEL_PLAYBACK] = "playback",

[SPICE_CHANNEL_RECORD] = "record",

[SPICE_CHANNEL_TUNNEL] = "tunnel",

[SPICE_CHANNEL_SMARTCARD] = "smartcard",

[SPICE_CHANNEL_USBREDIR] = "usbredir",

[SPICE_CHANNEL_PORT] = "port",

#if 0

/* minimum spice-protocol is 0.12.3, webdav was added in 0.12.7,

* no easy way to #ifdef (SPICE_CHANNEL_* is a enum). Disable

* as quick fix for build failures with older versions. */

[SPICE_CHANNEL_WEBDAV] = "webdav",

#endif

};

info = qmp_query_spice(NULL);

if (!info->enabled) {

monitor_printf(mon, "Server: disabled\n");

goto out;

}

monitor_printf(mon, "Server:\n");

if (info->has_port) {

monitor_printf(mon, " address: %s:%" PRId64 "\n",

info->host, info->port);

}

if (info->has_tls_port) {

monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",

info->host, info->tls_port);

}

monitor_printf(mon, " migrated: %s\n",

info->migrated ? "true" : "false");

monitor_printf(mon, " auth: %s\n", info->auth);

monitor_printf(mon, " compiled: %s\n", info->compiled_version);

monitor_printf(mon, " mouse-mode: %s\n",

SpiceQueryMouseMode_lookup[info->mouse_mode]);

if (!info->has_channels || info->channels == NULL) {

monitor_printf(mon, "Channels: none\n");

} else {

for (chan = info->channels; chan; chan = chan->next) {

monitor_printf(mon, "Channel:\n");

monitor_printf(mon, " address: %s:%s%s\n",

chan->value->host, chan->value->port,

chan->value->tls ? " [tls]" : "");

monitor_printf(mon, " session: %" PRId64 "\n",

chan->value->connection_id);

monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",

chan->value->channel_type, chan->value->channel_id);

channel_name = "unknown";

if (chan->value->channel_type > 0 &&

chan->value->channel_type < ARRAY_SIZE(channel_names) &&

channel_names[chan->value->channel_type]) {

channel_name = channel_names[chan->value->channel_type];

}

monitor_printf(mon, " channel name: %s\n", channel_name);

}

out:

qapi_free_SpiceInfo(info);

}

#endif

void hmp_info_balloon(Monitor *mon, const QDict *qdict)

{

BalloonInfo *info;

Error *err = NULL;

info = qmp_query_balloon(&err);

if (err) {

error_report_err(err);

return;

}

monitor_printf(mon, "balloon: actual=%" PRId64 "\n", info->actual >> 20);

qapi_free_BalloonInfo(info);

}

static void hmp_info_pci_device(Monitor *mon, const PciDeviceInfo *dev)

{

PciMemoryRegionList *region;

monitor_printf(mon, " Bus %2" PRId64 ", ", dev->bus);

monitor_printf(mon, "device %3" PRId64 ", function %" PRId64 ":\n",

dev->slot, dev->function);

monitor_printf(mon, " ");

if (dev->class_info->has_desc) {

monitor_printf(mon, "%s", dev->class_info->desc);

} else {

monitor_printf(mon, "Class %04" PRId64, dev->class_info->q_class);

}

monitor_printf(mon, ": PCI device %04" PRIx64 ":%04" PRIx64 "\n",

dev->id->vendor, dev->id->device);

if (dev->has_irq) {

monitor_printf(mon, " IRQ %" PRId64 ".\n", dev->irq);

}

if (dev->has_pci_bridge) {

monitor_printf(mon, " BUS %" PRId64 ".\n",

dev->pci_bridge->bus->number);

monitor_printf(mon, " secondary bus %" PRId64 ".\n",

dev->pci_bridge->bus->secondary);

monitor_printf(mon, " subordinate bus %" PRId64 ".\n",

dev->pci_bridge->bus->subordinate);

monitor_printf(mon, " IO range [0x%04"PRIx64", 0x%04"PRIx64"]\n",

dev->pci_bridge->bus->io_range->base,

dev->pci_bridge->bus->io_range->limit);

monitor_printf(mon,

E007 " memory range [0x%08"PRIx64", 0x%08"PRIx64"]\n",

dev->pci_bridge->bus->memory_range->base,

dev->pci_bridge->bus->memory_range->limit);

monitor_printf(mon, " prefetchable memory range "

"[0x%08"PRIx64", 0x%08"PRIx64"]\n",

dev->pci_bridge->bus->prefetchable_range->base,

dev->pci_bridge->bus->prefetchable_range->limit);

}

for (region = dev->regions; region; region = region->next) {

uint64_t addr, size;

addr = region->value->address;

size = region->value->size;

monitor_printf(mon, " BAR%" PRId64 ": ", region->value->bar);

if (!strcmp(region->value->type, "io")) {

monitor_printf(mon, "I/O at 0x%04" PRIx64

" [0x%04" PRIx64 "].\n",

addr, addr + size - 1);

} else {

monitor_printf(mon, "%d bit%s memory at 0x%08" PRIx64

" [0x%08" PRIx64 "].\n",

region->value->mem_type_64 ? 64 : 32,

region->value->prefetch ? " prefetchable" : "",

addr, addr + size - 1);

}

monitor_printf(mon, " id \"%s\"\n", dev->qdev_id);

if (dev->has_pci_bridge) {

if (dev->pci_bridge->has_devices) {

PciDeviceInfoList *cdev;

for (cdev = dev->pci_bridge->devices; cdev; cdev = cdev->next) {

hmp_info_pci_device(mon, cdev->value);

}

static int hmp_info_irq_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);

uint64_t *irq_counts;

unsigned int nb_irqs, i;

if (k->get_statistics &&

k->get_statistics(intc, &irq_counts, &nb_irqs)) {

if (nb_irqs > 0) {

monitor_printf(mon, "IRQ statistics for %s:\n",

object_get_typename(obj));

for (i = 0; i < nb_irqs; i++) {

if (irq_counts[i] > 0) {

monitor_printf(mon, "%2d: %" PRId64 "\n", i,

irq_counts[i]);

}

} else {

monitor_printf(mon, "IRQ statistics not available for %s.\n",

object_get_typename(obj));

}

return 0;

}

void hmp_info_irq(Monitor *mon, const QDict *qdict)

{

object_child_foreach_recursive(object_get_root(),

hmp_info_irq_foreach, mon);

}

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_info_pci(Monitor *mon, const QDict *qdict)

{

PciInfoList *info_list, *info;

Error *err = NULL;

info_list = qmp_query_pci(&err);

if (err) {

monitor_printf(mon, "PCI devices not supported\n");

error_free(err);

return;

}

for (info = info_list; info; info = info->next) {

PciDeviceInfoList *dev;

for (dev = info->value->devices; dev; dev = dev->next) {

hmp_info_pci_device(mon, dev->value);

}

qapi_free_PciInfoList(info_list);

}

void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)

{

BlockJobInfoList *list;

Error *err = NULL;

list = qmp_query_block_jobs(&err);

assert(!err);

if (!list) {

monitor_printf(mon, "No active jobs\n");

return;

}

while (list) {

if (strcmp(list->value->type, "stream") == 0) {

monitor_printf(mon, "Streaming device %s: Completed %" PRId64

" of %" PRId64 " bytes, speed limit %" PRId64

" bytes/s\n",

list->value->device,

list->value->offset,

list->value->len,

list->value->speed);

} else {

monitor_printf(mon, "Type %s, device %s: Completed %" PRId64

" of %" PRId64 " bytes, speed limit %" PRId64

" bytes/s\n",

list->value->type,

list->value->device,

list->value->offset,

list->value->len,

list->value->speed);

}

list = list->next;

}

qapi_free_BlockJobInfoList(list);

}

void hmp_info_tpm(Monitor *mon, const QDict *qdict)

{

TPMInfoList *info_list, *info;

Error *err = NULL;

unsigned int c = 0;

TPMPassthroughOptions *tpo;

info_list = qmp_query_tpm(&err);

if (err) {

monitor_printf(mon, "TPM device not supported\n");

error_free(err);

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

hmp.c

hmp.c

Files

hmp.c

Latest commit

History

hmp.c

File metadata and controls