Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/virtio/virtio-hmp-cmds.c
Line
Count
Source
1
/*
2
 * HMP commands related to virtio
3
 *
4
 * This work is licensed under the terms of the GNU GPL, version 2 or
5
 * (at your option) any later version.
6
 */
7
8
#include "qemu/osdep.h"
9
#include "monitor/hmp.h"
10
#include "monitor/monitor.h"
11
#include "qapi/qapi-commands-virtio.h"
12
#include "qobject/qdict.h"
13
14
15
static void hmp_virtio_dump_protocols(MonitorHMP *hmp,
16
                                      VhostDeviceProtocols *pcol)
17
0
{
18
0
    strList *pcol_list = pcol->protocols;
19
0
    while (pcol_list) {
20
0
        monitor_hmp_printf(hmp, "\t%s", pcol_list->value);
21
0
        pcol_list = pcol_list->next;
22
0
        if (pcol_list != NULL) {
23
0
            monitor_hmp_printf(hmp, ",\n");
24
0
        }
25
0
    }
26
0
    monitor_hmp_printf(hmp, "\n");
27
0
    if (pcol->has_unknown_protocols) {
28
0
        monitor_hmp_printf(hmp, "  unknown-protocols(0x%016"PRIx64")\n",
29
0
                           pcol->unknown_protocols);
30
0
    }
31
0
}
32
33
static void hmp_virtio_dump_status(MonitorHMP *hmp,
34
                                   VirtioDeviceStatus *status)
35
0
{
36
0
    strList *status_list = status->statuses;
37
0
    while (status_list) {
38
0
        monitor_hmp_printf(hmp, "\t%s", status_list->value);
39
0
        status_list = status_list->next;
40
0
        if (status_list != NULL) {
41
0
            monitor_hmp_printf(hmp, ",\n");
42
0
        }
43
0
    }
44
0
    monitor_hmp_printf(hmp, "\n");
45
0
    if (status->has_unknown_statuses) {
46
0
        monitor_hmp_printf(hmp, "  unknown-statuses(0x%016"PRIx32")\n",
47
0
                           status->unknown_statuses);
48
0
    }
49
0
}
50
51
static void hmp_virtio_dump_features(MonitorHMP *hmp,
52
                                     VirtioDeviceFeatures *features)
53
0
{
54
0
    strList *transport_list = features->transports;
55
0
    while (transport_list) {
56
0
        monitor_hmp_printf(hmp, "\t%s", transport_list->value);
57
0
        transport_list = transport_list->next;
58
0
        if (transport_list != NULL) {
59
0
            monitor_hmp_printf(hmp, ",\n");
60
0
        }
61
0
    }
62
63
0
    monitor_hmp_printf(hmp, "\n");
64
0
    strList *list = features->dev_features;
65
0
    if (list) {
66
0
        while (list) {
67
0
            monitor_hmp_printf(hmp, "\t%s", list->value);
68
0
            list = list->next;
69
0
            if (list != NULL) {
70
0
                monitor_hmp_printf(hmp, ",\n");
71
0
            }
72
0
        }
73
0
        monitor_hmp_printf(hmp, "\n");
74
0
    }
75
76
0
    if (features->has_unknown_dev_features) {
77
0
        monitor_hmp_printf(hmp, "  unknown-features(0x%016"PRIx64"%016"PRIx64")\n",
78
0
                           features->unknown_dev_features2,
79
0
                           features->unknown_dev_features);
80
0
    }
81
0
}
82
83
void hmp_virtio_query(MonitorHMP *hmp, const QDict *qdict)
84
0
{
85
0
    Error *err = NULL;
86
0
    VirtioInfoList *list = qmp_x_query_virtio(&err);
87
0
    VirtioInfoList *node;
88
89
0
    if (err != NULL) {
90
0
        hmp_handle_error(hmp, err);
91
0
        return;
92
0
    }
93
94
0
    if (list == NULL) {
95
0
        monitor_hmp_printf(hmp, "No VirtIO devices\n");
96
0
        return;
97
0
    }
98
99
0
    node = list;
100
0
    while (node) {
101
0
        monitor_hmp_printf(hmp, "%s [%s]\n", node->value->path,
102
0
                           node->value->name);
103
0
        node = node->next;
104
0
    }
105
0
    qapi_free_VirtioInfoList(list);
106
0
}
107
108
void hmp_virtio_status(MonitorHMP *hmp, const QDict *qdict)
109
0
{
110
0
    Error *err = NULL;
111
0
    const char *path = qdict_get_try_str(qdict, "path");
112
0
    VirtioStatus *s = qmp_x_query_virtio_status(path, &err);
113
114
0
    if (err != NULL) {
115
0
        hmp_handle_error(hmp, err);
116
0
        return;
117
0
    }
118
119
0
    monitor_hmp_printf(hmp, "%s:\n", path);
120
0
    monitor_hmp_printf(hmp, "  device_name:             %s %s\n",
121
0
                       s->name, s->vhost_dev ? "(vhost)" : "");
122
0
    monitor_hmp_printf(hmp, "  device_id:               %d\n", s->device_id);
123
0
    monitor_hmp_printf(hmp, "  vhost_started:           %s\n",
124
0
                       s->vhost_started ? "true" : "false");
125
0
    monitor_hmp_printf(hmp, "  bus_name:                %s\n", s->bus_name);
126
0
    monitor_hmp_printf(hmp, "  broken:                  %s\n",
127
0
                       s->broken ? "true" : "false");
128
0
    monitor_hmp_printf(hmp, "  disabled:                %s\n",
129
0
                       s->disabled ? "true" : "false");
130
0
    monitor_hmp_printf(hmp, "  disable_legacy_check:    %s\n",
131
0
                       s->disable_legacy_check ? "true" : "false");
132
0
    monitor_hmp_printf(hmp, "  started:                 %s\n",
133
0
                       s->started ? "true" : "false");
134
0
    monitor_hmp_printf(hmp, "  use_started:             %s\n",
135
0
                       s->use_started ? "true" : "false");
136
0
    monitor_hmp_printf(hmp, "  start_on_kick:           %s\n",
137
0
                       s->start_on_kick ? "true" : "false");
138
0
    monitor_hmp_printf(hmp, "  use_guest_notifier_mask: %s\n",
139
0
                       s->use_guest_notifier_mask ? "true" : "false");
140
0
    monitor_hmp_printf(hmp, "  vm_running:              %s\n",
141
0
                       s->vm_running ? "true" : "false");
142
0
    monitor_hmp_printf(hmp, "  num_vqs:                 %"PRId64"\n", s->num_vqs);
143
0
    monitor_hmp_printf(hmp, "  queue_sel:               %d\n",
144
0
                       s->queue_sel);
145
0
    monitor_hmp_printf(hmp, "  isr:                     %d\n", s->isr);
146
0
    monitor_hmp_printf(hmp, "  endianness:              %s\n",
147
0
                       s->device_endian);
148
0
    monitor_hmp_printf(hmp, "  status:\n");
149
0
    hmp_virtio_dump_status(hmp, s->status);
150
0
    monitor_hmp_printf(hmp, "  Guest features:\n");
151
0
    hmp_virtio_dump_features(hmp, s->guest_features);
152
0
    monitor_hmp_printf(hmp, "  Host features:\n");
153
0
    hmp_virtio_dump_features(hmp, s->host_features);
154
0
    monitor_hmp_printf(hmp, "  Backend features:\n");
155
0
    hmp_virtio_dump_features(hmp, s->backend_features);
156
157
0
    if (s->vhost_dev) {
158
0
        monitor_hmp_printf(hmp, "  VHost:\n");
159
0
        monitor_hmp_printf(hmp, "    nvqs:           %d\n",
160
0
                           s->vhost_dev->nvqs);
161
0
        monitor_hmp_printf(hmp, "    vq_index:       %"PRId64"\n",
162
0
                           s->vhost_dev->vq_index);
163
0
        monitor_hmp_printf(hmp, "    max_queues:     %"PRId64"\n",
164
0
                           s->vhost_dev->max_queues);
165
0
        monitor_hmp_printf(hmp, "    n_mem_sections: %"PRId64"\n",
166
0
                           s->vhost_dev->n_mem_sections);
167
0
        monitor_hmp_printf(hmp, "    n_tmp_sections: %"PRId64"\n",
168
0
                           s->vhost_dev->n_tmp_sections);
169
0
        monitor_hmp_printf(hmp, "    backend_cap:    %"PRId64"\n",
170
0
                           s->vhost_dev->backend_cap);
171
0
        monitor_hmp_printf(hmp, "    log_enabled:    %s\n",
172
0
                           s->vhost_dev->log_enabled ? "true" : "false");
173
0
        monitor_hmp_printf(hmp, "    log_size:       %"PRId64"\n",
174
0
                           s->vhost_dev->log_size);
175
0
        monitor_hmp_printf(hmp, "    Features:\n");
176
0
        hmp_virtio_dump_features(hmp, s->vhost_dev->features);
177
0
        monitor_hmp_printf(hmp, "    Acked features:\n");
178
0
        hmp_virtio_dump_features(hmp, s->vhost_dev->acked_features);
179
0
        if (s->vhost_dev->protocol_features) {
180
0
            monitor_hmp_printf(hmp, "    Protocol features:\n");
181
0
            hmp_virtio_dump_protocols(hmp, s->vhost_dev->protocol_features);
182
0
        }
183
0
    }
184
185
0
    qapi_free_VirtioStatus(s);
186
0
}
187
188
void hmp_vhost_queue_status(MonitorHMP *hmp, const QDict *qdict)
189
0
{
190
0
    Error *err = NULL;
191
0
    const char *path = qdict_get_try_str(qdict, "path");
192
0
    int queue = qdict_get_int(qdict, "queue");
193
0
    VirtVhostQueueStatus *s =
194
0
        qmp_x_query_virtio_vhost_queue_status(path, queue, &err);
195
196
0
    if (err != NULL) {
197
0
        hmp_handle_error(hmp, err);
198
0
        return;
199
0
    }
200
201
0
    monitor_hmp_printf(hmp, "%s:\n", path);
202
0
    monitor_hmp_printf(hmp, "  device_name:          %s (vhost)\n",
203
0
                       s->name);
204
0
    monitor_hmp_printf(hmp, "  kick:                 %"PRId64"\n", s->kick);
205
0
    monitor_hmp_printf(hmp, "  call:                 %"PRId64"\n", s->call);
206
0
    monitor_hmp_printf(hmp, "  VRing:\n");
207
0
    monitor_hmp_printf(hmp, "    num:         %"PRId64"\n", s->num);
208
0
    monitor_hmp_printf(hmp, "    desc_phys:   0x%016"PRIx64"\n",
209
0
                       s->desc_phys);
210
0
    monitor_hmp_printf(hmp, "    desc_size:   %"PRId32"\n", s->desc_size);
211
0
    monitor_hmp_printf(hmp, "    avail_phys:  0x%016"PRIx64"\n",
212
0
                       s->avail_phys);
213
0
    monitor_hmp_printf(hmp, "    avail_size:  %"PRId32"\n", s->avail_size);
214
0
    monitor_hmp_printf(hmp, "    used_phys:   0x%016"PRIx64"\n",
215
0
                       s->used_phys);
216
0
    monitor_hmp_printf(hmp, "    used_size:   %"PRId32"\n", s->used_size);
217
218
0
    qapi_free_VirtVhostQueueStatus(s);
219
0
}
220
221
void hmp_virtio_queue_status(MonitorHMP *hmp, const QDict *qdict)
222
0
{
223
0
    Error *err = NULL;
224
0
    const char *path = qdict_get_try_str(qdict, "path");
225
0
    int queue = qdict_get_int(qdict, "queue");
226
0
    VirtQueueStatus *s = qmp_x_query_virtio_queue_status(path, queue, &err);
227
228
0
    if (err != NULL) {
229
0
        hmp_handle_error(hmp, err);
230
0
        return;
231
0
    }
232
233
0
    monitor_hmp_printf(hmp, "%s:\n", path);
234
0
    monitor_hmp_printf(hmp, "  device_name:          %s\n", s->name);
235
0
    monitor_hmp_printf(hmp, "  queue_index:          %d\n", s->queue_index);
236
0
    monitor_hmp_printf(hmp, "  inuse:                %d\n", s->inuse);
237
0
    monitor_hmp_printf(hmp, "  used_idx:             %d\n", s->used_idx);
238
0
    monitor_hmp_printf(hmp, "  signalled_used:       %d\n",
239
0
                       s->signalled_used);
240
0
    monitor_hmp_printf(hmp, "  signalled_used_valid: %s\n",
241
0
                       s->signalled_used_valid ? "true" : "false");
242
0
    if (s->has_last_avail_idx) {
243
0
        monitor_hmp_printf(hmp, "  last_avail_idx:       %d\n",
244
0
                           s->last_avail_idx);
245
0
    }
246
0
    if (s->has_shadow_avail_idx) {
247
0
        monitor_hmp_printf(hmp, "  shadow_avail_idx:     %d\n",
248
0
                           s->shadow_avail_idx);
249
0
    }
250
0
    monitor_hmp_printf(hmp, "  VRing:\n");
251
0
    monitor_hmp_printf(hmp, "    num:          %"PRId32"\n", s->vring_num);
252
0
    monitor_hmp_printf(hmp, "    num_default:  %"PRId32"\n",
253
0
                       s->vring_num_default);
254
0
    monitor_hmp_printf(hmp, "    align:        %"PRId32"\n",
255
0
                       s->vring_align);
256
0
    monitor_hmp_printf(hmp, "    desc:         0x%016"PRIx64"\n",
257
0
                       s->vring_desc);
258
0
    monitor_hmp_printf(hmp, "    avail:        0x%016"PRIx64"\n",
259
0
                       s->vring_avail);
260
0
    monitor_hmp_printf(hmp, "    used:         0x%016"PRIx64"\n",
261
0
                       s->vring_used);
262
263
0
    qapi_free_VirtQueueStatus(s);
264
0
}
265
266
void hmp_virtio_queue_element(MonitorHMP *hmp, const QDict *qdict)
267
0
{
268
0
    Error *err = NULL;
269
0
    const char *path = qdict_get_try_str(qdict, "path");
270
0
    int queue = qdict_get_int(qdict, "queue");
271
0
    int index = qdict_get_try_int(qdict, "index", -1);
272
0
    VirtioQueueElement *e;
273
0
    VirtioRingDescList *list;
274
275
0
    e = qmp_x_query_virtio_queue_element(path, queue, index != -1,
276
0
                                         index, &err);
277
0
    if (err != NULL) {
278
0
        hmp_handle_error(hmp, err);
279
0
        return;
280
0
    }
281
282
0
    monitor_hmp_printf(hmp, "%s:\n", path);
283
0
    monitor_hmp_printf(hmp, "  device_name: %s\n", e->name);
284
0
    monitor_hmp_printf(hmp, "  index:   %d\n", e->index);
285
0
    monitor_hmp_printf(hmp, "  desc:\n");
286
0
    monitor_hmp_printf(hmp, "    descs:\n");
287
288
0
    list = e->descs;
289
0
    while (list) {
290
0
        monitor_hmp_printf(hmp, "        addr 0x%"PRIx64" len %d",
291
0
                           list->value->addr, list->value->len);
292
0
        if (list->value->flags) {
293
0
            strList *flag = list->value->flags;
294
0
            monitor_hmp_printf(hmp, " (");
295
0
            while (flag) {
296
0
                monitor_hmp_printf(hmp, "%s", flag->value);
297
0
                flag = flag->next;
298
0
                if (flag) {
299
0
                    monitor_hmp_printf(hmp, ", ");
300
0
                }
301
0
            }
302
0
            monitor_hmp_printf(hmp, ")");
303
0
        }
304
0
        list = list->next;
305
0
        if (list) {
306
0
            monitor_hmp_printf(hmp, ",\n");
307
0
        }
308
0
    }
309
0
    monitor_hmp_printf(hmp, "\n");
310
0
    monitor_hmp_printf(hmp, "  avail:\n");
311
0
    monitor_hmp_printf(hmp, "    flags: %d\n", e->avail->flags);
312
0
    monitor_hmp_printf(hmp, "    idx:   %d\n", e->avail->idx);
313
0
    monitor_hmp_printf(hmp, "    ring:  %d\n", e->avail->ring);
314
0
    monitor_hmp_printf(hmp, "  used:\n");
315
0
    monitor_hmp_printf(hmp, "    flags: %d\n", e->used->flags);
316
0
    monitor_hmp_printf(hmp, "    idx:   %d\n", e->used->idx);
317
318
0
    qapi_free_VirtioQueueElement(e);
319
0
}