Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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
}