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 } 409