Merge remote-tracking branch 'remotes/elmarco/tags/slirp-pull-request' into staging
[qemu.git] / 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 "cpu.h"
12 #include "hw/boards.h"
13 #include "qapi/error.h"
14 #include "qapi/qapi-commands-machine.h"
15 #include "qapi/qmp/qerror.h"
16 #include "qemu/main-loop.h"
17 #include "sysemu/hostmem.h"
18 #include "sysemu/hw_accel.h"
19 #include "sysemu/numa.h"
20 #include "sysemu/runstate.h"
21 #include "sysemu/sysemu.h"
22
23 CpuInfoList *qmp_query_cpus(Error **errp)
24 {
25 MachineState *ms = MACHINE(qdev_get_machine());
26 MachineClass *mc = MACHINE_GET_CLASS(ms);
27 CpuInfoList *head = NULL, *cur_item = NULL;
28 CPUState *cpu;
29
30 CPU_FOREACH(cpu) {
31 CpuInfoList *info;
32 #if defined(TARGET_I386)
33 X86CPU *x86_cpu = X86_CPU(cpu);
34 CPUX86State *env = &x86_cpu->env;
35 #elif defined(TARGET_PPC)
36 PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
37 CPUPPCState *env = &ppc_cpu->env;
38 #elif defined(TARGET_SPARC)
39 SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
40 CPUSPARCState *env = &sparc_cpu->env;
41 #elif defined(TARGET_RISCV)
42 RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
43 CPURISCVState *env = &riscv_cpu->env;
44 #elif defined(TARGET_MIPS)
45 MIPSCPU *mips_cpu = MIPS_CPU(cpu);
46 CPUMIPSState *env = &mips_cpu->env;
47 #elif defined(TARGET_TRICORE)
48 TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
49 CPUTriCoreState *env = &tricore_cpu->env;
50 #elif defined(TARGET_S390X)
51 S390CPU *s390_cpu = S390_CPU(cpu);
52 CPUS390XState *env = &s390_cpu->env;
53 #endif
54
55 cpu_synchronize_state(cpu);
56
57 info = g_malloc0(sizeof(*info));
58 info->value = g_malloc0(sizeof(*info->value));
59 info->value->CPU = cpu->cpu_index;
60 info->value->current = (cpu == first_cpu);
61 info->value->halted = cpu->halted;
62 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
63 info->value->thread_id = cpu->thread_id;
64 #if defined(TARGET_I386)
65 info->value->arch = CPU_INFO_ARCH_X86;
66 info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
67 #elif defined(TARGET_PPC)
68 info->value->arch = CPU_INFO_ARCH_PPC;
69 info->value->u.ppc.nip = env->nip;
70 #elif defined(TARGET_SPARC)
71 info->value->arch = CPU_INFO_ARCH_SPARC;
72 info->value->u.q_sparc.pc = env->pc;
73 info->value->u.q_sparc.npc = env->npc;
74 #elif defined(TARGET_MIPS)
75 info->value->arch = CPU_INFO_ARCH_MIPS;
76 info->value->u.q_mips.PC = env->active_tc.PC;
77 #elif defined(TARGET_TRICORE)
78 info->value->arch = CPU_INFO_ARCH_TRICORE;
79 info->value->u.tricore.PC = env->PC;
80 #elif defined(TARGET_S390X)
81 info->value->arch = CPU_INFO_ARCH_S390;
82 info->value->u.s390.cpu_state = env->cpu_state;
83 #elif defined(TARGET_RISCV)
84 info->value->arch = CPU_INFO_ARCH_RISCV;
85 info->value->u.riscv.pc = env->pc;
86 #else
87 info->value->arch = CPU_INFO_ARCH_OTHER;
88 #endif
89 info->value->has_props = !!mc->cpu_index_to_instance_props;
90 if (info->value->has_props) {
91 CpuInstanceProperties *props;
92 props = g_malloc0(sizeof(*props));
93 *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
94 info->value->props = props;
95 }
96
97 /* XXX: waiting for the qapi to support GSList */
98 if (!cur_item) {
99 head = cur_item = info;
100 } else {
101 cur_item->next = info;
102 cur_item = info;
103 }
104 }
105
106 return head;
107 }
108
109 static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
110 {
111 /*
112 * The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
113 * TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
114 */
115 switch (target) {
116 case SYS_EMU_TARGET_I386:
117 case SYS_EMU_TARGET_X86_64:
118 return CPU_INFO_ARCH_X86;
119
120 case SYS_EMU_TARGET_PPC:
121 case SYS_EMU_TARGET_PPC64:
122 return CPU_INFO_ARCH_PPC;
123
124 case SYS_EMU_TARGET_SPARC:
125 case SYS_EMU_TARGET_SPARC64:
126 return CPU_INFO_ARCH_SPARC;
127
128 case SYS_EMU_TARGET_MIPS:
129 case SYS_EMU_TARGET_MIPSEL:
130 case SYS_EMU_TARGET_MIPS64:
131 case SYS_EMU_TARGET_MIPS64EL:
132 return CPU_INFO_ARCH_MIPS;
133
134 case SYS_EMU_TARGET_TRICORE:
135 return CPU_INFO_ARCH_TRICORE;
136
137 case SYS_EMU_TARGET_S390X:
138 return CPU_INFO_ARCH_S390;
139
140 case SYS_EMU_TARGET_RISCV32:
141 case SYS_EMU_TARGET_RISCV64:
142 return CPU_INFO_ARCH_RISCV;
143
144 default:
145 return CPU_INFO_ARCH_OTHER;
146 }
147 }
148
149 static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
150 {
151 #ifdef TARGET_S390X
152 S390CPU *s390_cpu = S390_CPU(cpu);
153 CPUS390XState *env = &s390_cpu->env;
154
155 info->cpu_state = env->cpu_state;
156 #else
157 abort();
158 #endif
159 }
160
161 /*
162 * fast means: we NEVER interrupt vCPU threads to retrieve
163 * information from KVM.
164 */
165 CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
166 {
167 MachineState *ms = MACHINE(qdev_get_machine());
168 MachineClass *mc = MACHINE_GET_CLASS(ms);
169 CpuInfoFastList *head = NULL, *cur_item = NULL;
170 SysEmuTarget target = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME,
171 -1, &error_abort);
172 CPUState *cpu;
173
174 CPU_FOREACH(cpu) {
175 CpuInfoFastList *info = g_malloc0(sizeof(*info));
176 info->value = g_malloc0(sizeof(*info->value));
177
178 info->value->cpu_index = cpu->cpu_index;
179 info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
180 info->value->thread_id = cpu->thread_id;
181
182 info->value->has_props = !!mc->cpu_index_to_instance_props;
183 if (info->value->has_props) {
184 CpuInstanceProperties *props;
185 props = g_malloc0(sizeof(*props));
186 *props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
187 info->value->props = props;
188 }
189
190 info->value->arch = sysemu_target_to_cpuinfo_arch(target);
191 info->value->target = target;
192 if (target == SYS_EMU_TARGET_S390X) {
193 cpustate_to_cpuinfo_s390(&info->value->u.s390x, cpu);
194 }
195
196 if (!cur_item) {
197 head = cur_item = info;
198 } else {
199 cur_item->next = info;
200 cur_item = info;
201 }
202 }
203
204 return head;
205 }
206
207 MachineInfoList *qmp_query_machines(Error **errp)
208 {
209 GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false);
210 MachineInfoList *mach_list = NULL;
211
212 for (el = machines; el; el = el->next) {
213 MachineClass *mc = el->data;
214 MachineInfoList *entry;
215 MachineInfo *info;
216
217 info = g_malloc0(sizeof(*info));
218 if (mc->is_default) {
219 info->has_is_default = true;
220 info->is_default = true;
221 }
222
223 if (mc->alias) {
224 info->has_alias = true;
225 info->alias = g_strdup(mc->alias);
226 }
227
228 info->name = g_strdup(mc->name);
229 info->cpu_max = !mc->max_cpus ? 1 : mc->max_cpus;
230 info->hotpluggable_cpus = mc->has_hotpluggable_cpus;
231 info->numa_mem_supported = mc->numa_mem_supported;
232 info->deprecated = !!mc->deprecation_reason;
233 if (mc->default_cpu_type) {
234 info->default_cpu_type = g_strdup(mc->default_cpu_type);
235 info->has_default_cpu_type = true;
236 }
237
238 entry = g_malloc0(sizeof(*entry));
239 entry->value = info;
240 entry->next = mach_list;
241 mach_list = entry;
242 }
243
244 g_slist_free(machines);
245 return mach_list;
246 }
247
248 CurrentMachineParams *qmp_query_current_machine(Error **errp)
249 {
250 CurrentMachineParams *params = g_malloc0(sizeof(*params));
251 params->wakeup_suspend_support = qemu_wakeup_suspend_enabled();
252
253 return params;
254 }
255
256 TargetInfo *qmp_query_target(Error **errp)
257 {
258 TargetInfo *info = g_malloc0(sizeof(*info));
259
260 info->arch = qapi_enum_parse(&SysEmuTarget_lookup, TARGET_NAME, -1,
261 &error_abort);
262
263 return info;
264 }
265
266 HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
267 {
268 MachineState *ms = MACHINE(qdev_get_machine());
269 MachineClass *mc = MACHINE_GET_CLASS(ms);
270
271 if (!mc->has_hotpluggable_cpus) {
272 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
273 return NULL;
274 }
275
276 return machine_query_hotpluggable_cpus(ms);
277 }
278
279 void qmp_cpu_add(int64_t id, Error **errp)
280 {
281 MachineClass *mc;
282
283 mc = MACHINE_GET_CLASS(current_machine);
284 if (mc->hot_add_cpu) {
285 mc->hot_add_cpu(current_machine, id, errp);
286 } else {
287 error_setg(errp, "Not supported");
288 }
289 }
290
291 void qmp_set_numa_node(NumaOptions *cmd, Error **errp)
292 {
293 if (!runstate_check(RUN_STATE_PRECONFIG)) {
294 error_setg(errp, "The command is permitted only in '%s' state",
295 RunState_str(RUN_STATE_PRECONFIG));
296 return;
297 }
298
299 set_numa_options(MACHINE(qdev_get_machine()), cmd, errp);
300 }
301
302 static int query_memdev(Object *obj, void *opaque)
303 {
304 MemdevList **list = opaque;
305 MemdevList *m = NULL;
306
307 if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
308 m = g_malloc0(sizeof(*m));
309
310 m->value = g_malloc0(sizeof(*m->value));
311
312 m->value->id = object_get_canonical_path_component(obj);
313 m->value->has_id = !!m->value->id;
314
315 m->value->size = object_property_get_uint(obj, "size",
316 &error_abort);
317 m->value->merge = object_property_get_bool(obj, "merge",
318 &error_abort);
319 m->value->dump = object_property_get_bool(obj, "dump",
320 &error_abort);
321 m->value->prealloc = object_property_get_bool(obj,
322 "prealloc",
323 &error_abort);
324 m->value->policy = object_property_get_enum(obj,
325 "policy",
326 "HostMemPolicy",
327 &error_abort);
328 object_property_get_uint16List(obj, "host-nodes",
329 &m->value->host_nodes,
330 &error_abort);
331
332 m->next = *list;
333 *list = m;
334 }
335
336 return 0;
337 }
338
339 MemdevList *qmp_query_memdev(Error **errp)
340 {
341 Object *obj = object_get_objects_root();
342 MemdevList *list = NULL;
343
344 object_child_foreach(obj, query_memdev, &list);
345 return list;
346 }