hw/core/machine-qmp-cmds.c

   1 /*
   2  * QMP commands related to machines and CPUs
   3  *
   4  * Copyright (C) 2014 Red Hat Inc
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "hw/acpi/vmgenid.h"
  12 #include "hw/boards.h"
  13 #include "hw/intc/intc.h"
  14 #include "hw/mem/memory-device.h"
  15 #include "qapi/error.h"
  16 #include "qapi/qapi-builtin-visit.h"
  17 #include "qapi/qapi-commands-machine.h"
  18 #include "qapi/qmp/qobject.h"
  19 #include "qapi/qobject-input-visitor.h"
  20 #include "qapi/type-helpers.h"
  21 #include "qemu/uuid.h"
  22 #include "qom/qom-qobject.h"
  23 #include "sysemu/hostmem.h"
  24 #include "sysemu/hw_accel.h"
  25 #include "sysemu/numa.h"
  26 #include "sysemu/runstate.h"
  27 #include "sysemu/sysemu.h"
  28
  29 /*
  30  * fast means: we NEVER interrupt vCPU threads to retrieve
  31  * information from KVM.
  32  */
  33 CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
  34 {
  35     MachineState *ms = MACHINE(qdev_get_machine());
  36     MachineClass *mc = MACHINE_GET_CLASS(ms);
  37     CpuInfoFastList *head = NULL, **tail = &head;
  38     SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, target_name(),
  39                                           -1, &error_abort);
  40     CPUState *cpu;
  41
  42     CPU_FOREACH(cpu) {
  43         CpuInfoFast *value = g_malloc0(sizeof(*value));
  44
  45         value->cpu_index = cpu->cpu_index;
  46         value->qom_path = object_get_canonical_path(OBJECT(cpu));
  47         value->thread_id = cpu->thread_id;
  48
  49         if (mc->cpu_index_to_instance_props) {
  50             CpuInstanceProperties *props;
  51             props = g_malloc0(sizeof(*props));
  52             *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
  53             value->props = props;
  54         }
  55
  56         value->target = target;
  57         if (cpu->cc->query_cpu_fast) {
  58             cpu->cc->query_cpu_fast(cpu, value);
  59         }
  60
  61         QAPI_LIST_APPEND(tail, value);
  62     }
  63
  64     return head;
  65 }
  66
  67 MachineInfoList *qmp_query_machines(bool has_compat_props, bool compat_props,
  68                                     Error **errp)
  69 {
  70     GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
  71     MachineInfoList *mach_list = NULL;
  72
  73     for (el = machines; el; el = el->next) {
  74         MachineClass *mc = el->data;
  75         MachineInfo *info;
  76
  77         info = g_malloc0(sizeof(*info));
  78         if (mc->is_default) {
  79             info->has_is_default = true;
  80             info->is_default = true;
  81         }
  82
  83         if (mc->alias) {
  84             info->alias = g_strdup(mc->alias);
  85         }
  86
  87         info->name = g_strdup(mc->name);
  88         info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
  89         info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
  90         info->numa_mem_supported = mc->numa_mem_supported;
  91         info->deprecated = !!mc->deprecation_reason;
  92         info->acpi = !!object_class_property_find(OBJECT_CLASS(mc), "acpi");
  93         if (mc->default_cpu_type) {
  94             info->default_cpu_type = g_strdup(mc->default_cpu_type);
  95         }
  96         if (mc->default_ram_id) {
  97             info->default_ram_id = g_strdup(mc->default_ram_id);
  98         }
  99
 100         if (compat_props && mc->compat_props) {
 101             int i;
 102             info->compat_props = NULL;
 103             CompatPropertyList **tail = &(info->compat_props);
 104             info->has_compat_props = true;
 105
 106             for (i = 0; i < mc->compat_props->len; i++) {
 107                 GlobalProperty *mt_prop = g_ptr_array_index(mc->compat_props,
 108                                                             i);
 109                 CompatProperty *prop;
 110
 111                 prop = g_malloc0(sizeof(*prop));
 112                 prop->qom_type = g_strdup(mt_prop->driver);
 113                 prop->property = g_strdup(mt_prop->property);
 114                 prop->value = g_strdup(mt_prop->value);
 115
 116                 QAPI_LIST_APPEND(tail, prop);
 117             }
 118         }
 119
 120         QAPI_LIST_PREPEND(mach_list, info);
 121     }
 122
 123     g_slist_free(machines);
 124     return mach_list;
 125 }
 126
 127 CurrentMachineParams *qmp_query_current_machine(Error **errp)
 128 {
 129     CurrentMachineParams *params = g_malloc0(sizeof(*params));
 130     params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();
 131
 132     return params;
 133 }
 134
 135 TargetInfo *qmp_query_target(Error **errp)
 136 {
 137     TargetInfo *info = g_malloc0(sizeof(*info));
 138
 139     info->arch = qapi_enum_parse(&SysEmuTarget_lookup, target_name(), -1,
 140                                  &error_abort);
 141
 142     return info;
 143 }
 144
 145 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
 146 {
 147     MachineState *ms = MACHINE(qdev_get_machine());
 148     MachineClass *mc = MACHINE_GET_CLASS(ms);
 149
 150     if (!mc->has_hotpluggable_cpus) {
 151         error_setg(errp, "machine does not support hot-plugging CPUs");
 152         return NULL;
 153     }
 154
 155     return machine_query_hotpluggable_cpus(ms);
 156 }
 157
 158 void qmp_set_numa_node(NumaOptions *cmd, Error **errp)
 159 {
 160     if (phase_check(PHASE_MACHINE_INITIALIZED)) {
 161         error_setg(errp, "The command is permitted only before the machine has been created");
 162         return;
 163     }
 164
 165     set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
 166 }
 167
 168 static int query_memdev(Object *obj, void *opaque)
 169 {
 170     Error *err = NULL;
 171     MemdevList **list = opaque;
 172     Memdev *m;
 173     QObject *host_nodes;
 174     Visitor *v;
 175
 176     if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
 177         m = g_malloc0(sizeof(*m));
 178
 179         m->id = g_strdup(object_get_canonical_path_component(obj));
 180
 181         m->size = object_property_get_uint(obj, "size", &error_abort);
 182         m->merge = object_property_get_bool(obj, "merge", &error_abort);
 183         m->dump = object_property_get_bool(obj, "dump", &error_abort);
 184         m->prealloc = object_property_get_bool(obj, "prealloc", &error_abort);
 185         m->share = object_property_get_bool(obj, "share", &error_abort);
 186         m->reserve = object_property_get_bool(obj, "reserve", &err);
 187         if (err) {
 188             error_free_or_abort(&err);
 189         } else {
 190             m->has_reserve = true;
 191         }
 192         m->policy = object_property_get_enum(obj, "policy", "HostMemPolicy",
 193                                              &error_abort);
 194         host_nodes = object_property_get_qobject(obj,
 195                                                  "host-nodes",
 196                                                  &error_abort);
 197         v = qobject_input_visitor_new(host_nodes);
 198         visit_type_uint16List(v, NULL, &m->host_nodes, &error_abort);
 199         visit_free(v);
 200         qobject_unref(host_nodes);
 201
 202         QAPI_LIST_PREPEND(*list, m);
 203     }
 204
 205     return 0;
 206 }
 207
 208 MemdevList *qmp_query_memdev(Error **errp)
 209 {
 210     Object *obj = object_get_objects_root();
 211     MemdevList *list = NULL;
 212
 213     object_child_foreach(obj, query_memdev, &list);
 214     return list;
 215 }
 216
 217 HumanReadableText *qmp_x_query_numa(Error **errp)
 218 {
 219     g_autoptr(GString) buf = g_string_new("");
 220     int i, nb_numa_nodes;
 221     NumaNodeMem *node_mem;
 222     CpuInfoFastList *cpu_list, *cpu;
 223     MachineState *ms = MACHINE(qdev_get_machine());
 224
 225     nb_numa_nodes = ms->numa_state ? ms->numa_state->num_nodes : 0;
 226     g_string_append_printf(buf, "%d nodes\n", nb_numa_nodes);
 227     if (!nb_numa_nodes) {
 228         goto done;
 229     }
 230
 231     cpu_list = qmp_query_cpus_fast(&error_abort);
 232     node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
 233
 234     query_numa_node_mem(node_mem, ms);
 235     for (i = 0; i < nb_numa_nodes; i++) {
 236         g_string_append_printf(buf, "node %d cpus:", i);
 237         for (cpu = cpu_list; cpu; cpu = cpu->next) {
 238             if (cpu->value->props && cpu->value->props->has_node_id &&
 239                 cpu->value->props->node_id == i) {
 240                 g_string_append_printf(buf, " %" PRIi64, cpu->value->cpu_index);
 241             }
 242         }
 243         g_string_append_printf(buf, "\n");
 244         g_string_append_printf(buf, "node %d size: %" PRId64 " MB\n", i,
 245                                node_mem[i].node_mem >> 20);
 246         g_string_append_printf(buf, "node %d plugged: %" PRId64 " MB\n", i,
 247                                node_mem[i].node_plugged_mem >> 20);
 248     }
 249     qapi_free_CpuInfoFastList(cpu_list);
 250     g_free(node_mem);
 251
 252  done:
 253     return human_readable_text_from_str(buf);
 254 }
 255
 256 KvmInfo *qmp_query_kvm(Error **errp)
 257 {
 258     KvmInfo *info = g_malloc0(sizeof(*info));
 259
 260     info->enabled = kvm_enabled();
 261     info->present = accel_find("kvm");
 262
 263     return info;
 264 }
 265
 266 UuidInfo *qmp_query_uuid(Error **errp)
 267 {
 268     UuidInfo *info = g_malloc0(sizeof(*info));
 269
 270     info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
 271     return info;
 272 }
 273
 274 void qmp_system_reset(Error **errp)
 275 {
 276     qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP_SYSTEM_RESET);
 277 }
 278
 279 void qmp_system_powerdown(Error **errp)
 280 {
 281     qemu_system_powerdown_request();
 282 }
 283
 284 void qmp_system_wakeup(Error **errp)
 285 {
 286     if (!qemu_wakeup_suspend_enabled()) {
 287         error_setg(errp,
 288                    "wake-up from suspend is not supported by this guest");
 289         return;
 290     }
 291
 292     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, errp);
 293 }
 294
 295 MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
 296 {
 297     return qmp_memory_device_list();
 298 }
 299
 300 MemoryInfo *qmp_query_memory_size_summary(Error **errp)
 301 {
 302     MemoryInfo *mem_info = g_new0(MemoryInfo, 1);
 303     MachineState *ms = MACHINE(qdev_get_machine());
 304
 305     mem_info->base_memory = ms->ram_size;
 306
 307     mem_info->plugged_memory = get_plugged_memory_size();
 308     mem_info->has_plugged_memory =
 309         mem_info->plugged_memory != (uint64_t)-1;
 310
 311     return mem_info;
 312 }
 313
 314 HumanReadableText *qmp_x_query_ramblock(Error **errp)
 315 {
 316     g_autoptr(GString) buf = ram_block_format();
 317
 318     return human_readable_text_from_str(buf);
 319 }
 320
 321 static int qmp_x_query_irq_foreach(Object *obj, void *opaque)
 322 {
 323     InterruptStatsProvider *intc;
 324     InterruptStatsProviderClass *k;
 325     GString *buf = opaque;
 326
 327     if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
 328         intc = INTERRUPT_STATS_PROVIDER(obj);
 329         k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
 330         uint64_t *irq_counts;
 331         unsigned int nb_irqs, i;
 332         if (k->get_statistics &&
 333             k->get_statistics(intc, &irq_counts, &nb_irqs)) {
 334             if (nb_irqs > 0) {
 335                 g_string_append_printf(buf, "IRQ statistics for %s:\n",
 336                                        object_get_typename(obj));
 337                 for (i = 0; i < nb_irqs; i++) {
 338                     if (irq_counts[i] > 0) {
 339                         g_string_append_printf(buf, "%2d: %" PRId64 "\n", i,
 340                                                irq_counts[i]);
 341                     }
 342                 }
 343             }
 344         } else {
 345             g_string_append_printf(buf,
 346                                    "IRQ statistics not available for %s.\n",
 347                                    object_get_typename(obj));
 348         }
 349     }
 350
 351     return 0;
 352 }
 353
 354 HumanReadableText *qmp_x_query_irq(Error **errp)
 355 {
 356     g_autoptr(GString) buf = g_string_new("");
 357
 358     object_child_foreach_recursive(object_get_root(),
 359                                    qmp_x_query_irq_foreach, buf);
 360
 361     return human_readable_text_from_str(buf);
 362 }
 363
 364 static int qmp_x_query_intc_foreach(Object *obj, void *opaque)
 365 {
 366     InterruptStatsProvider *intc;
 367     InterruptStatsProviderClass *k;
 368     GString *buf = opaque;
 369
 370     if (object_dynamic_cast(obj, TYPE_INTERRUPT_STATS_PROVIDER)) {
 371         intc = INTERRUPT_STATS_PROVIDER(obj);
 372         k = INTERRUPT_STATS_PROVIDER_GET_CLASS(obj);
 373         if (k->print_info) {
 374             k->print_info(intc, buf);
 375         } else {
 376             g_string_append_printf(buf,
 377                                    "Interrupt controller information not available for %s.\n",
 378                                    object_get_typename(obj));
 379         }
 380     }
 381
 382     return 0;
 383 }
 384
 385 HumanReadableText *qmp_x_query_interrupt_controllers(Error **errp)
 386 {
 387     g_autoptr(GString) buf = g_string_new("");
 388     object_child_foreach_recursive(object_get_root(),
 389                                    qmp_x_query_intc_foreach, buf);
 390     return human_readable_text_from_str(buf);
 391 }
 392
 393 GuidInfo *qmp_query_vm_generation_id(Error **errp)
 394 {
 395     GuidInfo *info;
 396     VmGenIdState *vms;
 397     Object *obj = find_vmgenid_dev();
 398
 399     if (!obj) {
 400         error_setg(errp, "VM Generation ID device not found");
 401         return NULL;
 402     }
 403     vms = VMGENID(obj);
 404
 405     info = g_malloc0(sizeof(*info));
 406     info->guid = qemu_uuid_unparse_strdup(&vms->guid);
 407     return info;
 408 }