/src/qemu/hw/core/machine-hmp-cmds.c
Line | Count | Source |
1 | | /* |
2 | | * HMP commands related to machines and CPUs |
3 | | * |
4 | | * Copyright IBM, Corp. 2011 |
5 | | * |
6 | | * Authors: |
7 | | * Anthony Liguori <aliguori@us.ibm.com> |
8 | | * |
9 | | * This work is licensed under the terms of the GNU GPL, version 2. See |
10 | | * the COPYING file in the top-level directory. |
11 | | * |
12 | | * Contributions after 2012-01-13 are licensed under the terms of the |
13 | | * GNU GPL, version 2 or (at your option) any later version. |
14 | | */ |
15 | | |
16 | | #include "qemu/osdep.h" |
17 | | #include "monitor/hmp.h" |
18 | | #include "qapi/error.h" |
19 | | #include "qapi/qapi-builtin-visit.h" |
20 | | #include "qapi/qapi-commands-accelerator.h" |
21 | | #include "qapi/qapi-commands-machine.h" |
22 | | #include "qobject/qdict.h" |
23 | | #include "qapi/string-output-visitor.h" |
24 | | #include "qemu/error-report.h" |
25 | | #include "system/numa.h" |
26 | | #include "hw/core/boards.h" |
27 | | |
28 | | void hmp_info_cpus(MonitorHMP *hmp, const QDict *qdict) |
29 | 0 | { |
30 | 0 | CpuInfoFastList *cpu_list, *cpu; |
31 | |
|
32 | 0 | cpu_list = qmp_query_cpus_fast(NULL); |
33 | |
|
34 | 0 | for (cpu = cpu_list; cpu; cpu = cpu->next) { |
35 | 0 | g_autofree char *cpu_model = cpu_model_from_type(cpu->value->qom_type); |
36 | 0 | int active = ' '; |
37 | |
|
38 | 0 | if (cpu->value->cpu_index == monitor_hmp_get_cpu_index(hmp)) { |
39 | 0 | active = '*'; |
40 | 0 | } |
41 | |
|
42 | 0 | monitor_hmp_printf(hmp, "%c CPU #%" PRId64 ":", active, |
43 | 0 | cpu->value->cpu_index); |
44 | 0 | monitor_hmp_printf(hmp, " thread_id=%" PRId64 " model=%s\n", |
45 | 0 | cpu->value->thread_id, cpu_model); |
46 | 0 | } |
47 | |
|
48 | 0 | qapi_free_CpuInfoFastList(cpu_list); |
49 | 0 | } |
50 | | |
51 | | void hmp_hotpluggable_cpus(MonitorHMP *hmp, const QDict *qdict) |
52 | 0 | { |
53 | 0 | Error *err = NULL; |
54 | 0 | HotpluggableCPUList *l = qmp_query_hotpluggable_cpus(&err); |
55 | 0 | HotpluggableCPUList *saved = l; |
56 | 0 | CpuInstanceProperties *c; |
57 | |
|
58 | 0 | if (hmp_handle_error(hmp, err)) { |
59 | 0 | return; |
60 | 0 | } |
61 | | |
62 | 0 | monitor_hmp_printf(hmp, "Hotpluggable CPUs:\n"); |
63 | 0 | while (l) { |
64 | 0 | monitor_hmp_printf(hmp, " type: \"%s\"\n", l->value->type); |
65 | 0 | monitor_hmp_printf(hmp, " vcpus_count: \"%" PRIu64 "\"\n", |
66 | 0 | l->value->vcpus_count); |
67 | 0 | if (l->value->qom_path) { |
68 | 0 | monitor_hmp_printf(hmp, " qom_path: \"%s\"\n", l->value->qom_path); |
69 | 0 | } |
70 | |
|
71 | 0 | c = l->value->props; |
72 | 0 | monitor_hmp_printf(hmp, " CPUInstance Properties:\n"); |
73 | 0 | if (c->has_node_id) { |
74 | 0 | monitor_hmp_printf(hmp, " node-id: \"%" PRIu64 "\"\n", c->node_id); |
75 | 0 | } |
76 | 0 | if (c->has_drawer_id) { |
77 | 0 | monitor_hmp_printf(hmp, " drawer-id: \"%" PRIu64 "\"\n", c->drawer_id); |
78 | 0 | } |
79 | 0 | if (c->has_book_id) { |
80 | 0 | monitor_hmp_printf(hmp, " book-id: \"%" PRIu64 "\"\n", c->book_id); |
81 | 0 | } |
82 | 0 | if (c->has_socket_id) { |
83 | 0 | monitor_hmp_printf(hmp, " socket-id: \"%" PRIu64 "\"\n", c->socket_id); |
84 | 0 | } |
85 | 0 | if (c->has_die_id) { |
86 | 0 | monitor_hmp_printf(hmp, " die-id: \"%" PRIu64 "\"\n", c->die_id); |
87 | 0 | } |
88 | 0 | if (c->has_cluster_id) { |
89 | 0 | monitor_hmp_printf(hmp, " cluster-id: \"%" PRIu64 "\"\n", |
90 | 0 | c->cluster_id); |
91 | 0 | } |
92 | 0 | if (c->has_module_id) { |
93 | 0 | monitor_hmp_printf(hmp, " module-id: \"%" PRIu64 "\"\n", |
94 | 0 | c->module_id); |
95 | 0 | } |
96 | 0 | if (c->has_core_id) { |
97 | 0 | monitor_hmp_printf(hmp, " core-id: \"%" PRIu64 "\"\n", c->core_id); |
98 | 0 | } |
99 | 0 | if (c->has_thread_id) { |
100 | 0 | monitor_hmp_printf(hmp, " thread-id: \"%" PRIu64 "\"\n", c->thread_id); |
101 | 0 | } |
102 | |
|
103 | 0 | l = l->next; |
104 | 0 | } |
105 | |
|
106 | 0 | qapi_free_HotpluggableCPUList(saved); |
107 | 0 | } |
108 | | |
109 | | void hmp_info_memdev(MonitorHMP *hmp, const QDict *qdict) |
110 | 0 | { |
111 | 0 | Error *err = NULL; |
112 | 0 | MemdevList *memdev_list = qmp_query_memdev(&err); |
113 | 0 | MemdevList *m = memdev_list; |
114 | 0 | Visitor *v; |
115 | 0 | char *str; |
116 | |
|
117 | 0 | while (m) { |
118 | 0 | v = string_output_visitor_new(false, &str); |
119 | 0 | visit_type_uint16List(v, NULL, &m->value->host_nodes, &error_abort); |
120 | 0 | monitor_hmp_printf(hmp, "memory backend: %s\n", m->value->id); |
121 | 0 | monitor_hmp_printf(hmp, " size: %" PRId64 "\n", m->value->size); |
122 | 0 | monitor_hmp_printf(hmp, " merge: %s\n", |
123 | 0 | m->value->merge ? "true" : "false"); |
124 | 0 | monitor_hmp_printf(hmp, " dump: %s\n", |
125 | 0 | m->value->dump ? "true" : "false"); |
126 | 0 | monitor_hmp_printf(hmp, " prealloc: %s\n", |
127 | 0 | m->value->prealloc ? "true" : "false"); |
128 | 0 | monitor_hmp_printf(hmp, " share: %s\n", |
129 | 0 | m->value->share ? "true" : "false"); |
130 | 0 | if (m->value->has_reserve) { |
131 | 0 | monitor_hmp_printf(hmp, " reserve: %s\n", |
132 | 0 | m->value->reserve ? "true" : "false"); |
133 | 0 | } |
134 | 0 | monitor_hmp_printf(hmp, " policy: %s\n", |
135 | 0 | HostMemPolicy_str(m->value->policy)); |
136 | 0 | visit_complete(v, &str); |
137 | 0 | monitor_hmp_printf(hmp, " host nodes: %s\n", str); |
138 | |
|
139 | 0 | g_free(str); |
140 | 0 | visit_free(v); |
141 | 0 | m = m->next; |
142 | 0 | } |
143 | |
|
144 | 0 | monitor_hmp_printf(hmp, "\n"); |
145 | |
|
146 | 0 | qapi_free_MemdevList(memdev_list); |
147 | 0 | hmp_handle_error(hmp, err); |
148 | 0 | } |
149 | | |
150 | | void hmp_info_kvm(MonitorHMP *hmp, const QDict *qdict) |
151 | 0 | { |
152 | 0 | KvmInfo *info; |
153 | |
|
154 | 0 | info = qmp_query_kvm(NULL); |
155 | 0 | monitor_hmp_printf(hmp, "kvm support: "); |
156 | 0 | if (info->present) { |
157 | 0 | monitor_hmp_printf(hmp, "%s\n", info->enabled ? "enabled" : "disabled"); |
158 | 0 | } else { |
159 | 0 | monitor_hmp_printf(hmp, "not compiled\n"); |
160 | 0 | } |
161 | |
|
162 | 0 | qapi_free_KvmInfo(info); |
163 | 0 | } |
164 | | |
165 | | void hmp_info_accelerators(MonitorHMP *hmp, const QDict *qdict) |
166 | 0 | { |
167 | 0 | AcceleratorInfo *info; |
168 | 0 | AcceleratorList *accel; |
169 | |
|
170 | 0 | info = qmp_query_accelerators(NULL); |
171 | 0 | for (accel = info->present; accel; accel = accel->next) { |
172 | 0 | char trail = accel->next ? ' ' : '\n'; |
173 | 0 | if (info->enabled == accel->value) { |
174 | 0 | monitor_hmp_printf(hmp, "[%s]%c", Accelerator_str(accel->value), trail); |
175 | 0 | } else { |
176 | 0 | monitor_hmp_printf(hmp, "%s%c", Accelerator_str(accel->value), trail); |
177 | 0 | } |
178 | 0 | } |
179 | |
|
180 | 0 | qapi_free_AcceleratorInfo(info); |
181 | 0 | } |
182 | | |
183 | | void hmp_info_uuid(MonitorHMP *hmp, const QDict *qdict) |
184 | 0 | { |
185 | 0 | UuidInfo *info; |
186 | |
|
187 | 0 | info = qmp_query_uuid(NULL); |
188 | 0 | monitor_hmp_printf(hmp, "%s\n", info->UUID); |
189 | 0 | qapi_free_UuidInfo(info); |
190 | 0 | } |
191 | | |
192 | | void hmp_info_balloon(MonitorHMP *hmp, const QDict *qdict) |
193 | 0 | { |
194 | 0 | BalloonInfo *info; |
195 | 0 | Error *err = NULL; |
196 | |
|
197 | 0 | info = qmp_query_balloon(&err); |
198 | 0 | if (hmp_handle_error(hmp, err)) { |
199 | 0 | return; |
200 | 0 | } |
201 | | |
202 | 0 | monitor_hmp_printf(hmp, "balloon: actual=%" PRId64 "\n", info->actual >> 20); |
203 | |
|
204 | 0 | qapi_free_BalloonInfo(info); |
205 | 0 | } |
206 | | |
207 | | void hmp_system_reset(MonitorHMP *hmp, const QDict *qdict) |
208 | 0 | { |
209 | 0 | qmp_system_reset(NULL); |
210 | 0 | } |
211 | | |
212 | | void hmp_system_powerdown(MonitorHMP *hmp, const QDict *qdict) |
213 | 0 | { |
214 | 0 | qmp_system_powerdown(NULL); |
215 | 0 | } |
216 | | |
217 | | void hmp_memsave(MonitorHMP *hmp, const QDict *qdict) |
218 | 0 | { |
219 | 0 | uint32_t size = qdict_get_int(qdict, "size"); |
220 | 0 | const char *filename = qdict_get_str(qdict, "filename"); |
221 | 0 | uint64_t addr = qdict_get_int(qdict, "val"); |
222 | 0 | Error *err = NULL; |
223 | 0 | int cpu_index = monitor_hmp_get_cpu_index(hmp); |
224 | |
|
225 | 0 | if (cpu_index < 0) { |
226 | 0 | monitor_hmp_printf(hmp, "No CPU available\n"); |
227 | 0 | return; |
228 | 0 | } |
229 | | |
230 | 0 | qmp_memsave(addr, size, filename, true, cpu_index, &err); |
231 | 0 | hmp_handle_error(hmp, err); |
232 | 0 | } |
233 | | |
234 | | void hmp_pmemsave(MonitorHMP *hmp, const QDict *qdict) |
235 | 0 | { |
236 | 0 | uint32_t size = qdict_get_int(qdict, "size"); |
237 | 0 | const char *filename = qdict_get_str(qdict, "filename"); |
238 | 0 | uint64_t addr = qdict_get_int(qdict, "val"); |
239 | 0 | Error *err = NULL; |
240 | |
|
241 | 0 | qmp_pmemsave(addr, size, filename, &err); |
242 | 0 | hmp_handle_error(hmp, err); |
243 | 0 | } |
244 | | |
245 | | void hmp_system_wakeup(MonitorHMP *hmp, const QDict *qdict) |
246 | 0 | { |
247 | 0 | Error *err = NULL; |
248 | |
|
249 | 0 | qmp_system_wakeup(&err); |
250 | 0 | hmp_handle_error(hmp, err); |
251 | 0 | } |
252 | | |
253 | | void hmp_nmi(MonitorHMP *hmp, const QDict *qdict) |
254 | 0 | { |
255 | 0 | Error *err = NULL; |
256 | |
|
257 | 0 | qmp_inject_nmi(&err); |
258 | 0 | hmp_handle_error(hmp, err); |
259 | 0 | } |
260 | | |
261 | | void hmp_balloon(MonitorHMP *hmp, const QDict *qdict) |
262 | 0 | { |
263 | 0 | int64_t value = qdict_get_int(qdict, "value"); |
264 | 0 | Error *err = NULL; |
265 | |
|
266 | 0 | qmp_balloon(value, &err); |
267 | 0 | hmp_handle_error(hmp, err); |
268 | 0 | } |
269 | | |
270 | | void hmp_info_memory_devices(MonitorHMP *hmp, const QDict *qdict) |
271 | 0 | { |
272 | 0 | Error *err = NULL; |
273 | 0 | MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err); |
274 | 0 | MemoryDeviceInfoList *info; |
275 | 0 | VirtioPMEMDeviceInfo *vpi; |
276 | 0 | VirtioMEMDeviceInfo *vmi; |
277 | 0 | MemoryDeviceInfo *value; |
278 | 0 | PCDIMMDeviceInfo *di; |
279 | 0 | SgxEPCDeviceInfo *se; |
280 | 0 | HvBalloonDeviceInfo *hi; |
281 | 0 | SpMemDeviceInfo *spmi; |
282 | |
|
283 | 0 | for (info = info_list; info; info = info->next) { |
284 | 0 | value = info->value; |
285 | |
|
286 | 0 | if (value) { |
287 | 0 | switch (value->type) { |
288 | 0 | case MEMORY_DEVICE_INFO_KIND_DIMM: |
289 | 0 | case MEMORY_DEVICE_INFO_KIND_NVDIMM: |
290 | 0 | di = value->type == MEMORY_DEVICE_INFO_KIND_DIMM ? |
291 | 0 | value->u.dimm.data : value->u.nvdimm.data; |
292 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
293 | 0 | MemoryDeviceInfoKind_str(value->type), |
294 | 0 | di->id ? di->id : ""); |
295 | 0 | monitor_hmp_printf(hmp, " addr: 0x%" PRIx64 "\n", di->addr); |
296 | 0 | monitor_hmp_printf(hmp, " slot: %" PRId64 "\n", di->slot); |
297 | 0 | monitor_hmp_printf(hmp, " node: %" PRId64 "\n", di->node); |
298 | 0 | monitor_hmp_printf(hmp, " size: %" PRIu64 "\n", di->size); |
299 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", di->memdev); |
300 | 0 | monitor_hmp_printf(hmp, " hotplugged: %s\n", |
301 | 0 | di->hotplugged ? "true" : "false"); |
302 | 0 | monitor_hmp_printf(hmp, " hotpluggable: %s\n", |
303 | 0 | di->hotpluggable ? "true" : "false"); |
304 | 0 | break; |
305 | 0 | case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM: |
306 | 0 | vpi = value->u.virtio_pmem.data; |
307 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
308 | 0 | MemoryDeviceInfoKind_str(value->type), |
309 | 0 | vpi->id ? vpi->id : ""); |
310 | 0 | monitor_hmp_printf(hmp, " memaddr: 0x%" PRIx64 "\n", vpi->memaddr); |
311 | 0 | monitor_hmp_printf(hmp, " size: %" PRIu64 "\n", vpi->size); |
312 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", vpi->memdev); |
313 | 0 | break; |
314 | 0 | case MEMORY_DEVICE_INFO_KIND_VIRTIO_MEM: |
315 | 0 | vmi = value->u.virtio_mem.data; |
316 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
317 | 0 | MemoryDeviceInfoKind_str(value->type), |
318 | 0 | vmi->id ? vmi->id : ""); |
319 | 0 | monitor_hmp_printf(hmp, " memaddr: 0x%" PRIx64 "\n", vmi->memaddr); |
320 | 0 | monitor_hmp_printf(hmp, " node: %" PRId64 "\n", vmi->node); |
321 | 0 | monitor_hmp_printf(hmp, " requested-size: %" PRIu64 "\n", |
322 | 0 | vmi->requested_size); |
323 | 0 | monitor_hmp_printf(hmp, " size: %" PRIu64 "\n", vmi->size); |
324 | 0 | monitor_hmp_printf(hmp, " max-size: %" PRIu64 "\n", vmi->max_size); |
325 | 0 | monitor_hmp_printf(hmp, " block-size: %" PRIu64 "\n", |
326 | 0 | vmi->block_size); |
327 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", vmi->memdev); |
328 | 0 | break; |
329 | 0 | case MEMORY_DEVICE_INFO_KIND_SGX_EPC: |
330 | 0 | se = value->u.sgx_epc.data; |
331 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
332 | 0 | MemoryDeviceInfoKind_str(value->type), |
333 | 0 | se->id ? se->id : ""); |
334 | 0 | monitor_hmp_printf(hmp, " memaddr: 0x%" PRIx64 "\n", se->memaddr); |
335 | 0 | monitor_hmp_printf(hmp, " size: %" PRIu64 "\n", se->size); |
336 | 0 | monitor_hmp_printf(hmp, " node: %" PRId64 "\n", se->node); |
337 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", se->memdev); |
338 | 0 | break; |
339 | 0 | case MEMORY_DEVICE_INFO_KIND_HV_BALLOON: |
340 | 0 | hi = value->u.hv_balloon.data; |
341 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
342 | 0 | MemoryDeviceInfoKind_str(value->type), |
343 | 0 | hi->id ? hi->id : ""); |
344 | 0 | if (hi->has_memaddr) { |
345 | 0 | monitor_hmp_printf(hmp, " memaddr: 0x%" PRIx64 "\n", |
346 | 0 | hi->memaddr); |
347 | 0 | } |
348 | 0 | monitor_hmp_printf(hmp, " max-size: %" PRIu64 "\n", hi->max_size); |
349 | 0 | if (hi->memdev) { |
350 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", hi->memdev); |
351 | 0 | } |
352 | 0 | break; |
353 | 0 | case MEMORY_DEVICE_INFO_KIND_SP_MEM: |
354 | 0 | spmi = value->u.sp_mem.data; |
355 | 0 | monitor_hmp_printf(hmp, "Memory device [%s]: \"%s\"\n", |
356 | 0 | MemoryDeviceInfoKind_str(value->type), |
357 | 0 | spmi->id ? spmi->id : ""); |
358 | 0 | monitor_hmp_printf(hmp, " addr: 0x%" PRIx64 "\n", spmi->addr); |
359 | 0 | monitor_hmp_printf(hmp, " node: %" PRId64 "\n", spmi->node); |
360 | 0 | monitor_hmp_printf(hmp, " size: %" PRIu64 "\n", spmi->size); |
361 | 0 | monitor_hmp_printf(hmp, " memdev: %s\n", spmi->memdev); |
362 | 0 | break; |
363 | 0 | default: |
364 | 0 | g_assert_not_reached(); |
365 | 0 | } |
366 | 0 | } |
367 | 0 | } |
368 | | |
369 | 0 | qapi_free_MemoryDeviceInfoList(info_list); |
370 | 0 | hmp_handle_error(hmp, err); |
371 | 0 | } |
372 | | |
373 | | void hmp_info_vm_generation_id(MonitorHMP *hmp, const QDict *qdict) |
374 | 0 | { |
375 | 0 | Error *err = NULL; |
376 | 0 | GuidInfo *info = qmp_query_vm_generation_id(&err); |
377 | 0 | if (info) { |
378 | 0 | monitor_hmp_printf(hmp, "%s\n", info->guid); |
379 | 0 | } |
380 | 0 | hmp_handle_error(hmp, err); |
381 | 0 | qapi_free_GuidInfo(info); |
382 | 0 | } |
383 | | |
384 | | void hmp_info_memory_size_summary(MonitorHMP *hmp, const QDict *qdict) |
385 | 0 | { |
386 | 0 | Error *err = NULL; |
387 | 0 | MemoryInfo *info = qmp_query_memory_size_summary(&err); |
388 | 0 | if (info) { |
389 | 0 | monitor_hmp_printf(hmp, "base memory: %" PRIu64 "\n", |
390 | 0 | info->base_memory); |
391 | |
|
392 | 0 | if (info->has_plugged_memory) { |
393 | 0 | monitor_hmp_printf(hmp, "plugged memory: %" PRIu64 "\n", |
394 | 0 | info->plugged_memory); |
395 | 0 | } |
396 | |
|
397 | 0 | qapi_free_MemoryInfo(info); |
398 | 0 | } |
399 | 0 | hmp_handle_error(hmp, err); |
400 | 0 | } |