[qemu.git] / hmp.c

/*
 * Human Monitor Interface
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

#include "hmp.h"
#include "qmp-commands.h"

void hmp_info_name(Monitor *mon)
{
    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)
{
    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)
{
    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)
{
    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)
{
    UuidInfo *info;

    info = qmp_query_uuid(NULL);
    monitor_printf(mon, "%s\n", info->UUID);
    qapi_free_UuidInfo(info);
}

void hmp_info_chardev(Monitor *mon)
{
    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)
{
    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)
{
    MigrationInfo *info;

    info = qmp_query_migrate(NULL);

    if (info->has_status) {
        monitor_printf(mon, "Migration status: %s\n", info->status);
    }

    if (info->has_ram) {
        monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
                       info->ram->transferred >> 10);
        monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
                       info->ram->remaining >> 10);
        monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
                       info->ram->total >> 10);
    }

    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);
    }

    qapi_free_MigrationInfo(info);
}

void hmp_info_cpus(Monitor *mon)
{
    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);

        if (cpu->value->has_pc) {
            monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
        }
        if (cpu->value->has_nip) {
            monitor_printf(mon, "nip=0x%016" PRIx64, cpu->value->nip);
        }
        if (cpu->value->has_npc) {
            monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
            monitor_printf(mon, "npc=0x%016" PRIx64, cpu->value->npc);
        }
        if (cpu->value->has_PC) {
            monitor_printf(mon, "PC=0x%016" PRIx64, cpu->value->PC);
        }

        if (cpu->value->halted) {
            monitor_printf(mon, " (halted)");
        }

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

    qapi_free_CpuInfoList(cpu_list);
}

void hmp_info_block(Monitor *mon)
{
    BlockInfoList *block_list, *info;

    block_list = qmp_query_block(NULL);

    for (info = block_list; info; info = info->next) {
        monitor_printf(mon, "%s: removable=%d",
                       info->value->device, info->value->removable);

        if (info->value->removable) {
            monitor_printf(mon, " locked=%d", info->value->locked);
            monitor_printf(mon, " tray-open=%d", info->value->tray_open);
        }

        if (info->value->has_io_status) {
            monitor_printf(mon, " io-status=%s",
                           BlockDeviceIoStatus_lookup[info->value->io_status]);
        }

        if (info->value->has_inserted) {
            monitor_printf(mon, " file=");
            monitor_print_filename(mon, info->value->inserted->file);

            if (info->value->inserted->has_backing_file) {
                monitor_printf(mon, " backing_file=");
                monitor_print_filename(mon, info->value->inserted->backing_file);
            }
            monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
                           info->value->inserted->ro,
                           info->value->inserted->drv,
                           info->value->inserted->encrypted);
        } else {
            monitor_printf(mon, " [not inserted]");
        }

        monitor_printf(mon, "\n");
    }

    qapi_free_BlockInfoList(block_list);
}

void hmp_info_blockstats(Monitor *mon)
{
    BlockStatsList *stats_list, *stats;

    stats_list = qmp_query_blockstats(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
                       "\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);
    }

    qapi_free_BlockStatsList(stats_list);
}

void hmp_info_vnc(Monitor *mon)
{
    VncInfo *info;
    Error *err = NULL;
    VncClientInfoList *client;

    info = qmp_query_vnc(&err);
    if (err) {
        monitor_printf(mon, "%s\n", error_get_pretty(err));
        error_free(err);
        return;
    }

    if (!info->enabled) {
        monitor_printf(mon, "Server: disabled\n");
        goto out;
    }

    monitor_printf(mon, "Server:\n");
    if (info->has_host && info->has_service) {
        monitor_printf(mon, "     address: %s:%s\n", info->host, info->service);
    }
    if (info->has_auth) {
        monitor_printf(mon, "        auth: %s\n", info->auth);
    }

    if (!info->has_clients || info->clients == NULL) {
        monitor_printf(mon, "Client: none\n");
    } else {
        for (client = info->clients; client; client = client->next) {
            monitor_printf(mon, "Client:\n");
            monitor_printf(mon, "     address: %s:%s\n",
                           client->value->host, client->value->service);
            monitor_printf(mon, "  x509_dname: %s\n",
                           client->value->x509_dname ?
                           client->value->x509_dname : "none");
            monitor_printf(mon, "    username: %s\n",
                           client->value->has_sasl_username ?
                           client->value->sasl_username : "none");
        }
    }

out:
    qapi_free_VncInfo(info);
}

void hmp_info_spice(Monitor *mon)
{
    SpiceChannelList *chan;
    SpiceInfo *info;

    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, "        auth: %s\n", info->auth);
    monitor_printf(mon, "    compiled: %s\n", info->compiled_version);

    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);
        }
    }

out:
    qapi_free_SpiceInfo(info);
}

void hmp_info_balloon(Monitor *mon)
{
    BalloonInfo *info;
    Error *err = NULL;

    info = qmp_query_balloon(&err);
    if (err) {
        monitor_printf(mon, "%s\n", error_get_pretty(err));
        error_free(err);
        return;
    }

    monitor_printf(mon, "balloon: actual=%" PRId64, info->actual >> 20);
    if (info->has_mem_swapped_in) {
        monitor_printf(mon, " mem_swapped_in=%" PRId64, info->mem_swapped_in);
    }
    if (info->has_mem_swapped_out) {
        monitor_printf(mon, " mem_swapped_out=%" PRId64, info->mem_swapped_out);
    }
    if (info->has_major_page_faults) {
        monitor_printf(mon, " major_page_faults=%" PRId64,
                       info->major_page_faults);
    }
    if (info->has_minor_page_faults) {
        monitor_printf(mon, " minor_page_faults=%" PRId64,
                       info->minor_page_faults);
    }
    if (info->has_free_mem) {
        monitor_printf(mon, " free_mem=%" PRId64, info->free_mem);
    }
    if (info->has_total_mem) {
        monitor_printf(mon, " total_mem=%" PRId64, info->total_mem);
    }

    monitor_printf(mon, "\n");

    qapi_free_BalloonInfo(info);
}

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_system_reset(Monitor *mon, const QDict *qdict)
{
    qmp_system_reset(NULL);
}

void hmp_system_powerdown(Monitor *mon, const QDict *qdict)
{
    qmp_system_powerdown(NULL);
}

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(cpu_index) < 0) {
        monitor_printf(mon, "invalid CPU index\n");
    }
}
Commit	Line	Data
48a32bed AL	1	/*
	2	* Human Monitor Interface
	3	*
	4	* Copyright IBM, Corp. 2011
	5	*
	6	* Authors:
	7	* Anthony Liguori <[email protected]>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2. See
	10	* the COPYING file in the top-level directory.
	11	*
	12	*/
	13
	14	#include "hmp.h"
	15	#include "qmp-commands.h"
	16
	17	void hmp_info_name(Monitor *mon)
	18	{
	19	NameInfo *info;
	20
	21	info = qmp_query_name(NULL);
	22	if (info->has_name) {
	23	monitor_printf(mon, "%s\n", info->name);
	24	}
	25	qapi_free_NameInfo(info);
	26	}
b9c15f16 LC	27
	28	void hmp_info_version(Monitor *mon)
	29	{
	30	VersionInfo *info;
	31
	32	info = qmp_query_version(NULL);
	33
	34	monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
	35	info->qemu.major, info->qemu.minor, info->qemu.micro,
	36	info->package);
	37
	38	qapi_free_VersionInfo(info);
	39	}
292a2602 LC	40
	41	void hmp_info_kvm(Monitor *mon)
	42	{
	43	KvmInfo *info;
	44
	45	info = qmp_query_kvm(NULL);
	46	monitor_printf(mon, "kvm support: ");
	47	if (info->present) {
	48	monitor_printf(mon, "%s\n", info->enabled ? "enabled" : "disabled");
	49	} else {
	50	monitor_printf(mon, "not compiled\n");
	51	}
	52
	53	qapi_free_KvmInfo(info);
	54	}
	55
1fa9a5e4 LC	56	void hmp_info_status(Monitor *mon)
	57	{
	58	StatusInfo *info;
	59
	60	info = qmp_query_status(NULL);
	61
	62	monitor_printf(mon, "VM status: %s%s",
	63	info->running ? "running" : "paused",
	64	info->singlestep ? " (single step mode)" : "");
	65
	66	if (!info->running && info->status != RUN_STATE_PAUSED) {
	67	monitor_printf(mon, " (%s)", RunState_lookup[info->status]);
	68	}
	69
	70	monitor_printf(mon, "\n");
	71
	72	qapi_free_StatusInfo(info);
	73	}
	74
efab767e LC	75	void hmp_info_uuid(Monitor *mon)
	76	{
	77	UuidInfo *info;
	78
	79	info = qmp_query_uuid(NULL);
	80	monitor_printf(mon, "%s\n", info->UUID);
	81	qapi_free_UuidInfo(info);
	82	}
c5a415a0 LC	83
	84	void hmp_info_chardev(Monitor *mon)
	85	{
	86	ChardevInfoList char_info, info;
	87
	88	char_info = qmp_query_chardev(NULL);
	89	for (info = char_info; info; info = info->next) {
	90	monitor_printf(mon, "%s: filename=%s\n", info->value->label,
	91	info->value->filename);
	92	}
	93
	94	qapi_free_ChardevInfoList(char_info);
	95	}
7a7f325e	96
e235cec3 LC	97	void hmp_info_mice(Monitor *mon)
	98	{
	99	MouseInfoList mice_list, mouse;
	100
	101	mice_list = qmp_query_mice(NULL);
	102	if (!mice_list) {
	103	monitor_printf(mon, "No mouse devices connected\n");
	104	return;
	105	}
	106
	107	for (mouse = mice_list; mouse; mouse = mouse->next) {
	108	monitor_printf(mon, "%c Mouse #%" PRId64 ": %s%s\n",
	109	mouse->value->current ? '*' : ' ',
	110	mouse->value->index, mouse->value->name,
	111	mouse->value->absolute ? " (absolute)" : "");
	112	}
	113
	114	qapi_free_MouseInfoList(mice_list);
	115	}
	116
791e7c82 LC	117	void hmp_info_migrate(Monitor *mon)
	118	{
	119	MigrationInfo *info;
	120
	121	info = qmp_query_migrate(NULL);
	122
	123	if (info->has_status) {
	124	monitor_printf(mon, "Migration status: %s\n", info->status);
	125	}
	126
	127	if (info->has_ram) {
	128	monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n",
	129	info->ram->transferred >> 10);
	130	monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n",
	131	info->ram->remaining >> 10);
	132	monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n",
	133	info->ram->total >> 10);
	134	}
	135
	136	if (info->has_disk) {
	137	monitor_printf(mon, "transferred disk: %" PRIu64 " kbytes\n",
	138	info->disk->transferred >> 10);
	139	monitor_printf(mon, "remaining disk: %" PRIu64 " kbytes\n",
	140	info->disk->remaining >> 10);
	141	monitor_printf(mon, "total disk: %" PRIu64 " kbytes\n",
	142	info->disk->total >> 10);
	143	}
	144
	145	qapi_free_MigrationInfo(info);
	146	}
	147
de0b36b6 LC	148	void hmp_info_cpus(Monitor *mon)
	149	{
	150	CpuInfoList cpu_list, cpu;
	151
	152	cpu_list = qmp_query_cpus(NULL);
	153
	154	for (cpu = cpu_list; cpu; cpu = cpu->next) {
	155	int active = ' ';
	156
	157	if (cpu->value->CPU == monitor_get_cpu_index()) {
	158	active = '*';
	159	}
	160
	161	monitor_printf(mon, "%c CPU #%" PRId64 ": ", active, cpu->value->CPU);
	162
	163	if (cpu->value->has_pc) {
	164	monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
	165	}
	166	if (cpu->value->has_nip) {
	167	monitor_printf(mon, "nip=0x%016" PRIx64, cpu->value->nip);
	168	}
	169	if (cpu->value->has_npc) {
	170	monitor_printf(mon, "pc=0x%016" PRIx64, cpu->value->pc);
	171	monitor_printf(mon, "npc=0x%016" PRIx64, cpu->value->npc);
	172	}
	173	if (cpu->value->has_PC) {
	174	monitor_printf(mon, "PC=0x%016" PRIx64, cpu->value->PC);
	175	}
	176
	177	if (cpu->value->halted) {
	178	monitor_printf(mon, " (halted)");
	179	}
	180
	181	monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
	182	}
	183
	184	qapi_free_CpuInfoList(cpu_list);
	185	}
	186
b2023818 LC	187	void hmp_info_block(Monitor *mon)
	188	{
	189	BlockInfoList block_list, info;
	190
	191	block_list = qmp_query_block(NULL);
	192
	193	for (info = block_list; info; info = info->next) {
	194	monitor_printf(mon, "%s: removable=%d",
	195	info->value->device, info->value->removable);
	196
	197	if (info->value->removable) {
	198	monitor_printf(mon, " locked=%d", info->value->locked);
	199	monitor_printf(mon, " tray-open=%d", info->value->tray_open);
	200	}
	201
	202	if (info->value->has_io_status) {
	203	monitor_printf(mon, " io-status=%s",
	204	BlockDeviceIoStatus_lookup[info->value->io_status]);
	205	}
	206
	207	if (info->value->has_inserted) {
	208	monitor_printf(mon, " file=");
	209	monitor_print_filename(mon, info->value->inserted->file);
	210
	211	if (info->value->inserted->has_backing_file) {
	212	monitor_printf(mon, " backing_file=");
	213	monitor_print_filename(mon, info->value->inserted->backing_file);
	214	}
	215	monitor_printf(mon, " ro=%d drv=%s encrypted=%d",
	216	info->value->inserted->ro,
	217	info->value->inserted->drv,
	218	info->value->inserted->encrypted);
	219	} else {
	220	monitor_printf(mon, " [not inserted]");
	221	}
	222
	223	monitor_printf(mon, "\n");
	224	}
	225
	226	qapi_free_BlockInfoList(block_list);
	227	}
	228
f11f57e4 LC	229	void hmp_info_blockstats(Monitor *mon)
	230	{
	231	BlockStatsList stats_list, stats;
	232
	233	stats_list = qmp_query_blockstats(NULL);
	234
	235	for (stats = stats_list; stats; stats = stats->next) {
	236	if (!stats->value->has_device) {
	237	continue;
	238	}
	239
	240	monitor_printf(mon, "%s:", stats->value->device);
	241	monitor_printf(mon, " rd_bytes=%" PRId64
	242	" wr_bytes=%" PRId64
	243	" rd_operations=%" PRId64
	244	" wr_operations=%" PRId64
	245	" flush_operations=%" PRId64
	246	" wr_total_time_ns=%" PRId64
	247	" rd_total_time_ns=%" PRId64
	248	" flush_total_time_ns=%" PRId64
	249	"\n",
	250	stats->value->stats->rd_bytes,
	251	stats->value->stats->wr_bytes,
	252	stats->value->stats->rd_operations,
	253	stats->value->stats->wr_operations,
	254	stats->value->stats->flush_operations,
	255	stats->value->stats->wr_total_time_ns,
	256	stats->value->stats->rd_total_time_ns,
	257	stats->value->stats->flush_total_time_ns);
	258	}
	259
	260	qapi_free_BlockStatsList(stats_list);
	261	}
	262
2b54aa87 LC	263	void hmp_info_vnc(Monitor *mon)
	264	{
	265	VncInfo *info;
	266	Error *err = NULL;
	267	VncClientInfoList *client;
	268
	269	info = qmp_query_vnc(&err);
	270	if (err) {
	271	monitor_printf(mon, "%s\n", error_get_pretty(err));
	272	error_free(err);
	273	return;
	274	}
	275
	276	if (!info->enabled) {
	277	monitor_printf(mon, "Server: disabled\n");
	278	goto out;
	279	}
	280
	281	monitor_printf(mon, "Server:\n");
	282	if (info->has_host && info->has_service) {
	283	monitor_printf(mon, " address: %s:%s\n", info->host, info->service);
	284	}
	285	if (info->has_auth) {
	286	monitor_printf(mon, " auth: %s\n", info->auth);
	287	}
	288
	289	if (!info->has_clients \|\| info->clients == NULL) {
	290	monitor_printf(mon, "Client: none\n");
	291	} else {
	292	for (client = info->clients; client; client = client->next) {
	293	monitor_printf(mon, "Client:\n");
	294	monitor_printf(mon, " address: %s:%s\n",
	295	client->value->host, client->value->service);
	296	monitor_printf(mon, " x509_dname: %s\n",
	297	client->value->x509_dname ?
	298	client->value->x509_dname : "none");
	299	monitor_printf(mon, " username: %s\n",
	300	client->value->has_sasl_username ?
	301	client->value->sasl_username : "none");
	302	}
	303	}
	304
	305	out:
	306	qapi_free_VncInfo(info);
	307	}
	308
d1f29646 LC	309	void hmp_info_spice(Monitor *mon)
	310	{
	311	SpiceChannelList *chan;
	312	SpiceInfo *info;
	313
	314	info = qmp_query_spice(NULL);
	315
	316	if (!info->enabled) {
	317	monitor_printf(mon, "Server: disabled\n");
	318	goto out;
	319	}
	320
	321	monitor_printf(mon, "Server:\n");
	322	if (info->has_port) {
	323	monitor_printf(mon, " address: %s:%" PRId64 "\n",
	324	info->host, info->port);
	325	}
	326	if (info->has_tls_port) {
	327	monitor_printf(mon, " address: %s:%" PRId64 " [tls]\n",
	328	info->host, info->tls_port);
	329	}
	330	monitor_printf(mon, " auth: %s\n", info->auth);
	331	monitor_printf(mon, " compiled: %s\n", info->compiled_version);
	332
	333	if (!info->has_channels \|\| info->channels == NULL) {
	334	monitor_printf(mon, "Channels: none\n");
	335	} else {
	336	for (chan = info->channels; chan; chan = chan->next) {
	337	monitor_printf(mon, "Channel:\n");
	338	monitor_printf(mon, " address: %s:%s%s\n",
	339	chan->value->host, chan->value->port,
	340	chan->value->tls ? " [tls]" : "");
	341	monitor_printf(mon, " session: %" PRId64 "\n",
	342	chan->value->connection_id);
	343	monitor_printf(mon, " channel: %" PRId64 ":%" PRId64 "\n",
	344	chan->value->channel_type, chan->value->channel_id);
	345	}
	346	}
	347
	348	out:
	349	qapi_free_SpiceInfo(info);
	350	}
	351
96637bcd LC	352	void hmp_info_balloon(Monitor *mon)
	353	{
	354	BalloonInfo *info;
	355	Error *err = NULL;
	356
	357	info = qmp_query_balloon(&err);
	358	if (err) {
	359	monitor_printf(mon, "%s\n", error_get_pretty(err));
	360	error_free(err);
	361	return;
	362	}
	363
	364	monitor_printf(mon, "balloon: actual=%" PRId64, info->actual >> 20);
	365	if (info->has_mem_swapped_in) {
	366	monitor_printf(mon, " mem_swapped_in=%" PRId64, info->mem_swapped_in);
	367	}
	368	if (info->has_mem_swapped_out) {
	369	monitor_printf(mon, " mem_swapped_out=%" PRId64, info->mem_swapped_out);
	370	}
	371	if (info->has_major_page_faults) {
	372	monitor_printf(mon, " major_page_faults=%" PRId64,
	373	info->major_page_faults);
	374	}
	375	if (info->has_minor_page_faults) {
	376	monitor_printf(mon, " minor_page_faults=%" PRId64,
	377	info->minor_page_faults);
	378	}
	379	if (info->has_free_mem) {
	380	monitor_printf(mon, " free_mem=%" PRId64, info->free_mem);
	381	}
	382	if (info->has_total_mem) {
	383	monitor_printf(mon, " total_mem=%" PRId64, info->total_mem);
	384	}
	385
	386	monitor_printf(mon, "\n");
	387
	388	qapi_free_BalloonInfo(info);
	389	}
	390
7a7f325e LC	391	void hmp_quit(Monitor mon, const QDict qdict)
	392	{
	393	monitor_suspend(mon);
	394	qmp_quit(NULL);
	395	}
5f158f21 LC	396
	397	void hmp_stop(Monitor mon, const QDict qdict)
	398	{
	399	qmp_stop(NULL);
	400	}
38d22653 LC	401
	402	void hmp_system_reset(Monitor mon, const QDict qdict)
	403	{
	404	qmp_system_reset(NULL);
	405	}
5bc465e4 LC	406
	407	void hmp_system_powerdown(Monitor mon, const QDict qdict)
	408	{
	409	qmp_system_powerdown(NULL);
	410	}
755f1968 LC	411
	412	void hmp_cpu(Monitor mon, const QDict qdict)
	413	{
	414	int64_t cpu_index;
	415
	416	/* XXX: drop the monitor_set_cpu() usage when all HMP commands that
	417	use it are converted to the QAPI */
	418	cpu_index = qdict_get_int(qdict, "index");
	419	if (monitor_set_cpu(cpu_index) < 0) {
	420	monitor_printf(mon, "invalid CPU index\n");
	421	}
	422	}