Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/tests/qtest/libqos/virtio-mmio.c
Line
Count
Source
1
/*
2
 * libqos virtio MMIO driver
3
 *
4
 * Copyright (c) 2014 Marc MarĂ­
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 "../libqtest.h"
12
#include "qemu/module.h"
13
#include "virtio.h"
14
#include "virtio-mmio.h"
15
#include "libqos-malloc.h"
16
#include "qgraph.h"
17
#include "standard-headers/linux/virtio_ring.h"
18
19
static uint8_t qvirtio_mmio_config_readb(QVirtioDevice *d, uint64_t off)
20
0
{
21
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
22
0
    return qtest_readb(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
23
0
}
24
25
static uint16_t qvirtio_mmio_config_readw(QVirtioDevice *d, uint64_t off)
26
0
{
27
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
28
0
    return qtest_readw(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
29
0
}
30
31
static uint32_t qvirtio_mmio_config_readl(QVirtioDevice *d, uint64_t off)
32
0
{
33
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
34
0
    return qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
35
0
}
36
37
static uint64_t qvirtio_mmio_config_readq(QVirtioDevice *d, uint64_t off)
38
0
{
39
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
40
0
    return qtest_readq(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_SPECIFIC + off);
41
0
}
42
43
static uint64_t qvirtio_mmio_get_features(QVirtioDevice *d)
44
0
{
45
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
46
0
    uint64_t lo;
47
0
    uint64_t hi = 0;
48
49
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 0);
50
0
    lo = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
51
52
0
    if (dev->version >= 2) {
53
0
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES_SEL, 1);
54
0
        hi = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_HOST_FEATURES);
55
0
    }
56
57
0
    return (hi << 32) | lo;
58
0
}
59
60
static void qvirtio_mmio_set_features(QVirtioDevice *d, uint64_t features)
61
0
{
62
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
63
0
    dev->features = features;
64
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 0);
65
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES, features);
66
67
0
    if (dev->version >= 2) {
68
0
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES_SEL, 1);
69
0
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_GUEST_FEATURES,
70
0
                     features >> 32);
71
0
    }
72
0
}
73
74
static uint64_t qvirtio_mmio_get_guest_features(QVirtioDevice *d)
75
0
{
76
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
77
0
    return dev->features;
78
0
}
79
80
static uint8_t qvirtio_mmio_get_status(QVirtioDevice *d)
81
0
{
82
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
83
0
    return (uint8_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS);
84
0
}
85
86
static void qvirtio_mmio_set_status(QVirtioDevice *d, uint8_t status)
87
0
{
88
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
89
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_DEVICE_STATUS, (uint32_t)status);
90
0
}
91
92
static bool qvirtio_mmio_get_queue_isr_status(QVirtioDevice *d, QVirtQueue *vq)
93
0
{
94
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
95
0
    uint32_t isr;
96
97
0
    isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 1;
98
0
    if (isr != 0) {
99
0
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 1);
100
0
        return true;
101
0
    }
102
103
0
    return false;
104
0
}
105
106
static bool qvirtio_mmio_get_config_isr_status(QVirtioDevice *d)
107
0
{
108
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
109
0
    uint32_t isr;
110
111
0
    isr = qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_STATUS) & 2;
112
0
    if (isr != 0) {
113
0
        qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_INTERRUPT_ACK, 2);
114
0
        return true;
115
0
    }
116
117
0
    return false;
118
0
}
119
120
static void qvirtio_mmio_wait_config_isr_status(QVirtioDevice *d,
121
                                                gint64 timeout_us)
122
0
{
123
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
124
0
    gint64 start_time = g_get_monotonic_time();
125
126
0
    do {
127
0
        g_assert(g_get_monotonic_time() - start_time <= timeout_us);
128
0
        qtest_clock_step(dev->qts, 100);
129
0
    } while (!qvirtio_mmio_get_config_isr_status(d));
130
0
}
131
132
static void qvirtio_mmio_queue_select(QVirtioDevice *d, uint16_t index)
133
0
{
134
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
135
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_SEL, (uint32_t)index);
136
137
0
    g_assert_cmphex(qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN), ==, 0);
138
0
}
139
140
static uint16_t qvirtio_mmio_get_queue_size(QVirtioDevice *d)
141
0
{
142
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
143
0
    return (uint16_t)qtest_readl(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM_MAX);
144
0
}
145
146
static void qvirtio_mmio_set_queue_address(QVirtioDevice *d, QVirtQueue *vq)
147
0
{
148
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
149
0
    uint64_t pfn = vq->desc / dev->page_size;
150
151
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_PFN, pfn);
152
0
}
153
154
static QVirtQueue *qvirtio_mmio_virtqueue_setup(QVirtioDevice *d,
155
                                        QGuestAllocator *alloc, uint16_t index)
156
0
{
157
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
158
0
    QVirtQueue *vq;
159
0
    uint64_t addr;
160
161
0
    vq = g_malloc0(sizeof(*vq));
162
0
    vq->vdev = d;
163
0
    qvirtio_mmio_queue_select(d, index);
164
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_ALIGN, dev->page_size);
165
166
0
    vq->index = index;
167
0
    vq->size = qvirtio_mmio_get_queue_size(d);
168
0
    vq->free_head = 0;
169
0
    vq->num_free = vq->size;
170
0
    vq->align = dev->page_size;
171
0
    vq->indirect = dev->features & (1ull << VIRTIO_RING_F_INDIRECT_DESC);
172
0
    vq->event = dev->features & (1ull << VIRTIO_RING_F_EVENT_IDX);
173
174
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NUM, vq->size);
175
176
    /* Check different than 0 */
177
0
    g_assert_cmpint(vq->size, !=, 0);
178
179
    /* Check power of 2 */
180
0
    g_assert_cmpint(vq->size & (vq->size - 1), ==, 0);
181
182
0
    addr = guest_alloc(alloc, qvring_size(vq->size, dev->page_size));
183
0
    qvring_init(dev->qts, alloc, vq, addr);
184
0
    qvirtio_mmio_set_queue_address(d, vq);
185
186
0
    return vq;
187
0
}
188
189
static void qvirtio_mmio_virtqueue_cleanup(QVirtQueue *vq,
190
                                           QGuestAllocator *alloc)
191
0
{
192
0
    guest_free(alloc, vq->desc);
193
0
    g_free(vq);
194
0
}
195
196
static void qvirtio_mmio_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
197
0
{
198
0
    QVirtioMMIODevice *dev = container_of(d, QVirtioMMIODevice, vdev);
199
0
    qtest_writel(dev->qts, dev->addr + QVIRTIO_MMIO_QUEUE_NOTIFY, vq->index);
200
0
}
201
202
const QVirtioBus qvirtio_mmio = {
203
    .config_readb = qvirtio_mmio_config_readb,
204
    .config_readw = qvirtio_mmio_config_readw,
205
    .config_readl = qvirtio_mmio_config_readl,
206
    .config_readq = qvirtio_mmio_config_readq,
207
    .get_features = qvirtio_mmio_get_features,
208
    .set_features = qvirtio_mmio_set_features,
209
    .get_guest_features = qvirtio_mmio_get_guest_features,
210
    .get_status = qvirtio_mmio_get_status,
211
    .set_status = qvirtio_mmio_set_status,
212
    .get_queue_isr_status = qvirtio_mmio_get_queue_isr_status,
213
    .wait_config_isr_status = qvirtio_mmio_wait_config_isr_status,
214
    .queue_select = qvirtio_mmio_queue_select,
215
    .get_queue_size = qvirtio_mmio_get_queue_size,
216
    .set_queue_address = qvirtio_mmio_set_queue_address,
217
    .virtqueue_setup = qvirtio_mmio_virtqueue_setup,
218
    .virtqueue_cleanup = qvirtio_mmio_virtqueue_cleanup,
219
    .virtqueue_kick = qvirtio_mmio_virtqueue_kick,
220
};
221
222
static void *qvirtio_mmio_get_driver(void *obj, const char *interface)
223
0
{
224
0
    QVirtioMMIODevice *virtio_mmio = obj;
225
0
    if (!g_strcmp0(interface, "virtio-bus")) {
226
0
        return &virtio_mmio->vdev;
227
0
    }
228
0
    fprintf(stderr, "%s not present in virtio-mmio\n", interface);
229
0
    g_assert_not_reached();
230
0
}
231
232
static void qvirtio_mmio_start_hw(QOSGraphObject *obj)
233
0
{
234
0
    QVirtioMMIODevice *dev = (QVirtioMMIODevice *) obj;
235
0
    qvirtio_start_device(&dev->vdev);
236
0
}
237
238
void qvirtio_mmio_init_device(QVirtioMMIODevice *dev, QTestState *qts,
239
                              uint64_t addr, uint32_t page_size)
240
0
{
241
0
    uint32_t magic;
242
0
    magic = qtest_readl(qts, addr + QVIRTIO_MMIO_MAGIC_VALUE);
243
0
    g_assert(magic == ('v' | 'i' << 8 | 'r' << 16 | 't' << 24));
244
245
0
    dev->version = qtest_readl(qts, addr + QVIRTIO_MMIO_VERSION);
246
0
    g_assert(dev->version == 1 || dev->version == 2);
247
248
0
    dev->qts = qts;
249
0
    dev->addr = addr;
250
0
    dev->page_size = page_size;
251
0
    dev->vdev.device_type = qtest_readl(qts, addr + QVIRTIO_MMIO_DEVICE_ID);
252
0
    dev->vdev.bus = &qvirtio_mmio;
253
254
0
    qtest_writel(qts, addr + QVIRTIO_MMIO_GUEST_PAGE_SIZE, page_size);
255
256
0
    dev->obj.get_driver = qvirtio_mmio_get_driver;
257
0
    dev->obj.start_hw = qvirtio_mmio_start_hw;
258
0
}
259
260
static void virtio_mmio_register_nodes(void)
261
63
{
262
    qos_node_create_driver("virtio-mmio", NULL);
263
63
    qos_node_produces("virtio-mmio", "virtio-bus");
264
63
}
265
266
libqos_init(virtio_mmio_register_nodes);