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