#include "qemu-io.h"
#include "qemu/cutils.h"
#include "qemu/error-report.h"
+#include "hw/intc/intc.h"
#ifdef CONFIG_SPICE
#include <spice/enums.h>
if (params) {
monitor_printf(mon, "parameters:");
+ assert(params->has_compress_level);
monitor_printf(mon, " %s: %" PRId64,
MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_LEVEL],
params->compress_level);
+ assert(params->has_compress_threads);
monitor_printf(mon, " %s: %" PRId64,
MigrationParameter_lookup[MIGRATION_PARAMETER_COMPRESS_THREADS],
params->compress_threads);
+ assert(params->has_decompress_threads);
monitor_printf(mon, " %s: %" PRId64,
MigrationParameter_lookup[MIGRATION_PARAMETER_DECOMPRESS_THREADS],
params->decompress_threads);
+ assert(params->has_cpu_throttle_initial);
monitor_printf(mon, " %s: %" PRId64,
MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL],
params->cpu_throttle_initial);
+ assert(params->has_cpu_throttle_increment);
monitor_printf(mon, " %s: %" PRId64,
MigrationParameter_lookup[MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT],
params->cpu_throttle_increment);
monitor_printf(mon, " %s: '%s'",
MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_CREDS],
- params->tls_creds ? : "");
+ params->has_tls_creds ? params->tls_creds : "");
monitor_printf(mon, " %s: '%s'",
MigrationParameter_lookup[MIGRATION_PARAMETER_TLS_HOSTNAME],
- params->tls_hostname ? : "");
+ params->has_tls_hostname ? params->tls_hostname : "");
+ assert(params->has_max_bandwidth);
+ monitor_printf(mon, " %s: %" PRId64 " bytes/second",
+ MigrationParameter_lookup[MIGRATION_PARAMETER_MAX_BANDWIDTH],
+ params->max_bandwidth);
+ assert(params->has_downtime_limit);
+ monitor_printf(mon, " %s: %" PRId64 " milliseconds",
+ MigrationParameter_lookup[MIGRATION_PARAMETER_DOWNTIME_LIMIT],
+ params->downtime_limit);
+ monitor_printf(mon, " %s: %" PRId64,
+ MigrationParameter_lookup[MIGRATION_PARAMETER_X_CHECKPOINT_DELAY],
+ params->x_checkpoint_delay);
monitor_printf(mon, "\n");
}
}
}
+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;
void hmp_drive_mirror(Monitor *mon, const QDict *qdict)
{
- const char *device = qdict_get_str(qdict, "device");
const char *filename = qdict_get_str(qdict, "target");
const char *format = qdict_get_try_str(qdict, "format");
bool reuse = qdict_get_try_bool(qdict, "reuse", false);
bool full = qdict_get_try_bool(qdict, "full", false);
- enum NewImageMode mode;
Error *err = NULL;
+ DriveMirror mirror = {
+ .device = (char *)qdict_get_str(qdict, "device"),
+ .target = (char *)filename,
+ .has_format = !!format,
+ .format = (char *)format,
+ .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
+ .has_mode = true,
+ .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
+ .unmap = true,
+ };
if (!filename) {
error_setg(&err, QERR_MISSING_PARAMETER, "target");
hmp_handle_error(mon, &err);
return;
}
-
- if (reuse) {
- mode = NEW_IMAGE_MODE_EXISTING;
- } else {
- mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
- }
-
- qmp_drive_mirror(device, filename, !!format, format,
- false, NULL, false, NULL,
- full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
- true, mode, false, 0, false, 0, false, 0,
- false, 0, false, 0, false, true, &err);
+ qmp_drive_mirror(&mirror, &err);
hmp_handle_error(mon, &err);
}
const char *format = qdict_get_try_str(qdict, "format");
bool reuse = qdict_get_try_bool(qdict, "reuse", false);
bool full = qdict_get_try_bool(qdict, "full", false);
- enum NewImageMode mode;
+ bool compress = qdict_get_try_bool(qdict, "compress", false);
Error *err = NULL;
+ DriveBackup backup = {
+ .device = (char *)device,
+ .target = (char *)filename,
+ .has_format = !!format,
+ .format = (char *)format,
+ .sync = full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
+ .has_mode = true,
+ .mode = reuse ? NEW_IMAGE_MODE_EXISTING : NEW_IMAGE_MODE_ABSOLUTE_PATHS,
+ .has_compress = !!compress,
+ .compress = compress,
+ };
if (!filename) {
error_setg(&err, QERR_MISSING_PARAMETER, "target");
return;
}
- if (reuse) {
- mode = NEW_IMAGE_MODE_EXISTING;
- } else {
- mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
- }
-
- qmp_drive_backup(device, filename, !!format, format,
- full ? MIRROR_SYNC_MODE_FULL : MIRROR_SYNC_MODE_TOP,
- true, mode, false, 0, false, NULL,
- false, 0, false, 0, &err);
+ qmp_drive_backup(&backup, &err);
hmp_handle_error(mon, &err);
}
hmp_handle_error(mon, &err);
}
+/* Kept for backwards compatibility */
void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
{
double value = qdict_get_double(qdict, "value");
}
}
+/* Kept for backwards compatibility */
void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
{
int64_t value = qdict_get_int(qdict, "value");
{
const char *param = qdict_get_str(qdict, "parameter");
const char *valuestr = qdict_get_str(qdict, "value");
+ int64_t valuebw = 0;
long valueint = 0;
+ char *endp;
Error *err = NULL;
- bool has_compress_level = false;
- bool has_compress_threads = false;
- bool has_decompress_threads = false;
- bool has_cpu_throttle_initial = false;
- bool has_cpu_throttle_increment = false;
- bool has_tls_creds = false;
- bool has_tls_hostname = false;
bool use_int_value = false;
int i;
for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
if (strcmp(param, MigrationParameter_lookup[i]) == 0) {
+ MigrationParameters p = { 0 };
switch (i) {
case MIGRATION_PARAMETER_COMPRESS_LEVEL:
- has_compress_level = true;
+ p.has_compress_level = true;
use_int_value = true;
break;
case MIGRATION_PARAMETER_COMPRESS_THREADS:
- has_compress_threads = true;
+ p.has_compress_threads = true;
use_int_value = true;
break;
case MIGRATION_PARAMETER_DECOMPRESS_THREADS:
- has_decompress_threads = true;
+ p.has_decompress_threads = true;
use_int_value = true;
break;
case MIGRATION_PARAMETER_CPU_THROTTLE_INITIAL:
- has_cpu_throttle_initial = true;
+ p.has_cpu_throttle_initial = true;
use_int_value = true;
break;
case MIGRATION_PARAMETER_CPU_THROTTLE_INCREMENT:
- has_cpu_throttle_increment = true;
+ p.has_cpu_throttle_increment = true;
+ use_int_value = true;
break;
case MIGRATION_PARAMETER_TLS_CREDS:
- has_tls_creds = true;
+ p.has_tls_creds = true;
+ p.tls_creds = (char *) valuestr;
break;
case MIGRATION_PARAMETER_TLS_HOSTNAME:
- has_tls_hostname = true;
+ p.has_tls_hostname = true;
+ p.tls_hostname = (char *) valuestr;
+ break;
+ case MIGRATION_PARAMETER_MAX_BANDWIDTH:
+ p.has_max_bandwidth = true;
+ valuebw = qemu_strtosz(valuestr, &endp);
+ if (valuebw < 0 || (size_t)valuebw != valuebw
+ || *endp != '\0') {
+ error_setg(&err, "Invalid size %s", valuestr);
+ goto cleanup;
+ }
+ p.max_bandwidth = valuebw;
+ break;
+ case MIGRATION_PARAMETER_DOWNTIME_LIMIT:
+ p.has_downtime_limit = true;
+ use_int_value = true;
+ break;
+ case MIGRATION_PARAMETER_X_CHECKPOINT_DELAY:
+ p.has_x_checkpoint_delay = true;
+ use_int_value = true;
break;
}
valuestr);
goto cleanup;
}
+ /* Set all integers; only one has_FOO will be set, and
+ * the code ignores the remaining values */
+ p.compress_level = valueint;
+ p.compress_threads = valueint;
+ p.decompress_threads = valueint;
+ p.cpu_throttle_initial = valueint;
+ p.cpu_throttle_increment = valueint;
+ p.downtime_limit = valueint;
+ p.x_checkpoint_delay = valueint;
}
- qmp_migrate_set_parameters(has_compress_level, valueint,
- has_compress_threads, valueint,
- has_decompress_threads, valueint,
- has_cpu_throttle_initial, valueint,
- has_cpu_throttle_increment, valueint,
- has_tls_creds, valuestr,
- has_tls_hostname, valuestr,
- &err);
+ qmp_migrate_set_parameters(&p, &err);
break;
}
}
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);
+}
+
void hmp_set_password(Monitor *mon, const QDict *qdict)
{
const char *protocol = qdict_get_str(qdict, "protocol");
const char *device = qdict_get_str(qdict, "device");
Error *err = NULL;
- qmp_eject(device, true, force, &err);
+ qmp_eject(true, device, false, NULL, true, force, &err);
hmp_handle_error(mon, &err);
}
}
}
- qmp_blockdev_change_medium(device, target, !!arg, arg,
- !!read_only, read_only_mode, &err);
+ qmp_blockdev_change_medium(true, device, false, NULL, target,
+ !!arg, arg, !!read_only, read_only_mode,
+ &err);
if (err &&
error_get_class(err) == ERROR_CLASS_DEVICE_ENCRYPTED) {
error_free(err);
void hmp_block_set_io_throttle(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
+ BlockIOThrottle throttle = {
+ .device = (char *) qdict_get_str(qdict, "device"),
+ .bps = qdict_get_int(qdict, "bps"),
+ .bps_rd = qdict_get_int(qdict, "bps_rd"),
+ .bps_wr = qdict_get_int(qdict, "bps_wr"),
+ .iops = qdict_get_int(qdict, "iops"),
+ .iops_rd = qdict_get_int(qdict, "iops_rd"),
+ .iops_wr = qdict_get_int(qdict, "iops_wr"),
+ };
- qmp_block_set_io_throttle(qdict_get_str(qdict, "device"),
- qdict_get_int(qdict, "bps"),
- qdict_get_int(qdict, "bps_rd"),
- qdict_get_int(qdict, "bps_wr"),
- qdict_get_int(qdict, "iops"),
- qdict_get_int(qdict, "iops_rd"),
- qdict_get_int(qdict, "iops_wr"),
- false, /* no burst max via HMP */
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false, /* no burst length via HMP */
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false,
- 0,
- false, /* No default I/O size */
- 0,
- false,
- NULL, &err);
+ qmp_block_set_io_throttle(&throttle, &err);
hmp_handle_error(mon, &err);
}
const char *base = qdict_get_try_str(qdict, "base");
int64_t speed = qdict_get_try_int(qdict, "speed", 0);
- qmp_block_stream(device, base != NULL, base, false, NULL,
- qdict_haskey(qdict, "speed"), speed,
+ qmp_block_stream(false, NULL, device, base != NULL, base, false, NULL,
+ false, NULL, qdict_haskey(qdict, "speed"), speed,
true, BLOCKDEV_ON_ERROR_REPORT, &error);
hmp_handle_error(mon, &error);
{
Error *err = NULL;
QemuOpts *opts;
- OptsVisitor *ov;
+ Visitor *v;
Object *obj = NULL;
opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
return;
}
- ov = opts_visitor_new(opts);
- obj = user_creatable_add(qdict, opts_get_visitor(ov), &err);
- opts_visitor_cleanup(ov);
+ v = opts_visitor_new(opts);
+ obj = user_creatable_add(qdict, v, &err);
+ visit_free(v);
qemu_opts_del(opts);
if (err) {
if (opts == NULL) {
error_setg(&err, "Parsing chardev args failed");
} else {
- qemu_chr_new_from_opts(opts, NULL, &err);
+ qemu_chr_new_from_opts(opts, &err);
+ qemu_opts_del(opts);
}
hmp_handle_error(mon, &err);
}
void hmp_qemu_io(Monitor *mon, const QDict *qdict)
{
BlockBackend *blk;
+ BlockBackend *local_blk = NULL;
+ AioContext *aio_context;
const char* device = qdict_get_str(qdict, "device");
const char* command = qdict_get_str(qdict, "command");
Error *err = NULL;
blk = blk_by_name(device);
- if (blk) {
- AioContext *aio_context = blk_get_aio_context(blk);
- aio_context_acquire(aio_context);
+ if (!blk) {
+ BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
+ if (bs) {
+ blk = local_blk = blk_new();
+ blk_insert_bs(blk, bs);
+ } else {
+ goto fail;
+ }
+ }
- qemuio_command(blk, command);
+ aio_context = blk_get_aio_context(blk);
+ aio_context_acquire(aio_context);
- aio_context_release(aio_context);
- } else {
- error_set(&err, ERROR_CLASS_DEVICE_NOT_FOUND,
- "Device '%s' not found", device);
- }
+ qemuio_command(blk, command);
+
+ aio_context_release(aio_context);
+fail:
+ blk_unref(local_blk);
hmp_handle_error(mon, &err);
}
Error *err = NULL;
MemdevList *memdev_list = qmp_query_memdev(&err);
MemdevList *m = memdev_list;
- StringOutputVisitor *ov;
+ Visitor *v;
char *str;
int i = 0;
while (m) {
- ov = string_output_visitor_new(false);
- visit_type_uint16List(string_output_get_visitor(ov), NULL,
- &m->value->host_nodes, NULL);
+ v = string_output_visitor_new(false, &str);
+ visit_type_uint16List(v, NULL, &m->value->host_nodes, NULL);
monitor_printf(mon, "memory backend: %d\n", i);
monitor_printf(mon, " size: %" PRId64 "\n", m->value->size);
monitor_printf(mon, " merge: %s\n",
m->value->prealloc ? "true" : "false");
monitor_printf(mon, " policy: %s\n",
HostMemPolicy_lookup[m->value->policy]);
- str = string_output_get_string(ov);
+ visit_complete(v, &str);
monitor_printf(mon, " host nodes: %s\n", str);
g_free(str);
- string_output_visitor_cleanup(ov);
+ visit_free(v);
m = m->next;
i++;
}
qapi_free_DumpQueryResult(result);
}
+
+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);
+}
projects / qemu.git / blobdiff