This is a counterpart to the HMP "info profile" command. It is being added with an "x-" prefix because this QMP command is intended as an adhoc debugging tool and will thus not be modelled in QAPI as fully structured data, nor will it have long term guaranteed stability. The existing HMP command is rewritten to call the QMP command. Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com> Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
385 lines
10 KiB
C
385 lines
10 KiB
C
/*
|
|
* QEMU Management Protocol 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 "qemu-common.h"
|
|
#include "qemu/cutils.h"
|
|
#include "qemu/option.h"
|
|
#include "monitor/monitor.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "qemu/config-file.h"
|
|
#include "qemu/uuid.h"
|
|
#include "chardev/char.h"
|
|
#include "ui/qemu-spice.h"
|
|
#include "ui/console.h"
|
|
#include "sysemu/kvm.h"
|
|
#include "sysemu/runstate.h"
|
|
#include "sysemu/runstate-action.h"
|
|
#include "sysemu/blockdev.h"
|
|
#include "sysemu/block-backend.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qapi-commands-acpi.h"
|
|
#include "qapi/qapi-commands-block.h"
|
|
#include "qapi/qapi-commands-control.h"
|
|
#include "qapi/qapi-commands-machine.h"
|
|
#include "qapi/qapi-commands-misc.h"
|
|
#include "qapi/qapi-commands-ui.h"
|
|
#include "qapi/type-helpers.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#include "hw/mem/memory-device.h"
|
|
#include "hw/acpi/acpi_dev_interface.h"
|
|
|
|
NameInfo *qmp_query_name(Error **errp)
|
|
{
|
|
NameInfo *info = g_malloc0(sizeof(*info));
|
|
|
|
if (qemu_name) {
|
|
info->has_name = true;
|
|
info->name = g_strdup(qemu_name);
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
KvmInfo *qmp_query_kvm(Error **errp)
|
|
{
|
|
KvmInfo *info = g_malloc0(sizeof(*info));
|
|
|
|
info->enabled = kvm_enabled();
|
|
info->present = accel_find("kvm");
|
|
|
|
return info;
|
|
}
|
|
|
|
UuidInfo *qmp_query_uuid(Error **errp)
|
|
{
|
|
UuidInfo *info = g_malloc0(sizeof(*info));
|
|
|
|
info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
|
|
return info;
|
|
}
|
|
|
|
void qmp_quit(Error **errp)
|
|
{
|
|
shutdown_action = SHUTDOWN_ACTION_POWEROFF;
|
|
qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP_QUIT);
|
|
}
|
|
|
|
void qmp_stop(Error **errp)
|
|
{
|
|
/* if there is a dump in background, we should wait until the dump
|
|
* finished */
|
|
if (dump_in_progress()) {
|
|
error_setg(errp, "There is a dump in process, please wait.");
|
|
return;
|
|
}
|
|
|
|
if (runstate_check(RUN_STATE_INMIGRATE)) {
|
|
autostart = 0;
|
|
} else {
|
|
vm_stop(RUN_STATE_PAUSED);
|
|
}
|
|
}
|
|
|
|
void qmp_system_reset(Error **errp)
|
|
{
|
|
qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET);
|
|
}
|
|
|
|
void qmp_system_powerdown(Error **errp)
|
|
{
|
|
qemu_system_powerdown_request();
|
|
}
|
|
|
|
void qmp_cont(Error **errp)
|
|
{
|
|
BlockBackend *blk;
|
|
BlockJob *job;
|
|
Error *local_err = NULL;
|
|
|
|
/* if there is a dump in background, we should wait until the dump
|
|
* finished */
|
|
if (dump_in_progress()) {
|
|
error_setg(errp, "There is a dump in process, please wait.");
|
|
return;
|
|
}
|
|
|
|
if (runstate_needs_reset()) {
|
|
error_setg(errp, "Resetting the Virtual Machine is required");
|
|
return;
|
|
} else if (runstate_check(RUN_STATE_SUSPENDED)) {
|
|
return;
|
|
} else if (runstate_check(RUN_STATE_FINISH_MIGRATE)) {
|
|
error_setg(errp, "Migration is not finalized yet");
|
|
return;
|
|
}
|
|
|
|
for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
|
|
blk_iostatus_reset(blk);
|
|
}
|
|
|
|
for (job = block_job_next(NULL); job; job = block_job_next(job)) {
|
|
block_job_iostatus_reset(job);
|
|
}
|
|
|
|
/* Continuing after completed migration. Images have been inactivated to
|
|
* allow the destination to take control. Need to get control back now.
|
|
*
|
|
* If there are no inactive block nodes (e.g. because the VM was just
|
|
* paused rather than completing a migration), bdrv_inactivate_all() simply
|
|
* doesn't do anything. */
|
|
bdrv_invalidate_cache_all(&local_err);
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
if (runstate_check(RUN_STATE_INMIGRATE)) {
|
|
autostart = 1;
|
|
} else {
|
|
vm_start();
|
|
}
|
|
}
|
|
|
|
void qmp_system_wakeup(Error **errp)
|
|
{
|
|
if (!qemu_wakeup_suspend_enabled()) {
|
|
error_setg(errp,
|
|
"wake-up from suspend is not supported by this guest");
|
|
return;
|
|
}
|
|
|
|
qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, errp);
|
|
}
|
|
|
|
void qmp_set_password(const char *protocol, const char *password,
|
|
bool has_connected, const char *connected, Error **errp)
|
|
{
|
|
int disconnect_if_connected = 0;
|
|
int fail_if_connected = 0;
|
|
int rc;
|
|
|
|
if (has_connected) {
|
|
if (strcmp(connected, "fail") == 0) {
|
|
fail_if_connected = 1;
|
|
} else if (strcmp(connected, "disconnect") == 0) {
|
|
disconnect_if_connected = 1;
|
|
} else if (strcmp(connected, "keep") == 0) {
|
|
/* nothing */
|
|
} else {
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "connected");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (strcmp(protocol, "spice") == 0) {
|
|
if (!qemu_using_spice(errp)) {
|
|
return;
|
|
}
|
|
rc = qemu_spice.set_passwd(password, fail_if_connected,
|
|
disconnect_if_connected);
|
|
} else if (strcmp(protocol, "vnc") == 0) {
|
|
if (fail_if_connected || disconnect_if_connected) {
|
|
/* vnc supports "connected=keep" only */
|
|
error_setg(errp, QERR_INVALID_PARAMETER, "connected");
|
|
return;
|
|
}
|
|
/* Note that setting an empty password will not disable login through
|
|
* this interface. */
|
|
rc = vnc_display_password(NULL, password);
|
|
} else {
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol",
|
|
"'vnc' or 'spice'");
|
|
return;
|
|
}
|
|
|
|
if (rc != 0) {
|
|
error_setg(errp, "Could not set password");
|
|
}
|
|
}
|
|
|
|
void qmp_expire_password(const char *protocol, const char *whenstr,
|
|
Error **errp)
|
|
{
|
|
time_t when;
|
|
int rc;
|
|
|
|
if (strcmp(whenstr, "now") == 0) {
|
|
when = 0;
|
|
} else if (strcmp(whenstr, "never") == 0) {
|
|
when = TIME_MAX;
|
|
} else if (whenstr[0] == '+') {
|
|
when = time(NULL) + strtoull(whenstr+1, NULL, 10);
|
|
} else {
|
|
when = strtoull(whenstr, NULL, 10);
|
|
}
|
|
|
|
if (strcmp(protocol, "spice") == 0) {
|
|
if (!qemu_using_spice(errp)) {
|
|
return;
|
|
}
|
|
rc = qemu_spice.set_pw_expire(when);
|
|
} else if (strcmp(protocol, "vnc") == 0) {
|
|
rc = vnc_display_pw_expire(NULL, when);
|
|
} else {
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol",
|
|
"'vnc' or 'spice'");
|
|
return;
|
|
}
|
|
|
|
if (rc != 0) {
|
|
error_setg(errp, "Could not set password expire time");
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_VNC
|
|
void qmp_change_vnc_password(const char *password, Error **errp)
|
|
{
|
|
if (vnc_display_password(NULL, password) < 0) {
|
|
error_setg(errp, "Could not set password");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void qmp_add_client(const char *protocol, const char *fdname,
|
|
bool has_skipauth, bool skipauth, bool has_tls, bool tls,
|
|
Error **errp)
|
|
{
|
|
Chardev *s;
|
|
int fd;
|
|
|
|
fd = monitor_get_fd(monitor_cur(), fdname, errp);
|
|
if (fd < 0) {
|
|
return;
|
|
}
|
|
|
|
if (strcmp(protocol, "spice") == 0) {
|
|
if (!qemu_using_spice(errp)) {
|
|
close(fd);
|
|
return;
|
|
}
|
|
skipauth = has_skipauth ? skipauth : false;
|
|
tls = has_tls ? tls : false;
|
|
if (qemu_spice.display_add_client(fd, skipauth, tls) < 0) {
|
|
error_setg(errp, "spice failed to add client");
|
|
close(fd);
|
|
}
|
|
return;
|
|
#ifdef CONFIG_VNC
|
|
} else if (strcmp(protocol, "vnc") == 0) {
|
|
skipauth = has_skipauth ? skipauth : false;
|
|
vnc_display_add_client(NULL, fd, skipauth);
|
|
return;
|
|
#endif
|
|
} else if ((s = qemu_chr_find(protocol)) != NULL) {
|
|
if (qemu_chr_add_client(s, fd) < 0) {
|
|
error_setg(errp, "failed to add client");
|
|
close(fd);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
error_setg(errp, "protocol '%s' is invalid", protocol);
|
|
close(fd);
|
|
}
|
|
|
|
|
|
MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
|
|
{
|
|
return qmp_memory_device_list();
|
|
}
|
|
|
|
ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
|
|
{
|
|
bool ambig;
|
|
ACPIOSTInfoList *head = NULL;
|
|
ACPIOSTInfoList **prev = &head;
|
|
Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);
|
|
|
|
if (obj) {
|
|
AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
|
|
AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);
|
|
|
|
adevc->ospm_status(adev, &prev);
|
|
} else {
|
|
error_setg(errp, "command is not supported, missing ACPI device");
|
|
}
|
|
|
|
return head;
|
|
}
|
|
|
|
MemoryInfo *qmp_query_memory_size_summary(Error **errp)
|
|
{
|
|
MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo));
|
|
MachineState *ms = MACHINE(qdev_get_machine());
|
|
|
|
mem_info->base_memory = ms->ram_size;
|
|
|
|
mem_info->plugged_memory = get_plugged_memory_size();
|
|
mem_info->has_plugged_memory =
|
|
mem_info->plugged_memory != (uint64_t)-1;
|
|
|
|
return mem_info;
|
|
}
|
|
|
|
void qmp_display_reload(DisplayReloadOptions *arg, Error **errp)
|
|
{
|
|
switch (arg->type) {
|
|
case DISPLAY_RELOAD_TYPE_VNC:
|
|
#ifdef CONFIG_VNC
|
|
if (arg->u.vnc.has_tls_certs && arg->u.vnc.tls_certs) {
|
|
vnc_display_reload_certs(NULL, errp);
|
|
}
|
|
#else
|
|
error_setg(errp, "vnc is invalid, missing 'CONFIG_VNC'");
|
|
#endif
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_PROFILER
|
|
|
|
int64_t dev_time;
|
|
|
|
HumanReadableText *qmp_x_query_profile(Error **errp)
|
|
{
|
|
g_autoptr(GString) buf = g_string_new("");
|
|
static int64_t last_cpu_exec_time;
|
|
int64_t cpu_exec_time;
|
|
int64_t delta;
|
|
|
|
cpu_exec_time = tcg_cpu_exec_time();
|
|
delta = cpu_exec_time - last_cpu_exec_time;
|
|
|
|
g_string_append_printf(buf, "async time %" PRId64 " (%0.3f)\n",
|
|
dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
|
|
g_string_append_printf(buf, "qemu time %" PRId64 " (%0.3f)\n",
|
|
delta, delta / (double)NANOSECONDS_PER_SECOND);
|
|
last_cpu_exec_time = cpu_exec_time;
|
|
dev_time = 0;
|
|
|
|
return human_readable_text_from_str(buf);
|
|
}
|
|
#else
|
|
HumanReadableText *qmp_x_query_profile(Error **errp)
|
|
{
|
|
error_setg(errp, "Internal profiler not compiled");
|
|
return NULL;
|
|
}
|
|
#endif
|