*/
#include "qemu/osdep.h"
-#include "hmp.h"
+#include "monitor/hmp.h"
#include "net/net.h"
#include "net/eth.h"
#include "chardev/char.h"
#include "sysemu/block-backend.h"
-#include "sysemu/sysemu.h"
+#include "sysemu/runstate.h"
#include "qemu/config-file.h"
#include "qemu/option.h"
#include "qemu/timer.h"
#include "qemu/sockets.h"
#include "monitor/monitor-internal.h"
-#include "monitor/qdev.h"
#include "qapi/error.h"
+#include "qapi/clone-visitor.h"
#include "qapi/opts-visitor.h"
#include "qapi/qapi-builtin-visit.h"
#include "qapi/qapi-commands-block.h"
#include "qapi/qapi-commands-char.h"
+#include "qapi/qapi-commands-control.h"
#include "qapi/qapi-commands-migration.h"
#include "qapi/qapi-commands-misc.h"
#include "qapi/qapi-commands-net.h"
#include "qapi/qapi-commands-run-state.h"
#include "qapi/qapi-commands-tpm.h"
#include "qapi/qapi-commands-ui.h"
+#include "qapi/qapi-visit-net.h"
+#include "qapi/qapi-visit-migration.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qerror.h"
#include "qapi/string-input-visitor.h"
#include <spice/enums.h>
#endif
-static void hmp_handle_error(Monitor *mon, Error **errp)
+void hmp_handle_error(Monitor *mon, Error *err)
{
- assert(errp);
- if (*errp) {
- error_reportf_err(*errp, "Error: ");
+ if (err) {
+ error_reportf_err(err, "Error: ");
+ }
+}
+
+/*
+ * Produce a strList from a comma separated list.
+ * A NULL or empty input string return NULL.
+ */
+static strList *strList_from_comma_list(const char *in)
+{
+ strList *res = NULL;
+ strList **hook = &res;
+
+ while (in && in[0]) {
+ char *comma = strchr(in, ',');
+ *hook = g_new0(strList, 1);
+
+ if (comma) {
+ (*hook)->value = g_strndup(in, comma - in);
+ in = comma + 1; /* skip the , */
+ } else {
+ (*hook)->value = g_strdup(in);
+ in = NULL;
+ }
+ hook = &(*hook)->next;
}
+
+ return res;
}
void hmp_info_name(Monitor *mon, const QDict *qdict)
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_str(cap->value->capability),
- cap->value->state ? "on" : "off");
- }
- monitor_printf(mon, "\n");
- }
-
if (info->has_status) {
monitor_printf(mon, "Migration status: %s",
MigrationStatus_str(info->status));
monitor_printf(mon, "]\n");
}
qapi_free_MigrationInfo(info);
- qapi_free_MigrationCapabilityStatusList(caps);
}
void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "%s: %u\n",
MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_CHANNELS),
params->multifd_channels);
+ monitor_printf(mon, "%s: %s\n",
+ MigrationParameter_str(MIGRATION_PARAMETER_MULTIFD_COMPRESSION),
+ MultiFDCompression_str(params->multifd_compression));
monitor_printf(mon, "%s: %" PRIu64 "\n",
MigrationParameter_str(MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE),
params->xbzrle_cache_size);
qmp_query_migrate_cache_size(NULL) >> 10);
}
-void hmp_info_cpus(Monitor *mon, const QDict *qdict)
-{
- CpuInfoFastList *cpu_list, *cpu;
-
- cpu_list = qmp_query_cpus_fast(NULL);
-
- for (cpu = cpu_list; cpu; cpu = cpu->next) {
- int active = ' ';
-
- if (cpu->value->cpu_index == monitor_get_cpu_index()) {
- active = '*';
- }
-
- monitor_printf(mon, "%c CPU #%" PRId64 ":", active,
- cpu->value->cpu_index);
- monitor_printf(mon, " thread_id=%" PRId64 "\n", cpu->value->thread_id);
- }
-
- qapi_free_CpuInfoFastList(cpu_list);
-}
-
static void print_block_info(Monitor *mon, BlockInfo *info,
BlockDeviceInfo *inserted, bool verbose)
{
}
/* Print node information */
- blockdev_list = qmp_query_named_block_nodes(NULL);
+ blockdev_list = qmp_query_named_block_nodes(false, false, NULL);
for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
assert(blockdev->value->has_node_name);
if (device && strcmp(device, blockdev->value->node_name)) {
info2l = qmp_query_vnc_servers(&err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
if (!info2l) {
info = qmp_query_balloon(&err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
Error *err = NULL;
error_setg(&err, QERR_INVALID_PARAMETER, op);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
}
Error *err = NULL;
qmp_x_exit_preconfig(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_cpu(Monitor *mon, const QDict *qdict)
}
qmp_memsave(addr, size, filename, true, cpu_index, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_pmemsave(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_pmemsave(addr, size, filename, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
qmp_ringbuf_write(chardev, data, false, 0, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
data = qmp_ringbuf_read(chardev, size, false, 0, &err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
Error *err = NULL;
qmp_cont(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_system_wakeup(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_system_wakeup(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_nmi(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_inject_nmi(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_set_link(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_set_link(name, up, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_block_passwd(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_block_passwd(true, device, false, NULL, password, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_balloon(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_balloon(value, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_block_resize(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_block_resize(true, device, false, NULL, size, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
if (!filename) {
error_setg(&err, QERR_MISSING_PARAMETER, "target");
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
qmp_drive_mirror(&mirror, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_drive_backup(Monitor *mon, const QDict *qdict)
if (!filename) {
error_setg(&err, QERR_MISSING_PARAMETER, "target");
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
qmp_drive_backup(&backup, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_snapshot_blkdev(Monitor *mon, const QDict *qdict)
/* In the future, if 'snapshot-file' is not specified, the snapshot
will be taken internally. Today it's actually required. */
error_setg(&err, QERR_MISSING_PARAMETER, "snapshot-file");
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
filename, false, NULL,
!!format, format,
true, mode, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_snapshot_blkdev_internal(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_blockdev_snapshot_internal_sync(device, name, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_snapshot_delete_blkdev_internal(Monitor *mon, const QDict *qdict)
qmp_blockdev_snapshot_delete_internal_sync(device, !!id, id,
true, name, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_loadvm(Monitor *mon, const QDict *qdict)
if (load_snapshot(name, &err) == 0 && saved_vm_running) {
vm_start();
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_savevm(Monitor *mon, const QDict *qdict)
Error *err = NULL;
save_snapshot(qdict_get_try_str(qdict, "name"), &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_delvm(Monitor *mon, const QDict *qdict)
"deleting snapshot on device '%s': ",
bdrv_get_device_name(bs));
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_info_snapshots(Monitor *mon, const QDict *qdict)
void hmp_announce_self(Monitor *mon, const QDict *qdict)
{
- qmp_announce_self(migrate_announce_params(), NULL);
+ const char *interfaces_str = qdict_get_try_str(qdict, "interfaces");
+ const char *id = qdict_get_try_str(qdict, "id");
+ AnnounceParameters *params = QAPI_CLONE(AnnounceParameters,
+ migrate_announce_params());
+
+ qapi_free_strList(params->interfaces);
+ params->interfaces = strList_from_comma_list(interfaces_str);
+ params->has_interfaces = params->interfaces != NULL;
+ params->id = g_strdup(id);
+ params->has_id = !!params->id;
+ qmp_announce_self(params, NULL);
+ qapi_free_AnnounceParameters(params);
}
void hmp_migrate_cancel(Monitor *mon, const QDict *qdict)
qmp_migrate_continue(val, &err);
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_migrate_incoming(Monitor *mon, const QDict *qdict)
qmp_migrate_incoming(uri, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_migrate_recover(Monitor *mon, const QDict *qdict)
qmp_migrate_recover(uri, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
qmp_migrate_pause(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
/* Kept for backwards compatibility */
Error *err = NULL;
qmp_migrate_set_cache_size(value, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
/* Kept for backwards compatibility */
end:
qapi_free_MigrationCapabilityStatusList(caps);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict)
MigrateSetParameters *p = g_new0(MigrateSetParameters, 1);
uint64_t valuebw = 0;
uint64_t cache_size;
+ MultiFDCompression compress_type;
Error *err = NULL;
int val, ret;
p->has_multifd_channels = true;
visit_type_int(v, param, &p->multifd_channels, &err);
break;
+ case MIGRATION_PARAMETER_MULTIFD_COMPRESSION:
+ p->has_multifd_compression = true;
+ visit_type_MultiFDCompression(v, param, &compress_type, &err);
+ if (err) {
+ break;
+ }
+ p->multifd_compression = compress_type;
+ break;
+ case MIGRATION_PARAMETER_MULTIFD_ZLIB_LEVEL:
+ p->has_multifd_zlib_level = true;
+ visit_type_int(v, param, &p->multifd_zlib_level, &err);
+ break;
case MIGRATION_PARAMETER_XBZRLE_CACHE_SIZE:
p->has_xbzrle_cache_size = true;
visit_type_size(v, param, &cache_size, &err);
cleanup:
qapi_free_MigrateSetParameters(p);
visit_free(v);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_client_migrate_info(Monitor *mon, const QDict *qdict)
qmp_client_migrate_info(protocol, hostname,
has_port, port, has_tls_port, tls_port,
!!cert_subject, cert_subject, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
qmp_migrate_start_postcopy(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_x_colo_lost_heartbeat(&err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_set_password(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_set_password(protocol, password, !!connected, connected, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_expire_password(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_expire_password(protocol, whenstr, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_eject(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_eject(true, device, false, NULL, true, force, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
#ifdef CONFIG_VNC
void hmp_change(Monitor *mon, const QDict *qdict)
{
- MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
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");
if (strcmp(target, "passwd") == 0 ||
strcmp(target, "password") == 0) {
if (!arg) {
+ MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
monitor_read_password(hmp_mon, hmp_change_read_arg, NULL);
return;
}
read_only,
BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN, &err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
}
&err);
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
}
qmp_block_set_io_throttle(&throttle, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_block_stream(Monitor *mon, const QDict *qdict)
BLOCKDEV_ON_ERROR_REPORT, false, false, false, false,
&error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
void hmp_block_job_set_speed(Monitor *mon, const QDict *qdict)
qmp_block_job_set_speed(device, value, &error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
void hmp_block_job_cancel(Monitor *mon, const QDict *qdict)
qmp_block_job_cancel(device, true, force, &error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
void hmp_block_job_pause(Monitor *mon, const QDict *qdict)
qmp_block_job_pause(device, &error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
void hmp_block_job_resume(Monitor *mon, const QDict *qdict)
qmp_block_job_resume(device, &error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
void hmp_block_job_complete(Monitor *mon, const QDict *qdict)
qmp_block_job_complete(device, &error);
- hmp_handle_error(mon, &error);
+ hmp_handle_error(mon, error);
}
typedef struct HMPMigrationStatus
qmp_migrate(uri, !!blk, blk, !!inc, inc,
false, false, true, resume, &err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
}
}
-void hmp_device_add(Monitor *mon, const QDict *qdict)
-{
- Error *err = NULL;
-
- qmp_device_add((QDict *)qdict, NULL, &err);
- hmp_handle_error(mon, &err);
-}
-
-void hmp_device_del(Monitor *mon, const QDict *qdict)
-{
- const char *id = qdict_get_str(qdict, "id");
- Error *err = NULL;
-
- qmp_device_del(id, &err);
- hmp_handle_error(mon, &err);
-}
-
-void hmp_dump_guest_memory(Monitor *mon, const QDict *qdict)
-{
- Error *err = NULL;
- bool win_dmp = qdict_get_try_bool(qdict, "windmp", false);
- bool paging = qdict_get_try_bool(qdict, "paging", false);
- bool zlib = qdict_get_try_bool(qdict, "zlib", false);
- bool lzo = qdict_get_try_bool(qdict, "lzo", false);
- bool snappy = qdict_get_try_bool(qdict, "snappy", false);
- const char *file = qdict_get_str(qdict, "filename");
- bool has_begin = qdict_haskey(qdict, "begin");
- bool has_length = qdict_haskey(qdict, "length");
- bool has_detach = qdict_haskey(qdict, "detach");
- int64_t begin = 0;
- int64_t length = 0;
- bool detach = false;
- enum DumpGuestMemoryFormat dump_format = DUMP_GUEST_MEMORY_FORMAT_ELF;
- char *prot;
-
- if (zlib + lzo + snappy + win_dmp > 1) {
- error_setg(&err, "only one of '-z|-l|-s|-w' can be set");
- hmp_handle_error(mon, &err);
- return;
- }
-
- if (win_dmp) {
- dump_format = DUMP_GUEST_MEMORY_FORMAT_WIN_DMP;
- }
-
- if (zlib) {
- dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_ZLIB;
- }
-
- if (lzo) {
- dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_LZO;
- }
-
- if (snappy) {
- dump_format = DUMP_GUEST_MEMORY_FORMAT_KDUMP_SNAPPY;
- }
-
- if (has_begin) {
- begin = qdict_get_int(qdict, "begin");
- }
- if (has_length) {
- length = qdict_get_int(qdict, "length");
- }
- if (has_detach) {
- detach = qdict_get_bool(qdict, "detach");
- }
-
- prot = g_strconcat("file:", file, NULL);
-
- qmp_dump_guest_memory(paging, prot, true, detach, has_begin, begin,
- has_length, length, true, dump_format, &err);
- hmp_handle_error(mon, &err);
- g_free(prot);
-}
-
void hmp_netdev_add(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
}
out:
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_netdev_del(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_netdev_del(id, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_object_add(Monitor *mon, const QDict *qdict)
opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
qemu_opts_del(opts);
if (err) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
if (obj) {
object_unref(obj);
Error *err = NULL;
qmp_getfd(fdname, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_closefd(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_closefd(fdname, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_sendkey(Monitor *mon, const QDict *qdict)
}
qmp_send_key(head, has_hold_time, hold_time, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
out:
qapi_free_KeyValueList(head);
Error *err = NULL;
qmp_screendump(filename, id != NULL, id, id != NULL, head, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_nbd_server_start(Monitor *mon, const QDict *qdict)
continue;
}
- qmp_nbd_server_add(info->value->device, false, NULL,
+ qmp_nbd_server_add(info->value->device, false, NULL, false, NULL,
true, writable, false, NULL, &local_err);
if (local_err != NULL) {
qapi_free_BlockInfoList(block_list);
exit:
- hmp_handle_error(mon, &local_err);
+ hmp_handle_error(mon, local_err);
}
void hmp_nbd_server_add(Monitor *mon, const QDict *qdict)
bool writable = qdict_get_try_bool(qdict, "writable", false);
Error *local_err = NULL;
- qmp_nbd_server_add(device, !!name, name, true, writable,
+ qmp_nbd_server_add(device, !!name, name, false, NULL, true, writable,
false, NULL, &local_err);
- hmp_handle_error(mon, &local_err);
+ hmp_handle_error(mon, local_err);
}
void hmp_nbd_server_remove(Monitor *mon, const QDict *qdict)
/* Rely on NBD_SERVER_REMOVE_MODE_SAFE being the default */
qmp_nbd_server_remove(name, force, NBD_SERVER_REMOVE_MODE_HARD, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_nbd_server_stop(Monitor *mon, const QDict *qdict)
Error *err = NULL;
qmp_nbd_server_stop(&err);
- hmp_handle_error(mon, &err);
-}
-
-void hmp_cpu_add(Monitor *mon, const QDict *qdict)
-{
- int cpuid;
- Error *err = NULL;
-
- error_report("cpu_add is deprecated, please use device_add instead");
-
- cpuid = qdict_get_int(qdict, "id");
- qmp_cpu_add(cpuid, &err);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_chardev_add(Monitor *mon, const QDict *qdict)
qemu_chr_new_from_opts(opts, NULL, &err);
qemu_opts_del(opts);
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_chardev_change(Monitor *mon, const QDict *qdict)
qapi_free_ChardevReturn(ret);
qapi_free_ChardevBackend(backend);
qemu_opts_del(opts);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
Error *local_err = NULL;
qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
- hmp_handle_error(mon, &local_err);
+ hmp_handle_error(mon, local_err);
}
void hmp_chardev_send_break(Monitor *mon, const QDict *qdict)
Error *local_err = NULL;
qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err);
- hmp_handle_error(mon, &local_err);
+ hmp_handle_error(mon, local_err);
}
void hmp_qemu_io(Monitor *mon, const QDict *qdict)
{
BlockBackend *blk;
BlockBackend *local_blk = NULL;
+ bool qdev = qdict_get_try_bool(qdict, "qdev", false);
const char* device = qdict_get_str(qdict, "device");
const char* command = qdict_get_str(qdict, "command");
Error *err = NULL;
int ret;
- blk = blk_by_name(device);
- if (!blk) {
- BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
- if (bs) {
- blk = local_blk = blk_new(bdrv_get_aio_context(bs),
- 0, BLK_PERM_ALL);
- ret = blk_insert_bs(blk, bs, &err);
- if (ret < 0) {
+ if (qdev) {
+ blk = blk_by_qdev_id(device, &err);
+ if (!blk) {
+ goto fail;
+ }
+ } else {
+ blk = blk_by_name(device);
+ if (!blk) {
+ BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
+ if (bs) {
+ blk = local_blk = blk_new(bdrv_get_aio_context(bs),
+ 0, BLK_PERM_ALL);
+ ret = blk_insert_bs(blk, bs, &err);
+ if (ret < 0) {
+ goto fail;
+ }
+ } else {
goto fail;
}
- } else {
- goto fail;
}
}
fail:
blk_unref(local_blk);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_object_del(Monitor *mon, const QDict *qdict)
Error *err = NULL;
user_creatable_del(id, &err);
- hmp_handle_error(mon, &err);
-}
-
-void hmp_info_memdev(Monitor *mon, const QDict *qdict)
-{
- Error *err = NULL;
- MemdevList *memdev_list = qmp_query_memdev(&err);
- MemdevList *m = memdev_list;
- Visitor *v;
- char *str;
-
- while (m) {
- v = string_output_visitor_new(false, &str);
- visit_type_uint16List(v, NULL, &m->value->host_nodes, NULL);
- monitor_printf(mon, "memory backend: %s\n", m->value->id);
- monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
- monitor_printf(mon, " merge: %s\n",
- m->value->merge ? "true" : "false");
- monitor_printf(mon, " dump: %s\n",
- m->value->dump ? "true" : "false");
- monitor_printf(mon, " prealloc: %s\n",
- m->value->prealloc ? "true" : "false");
- monitor_printf(mon, " policy: %s\n",
- HostMemPolicy_str(m->value->policy));
- visit_complete(v, &str);
- monitor_printf(mon, " host nodes: %s\n", str);
-
- g_free(str);
- visit_free(v);
- m = m->next;
- }
-
- monitor_printf(mon, "\n");
-
- qapi_free_MemdevList(memdev_list);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
Error *err = NULL;
MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
MemoryDeviceInfoList *info;
+ VirtioPMEMDeviceInfo *vpi;
MemoryDeviceInfo *value;
PCDIMMDeviceInfo *di;
if (value) {
switch (value->type) {
case MEMORY_DEVICE_INFO_KIND_DIMM:
- di = value->u.dimm.data;
- break;
-
case MEMORY_DEVICE_INFO_KIND_NVDIMM:
- di = value->u.nvdimm.data;
- break;
-
- default:
- di = NULL;
- break;
- }
-
- if (di) {
+ di = value->type == MEMORY_DEVICE_INFO_KIND_DIMM ?
+ value->u.dimm.data : value->u.nvdimm.data;
monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
MemoryDeviceInfoKind_str(value->type),
di->id ? di->id : "");
di->hotplugged ? "true" : "false");
monitor_printf(mon, " hotpluggable: %s\n",
di->hotpluggable ? "true" : "false");
+ break;
+ case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM:
+ vpi = value->u.virtio_pmem.data;
+ monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
+ MemoryDeviceInfoKind_str(value->type),
+ vpi->id ? vpi->id : "");
+ monitor_printf(mon, " memaddr: 0x%" PRIx64 "\n", vpi->memaddr);
+ monitor_printf(mon, " size: %" PRIu64 "\n", vpi->size);
+ monitor_printf(mon, " memdev: %s\n", vpi->memdev);
+ break;
+ default:
+ g_assert_not_reached();
}
}
}
qapi_free_MemoryDeviceInfoList(info_list);
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
void hmp_info_iothreads(Monitor *mon, const QDict *qdict)
qapi_free_IOThreadInfoList(info_list);
}
-void hmp_qom_list(Monitor *mon, const QDict *qdict)
-{
- const char *path = qdict_get_try_str(qdict, "path");
- ObjectPropertyInfoList *list;
- Error *err = NULL;
-
- if (path == NULL) {
- monitor_printf(mon, "/\n");
- return;
- }
-
- list = qmp_qom_list(path, &err);
- if (err == NULL) {
- ObjectPropertyInfoList *start = list;
- while (list != NULL) {
- ObjectPropertyInfo *value = list->value;
-
- monitor_printf(mon, "%s (%s)\n",
- value->name, value->type);
- list = list->next;
- }
- qapi_free_ObjectPropertyInfoList(start);
- }
- hmp_handle_error(mon, &err);
-}
-
-void hmp_qom_set(Monitor *mon, const QDict *qdict)
-{
- const char *path = qdict_get_str(qdict, "path");
- const char *property = qdict_get_str(qdict, "property");
- const char *value = qdict_get_str(qdict, "value");
- Error *err = NULL;
- bool ambiguous = false;
- Object *obj;
-
- obj = object_resolve_path(path, &ambiguous);
- if (obj == NULL) {
- error_set(&err, ERROR_CLASS_DEVICE_NOT_FOUND,
- "Device '%s' not found", path);
- } else {
- if (ambiguous) {
- monitor_printf(mon, "Warning: Path '%s' is ambiguous\n", path);
- }
- object_property_parse(obj, value, property, &err);
- }
- hmp_handle_error(mon, &err);
-}
-
void hmp_rocker(Monitor *mon, const QDict *qdict)
{
const char *name = qdict_get_str(qdict, "name");
rocker = qmp_query_rocker(name, &err);
if (err != NULL) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
list = qmp_query_rocker_ports(name, &err);
if (err != NULL) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
list = qmp_query_rocker_of_dpa_flows(name, tbl_id != -1, tbl_id, &err);
if (err != NULL) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
list = qmp_query_rocker_of_dpa_groups(name, type != 9, type, &err);
if (err != NULL) {
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
return;
}
qapi_free_RockerOfDpaGroupList(list);
}
-void hmp_info_dump(Monitor *mon, const QDict *qdict)
-{
- DumpQueryResult *result = qmp_query_dump(NULL);
-
- assert(result && result->status < DUMP_STATUS__MAX);
- monitor_printf(mon, "Status: %s\n", DumpStatus_str(result->status));
-
- if (result->status == DUMP_STATUS_ACTIVE) {
- float percent = 0;
- assert(result->total != 0);
- percent = 100.0 * result->completed / result->total;
- monitor_printf(mon, "Finished: %.2f %%\n", percent);
- }
-
- qapi_free_DumpQueryResult(result);
-}
-
void hmp_info_ramblock(Monitor *mon, const QDict *qdict)
{
ram_block_dump(mon);
}
-void hmp_hotpluggable_cpus(Monitor *mon, const QDict *qdict)
-{
- Error *err = NULL;
- HotpluggableCPUList *l = qmp_query_hotpluggable_cpus(&err);
- HotpluggableCPUList *saved = l;
- CpuInstanceProperties *c;
-
- if (err != NULL) {
- hmp_handle_error(mon, &err);
- return;
- }
-
- monitor_printf(mon, "Hotpluggable CPUs:\n");
- while (l) {
- monitor_printf(mon, " type: \"%s\"\n", l->value->type);
- monitor_printf(mon, " vcpus_count: \"%" PRIu64 "\"\n",
- l->value->vcpus_count);
- if (l->value->has_qom_path) {
- monitor_printf(mon, " qom_path: \"%s\"\n", l->value->qom_path);
- }
-
- c = l->value->props;
- monitor_printf(mon, " CPUInstance Properties:\n");
- if (c->has_node_id) {
- monitor_printf(mon, " node-id: \"%" PRIu64 "\"\n", c->node_id);
- }
- if (c->has_socket_id) {
- monitor_printf(mon, " socket-id: \"%" PRIu64 "\"\n", c->socket_id);
- }
- if (c->has_core_id) {
- monitor_printf(mon, " core-id: \"%" PRIu64 "\"\n", c->core_id);
- }
- if (c->has_thread_id) {
- monitor_printf(mon, " thread-id: \"%" PRIu64 "\"\n", c->thread_id);
- }
-
- l = l->next;
- }
-
- qapi_free_HotpluggableCPUList(saved);
-}
-
void hmp_info_vm_generation_id(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
if (info) {
monitor_printf(mon, "%s\n", info->guid);
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
qapi_free_GuidInfo(info);
}
qapi_free_MemoryInfo(info);
}
- hmp_handle_error(mon, &err);
+ hmp_handle_error(mon, err);
}
projects / qemu.git / blobdiff