Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/hw/hyperv/hyperv_testdev.c
Line
Count
Source
1
/*
2
 * QEMU KVM Hyper-V test device to support Hyper-V kvm-unit-tests
3
 *
4
 * Copyright (C) 2015 Andrey Smetanin <asmetanin@virtuozzo.com>
5
 *
6
 * Authors:
7
 *  Andrey Smetanin <asmetanin@virtuozzo.com>
8
 *
9
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10
 * See the COPYING file in the top-level directory.
11
 *
12
 */
13
14
#include "qemu/osdep.h"
15
#include "qemu/main-loop.h"
16
#include "qemu/module.h"
17
#include "qemu/queue.h"
18
#include "hw/isa/isa.h"
19
#include "hw/hyperv/hyperv.h"
20
#include "qom/object.h"
21
22
typedef struct TestSintRoute {
23
    QLIST_ENTRY(TestSintRoute) le;
24
    uint8_t vp_index;
25
    uint8_t sint;
26
    HvSintRoute *sint_route;
27
} TestSintRoute;
28
29
typedef struct TestMsgConn {
30
    QLIST_ENTRY(TestMsgConn) le;
31
    uint8_t conn_id;
32
    HvSintRoute *sint_route;
33
    struct hyperv_message msg;
34
} TestMsgConn;
35
36
typedef struct TestEvtConn {
37
    QLIST_ENTRY(TestEvtConn) le;
38
    uint8_t conn_id;
39
    HvSintRoute *sint_route;
40
    EventNotifier notifier;
41
} TestEvtConn;
42
43
struct HypervTestDev {
44
    ISADevice parent_obj;
45
    MemoryRegion sint_control;
46
    QLIST_HEAD(, TestSintRoute) sint_routes;
47
    QLIST_HEAD(, TestMsgConn) msg_conns;
48
    QLIST_HEAD(, TestEvtConn) evt_conns;
49
};
50
51
#define TYPE_HYPERV_TEST_DEV "hyperv-testdev"
52
OBJECT_DECLARE_SIMPLE_TYPE(HypervTestDev, HYPERV_TEST_DEV)
53
54
enum {
55
    HV_TEST_DEV_SINT_ROUTE_CREATE = 1,
56
    HV_TEST_DEV_SINT_ROUTE_DESTROY,
57
    HV_TEST_DEV_SINT_ROUTE_SET_SINT,
58
    HV_TEST_DEV_MSG_CONN_CREATE,
59
    HV_TEST_DEV_MSG_CONN_DESTROY,
60
    HV_TEST_DEV_EVT_CONN_CREATE,
61
    HV_TEST_DEV_EVT_CONN_DESTROY,
62
};
63
64
static void sint_route_create(HypervTestDev *dev,
65
                              uint8_t vp_index, uint8_t sint)
66
0
{
67
0
    TestSintRoute *sint_route;
68
69
0
    sint_route = g_new0(TestSintRoute, 1);
70
0
    assert(sint_route);
71
72
0
    sint_route->vp_index = vp_index;
73
0
    sint_route->sint = sint;
74
75
0
    sint_route->sint_route = hyperv_sint_route_new(vp_index, sint, NULL, NULL);
76
0
    assert(sint_route->sint_route);
77
78
0
    QLIST_INSERT_HEAD(&dev->sint_routes, sint_route, le);
79
0
}
80
81
static TestSintRoute *sint_route_find(HypervTestDev *dev,
82
                                      uint8_t vp_index, uint8_t sint)
83
0
{
84
0
    TestSintRoute *sint_route;
85
86
0
    QLIST_FOREACH(sint_route, &dev->sint_routes, le) {
87
0
        if (sint_route->vp_index == vp_index && sint_route->sint == sint) {
88
0
            return sint_route;
89
0
        }
90
0
    }
91
0
    g_assert_not_reached();
92
0
}
93
94
static void sint_route_destroy(HypervTestDev *dev,
95
                               uint8_t vp_index, uint8_t sint)
96
0
{
97
0
    TestSintRoute *sint_route;
98
99
0
    sint_route = sint_route_find(dev, vp_index, sint);
100
0
    QLIST_REMOVE(sint_route, le);
101
0
    hyperv_sint_route_unref(sint_route->sint_route);
102
0
    g_free(sint_route);
103
0
}
104
105
static void sint_route_set_sint(HypervTestDev *dev,
106
                                uint8_t vp_index, uint8_t sint)
107
0
{
108
0
    TestSintRoute *sint_route;
109
110
0
    sint_route = sint_route_find(dev, vp_index, sint);
111
112
0
    hyperv_sint_route_set_sint(sint_route->sint_route);
113
0
}
114
115
static void msg_retry(void *opaque)
116
0
{
117
0
    TestMsgConn *conn = opaque;
118
0
    assert(!hyperv_post_msg(conn->sint_route, &conn->msg));
119
0
}
120
121
static void msg_cb(void *data, int status)
122
0
{
123
0
    TestMsgConn *conn = data;
124
125
0
    if (!status) {
126
0
        return;
127
0
    }
128
129
0
    assert(status == -EAGAIN);
130
131
0
    aio_bh_schedule_oneshot(qemu_get_aio_context(), msg_retry, conn);
132
0
}
133
134
static uint16_t msg_handler(const struct hyperv_post_message_input *msg,
135
                            void *data)
136
0
{
137
0
    int ret;
138
0
    TestMsgConn *conn = data;
139
140
    /* post the same message we've got */
141
0
    conn->msg.header.message_type = msg->message_type;
142
0
    assert(msg->payload_size < sizeof(conn->msg.payload));
143
0
    conn->msg.header.payload_size = msg->payload_size;
144
0
    memcpy(&conn->msg.payload, msg->payload, msg->payload_size);
145
146
0
    ret = hyperv_post_msg(conn->sint_route, &conn->msg);
147
148
0
    switch (ret) {
149
0
    case 0:
150
0
        return HV_STATUS_SUCCESS;
151
0
    case -EAGAIN:
152
0
        return HV_STATUS_INSUFFICIENT_BUFFERS;
153
0
    default:
154
0
        return HV_STATUS_INVALID_HYPERCALL_INPUT;
155
0
    }
156
0
}
157
158
static void msg_conn_create(HypervTestDev *dev, uint8_t vp_index,
159
                            uint8_t sint, uint8_t conn_id)
160
0
{
161
0
    TestMsgConn *conn;
162
163
0
    conn = g_new0(TestMsgConn, 1);
164
0
    assert(conn);
165
166
0
    conn->conn_id = conn_id;
167
168
0
    conn->sint_route = hyperv_sint_route_new(vp_index, sint, msg_cb, conn);
169
0
    assert(conn->sint_route);
170
171
0
    assert(!hyperv_set_msg_handler(conn->conn_id, msg_handler, conn));
172
173
0
    QLIST_INSERT_HEAD(&dev->msg_conns, conn, le);
174
0
}
175
176
static void msg_conn_destroy(HypervTestDev *dev, uint8_t conn_id)
177
0
{
178
0
    TestMsgConn *conn;
179
180
0
    QLIST_FOREACH(conn, &dev->msg_conns, le) {
181
0
        if (conn->conn_id == conn_id) {
182
0
            QLIST_REMOVE(conn, le);
183
0
            hyperv_set_msg_handler(conn->conn_id, NULL, NULL);
184
0
            hyperv_sint_route_unref(conn->sint_route);
185
0
            g_free(conn);
186
0
            return;
187
0
        }
188
0
    }
189
0
    g_assert_not_reached();
190
0
}
191
192
static void evt_conn_handler(EventNotifier *notifier)
193
0
{
194
0
    TestEvtConn *conn = container_of(notifier, TestEvtConn, notifier);
195
196
0
    event_notifier_test_and_clear(notifier);
197
198
    /* signal the same event flag we've got */
199
0
    assert(!hyperv_set_event_flag(conn->sint_route, conn->conn_id));
200
0
}
201
202
static void evt_conn_create(HypervTestDev *dev, uint8_t vp_index,
203
                            uint8_t sint, uint8_t conn_id)
204
0
{
205
0
    TestEvtConn *conn;
206
207
0
    conn = g_new0(TestEvtConn, 1);
208
0
    assert(conn);
209
210
0
    conn->conn_id = conn_id;
211
212
0
    conn->sint_route = hyperv_sint_route_new(vp_index, sint, NULL, NULL);
213
0
    assert(conn->sint_route);
214
215
0
    assert(!event_notifier_init(&conn->notifier, false));
216
217
0
    event_notifier_set_handler(&conn->notifier, evt_conn_handler);
218
219
0
    assert(!hyperv_set_event_flag_handler(conn_id, &conn->notifier));
220
221
0
    QLIST_INSERT_HEAD(&dev->evt_conns, conn, le);
222
0
}
223
224
static void evt_conn_destroy(HypervTestDev *dev, uint8_t conn_id)
225
0
{
226
0
    TestEvtConn *conn;
227
228
0
    QLIST_FOREACH(conn, &dev->evt_conns, le) {
229
0
        if (conn->conn_id == conn_id) {
230
0
            QLIST_REMOVE(conn, le);
231
0
            hyperv_set_event_flag_handler(conn->conn_id, NULL);
232
0
            event_notifier_set_handler(&conn->notifier, NULL);
233
0
            event_notifier_cleanup(&conn->notifier);
234
0
            hyperv_sint_route_unref(conn->sint_route);
235
0
            g_free(conn);
236
0
            return;
237
0
        }
238
0
    }
239
0
    g_assert_not_reached();
240
0
}
241
242
static uint64_t hv_test_dev_read(void *opaque, hwaddr addr, unsigned size)
243
0
{
244
0
    return 0;
245
0
}
246
247
static void hv_test_dev_write(void *opaque, hwaddr addr, uint64_t data,
248
                                uint32_t len)
249
0
{
250
0
    HypervTestDev *dev = HYPERV_TEST_DEV(opaque);
251
0
    uint8_t sint = data & 0xFF;
252
0
    uint8_t vp_index = (data >> 8ULL) & 0xFF;
253
0
    uint8_t ctl = (data >> 16ULL) & 0xFF;
254
0
    uint8_t conn_id = (data >> 24ULL) & 0xFF;
255
256
0
    switch (ctl) {
257
0
    case HV_TEST_DEV_SINT_ROUTE_CREATE:
258
0
        sint_route_create(dev, vp_index, sint);
259
0
        break;
260
0
    case HV_TEST_DEV_SINT_ROUTE_DESTROY:
261
0
        sint_route_destroy(dev, vp_index, sint);
262
0
        break;
263
0
    case HV_TEST_DEV_SINT_ROUTE_SET_SINT:
264
0
        sint_route_set_sint(dev, vp_index, sint);
265
0
        break;
266
0
    case HV_TEST_DEV_MSG_CONN_CREATE:
267
0
        msg_conn_create(dev, vp_index, sint, conn_id);
268
0
        break;
269
0
    case HV_TEST_DEV_MSG_CONN_DESTROY:
270
0
        msg_conn_destroy(dev, conn_id);
271
0
        break;
272
0
    case HV_TEST_DEV_EVT_CONN_CREATE:
273
0
        evt_conn_create(dev, vp_index, sint, conn_id);
274
0
        break;
275
0
    case HV_TEST_DEV_EVT_CONN_DESTROY:
276
0
        evt_conn_destroy(dev, conn_id);
277
0
        break;
278
0
    default:
279
0
        break;
280
0
    }
281
0
}
282
283
static const MemoryRegionOps synic_test_sint_ops = {
284
    .read = hv_test_dev_read,
285
    .write = hv_test_dev_write,
286
    .valid.min_access_size = 4,
287
    .valid.max_access_size = 4,
288
    .endianness = DEVICE_LITTLE_ENDIAN,
289
};
290
291
static void hv_test_dev_realizefn(DeviceState *d, Error **errp)
292
0
{
293
0
    ISADevice *isa = ISA_DEVICE(d);
294
0
    HypervTestDev *dev = HYPERV_TEST_DEV(d);
295
0
    MemoryRegion *io = isa_address_space_io(isa);
296
297
0
    QLIST_INIT(&dev->sint_routes);
298
0
    QLIST_INIT(&dev->msg_conns);
299
0
    QLIST_INIT(&dev->evt_conns);
300
0
    memory_region_init_io(&dev->sint_control, OBJECT(dev),
301
0
                          &synic_test_sint_ops, dev,
302
0
                          "hyperv-testdev-ctl", 4);
303
0
    memory_region_add_subregion(io, 0x3000, &dev->sint_control);
304
0
}
305
306
static void hv_test_dev_class_init(ObjectClass *klass, const void *data)
307
63
{
308
63
    DeviceClass *dc = DEVICE_CLASS(klass);
309
310
63
    set_bit(DEVICE_CATEGORY_MISC, dc->categories);
311
63
    dc->realize = hv_test_dev_realizefn;
312
63
}
313
314
static const TypeInfo hv_test_dev_info = {
315
    .name           = TYPE_HYPERV_TEST_DEV,
316
    .parent         = TYPE_ISA_DEVICE,
317
    .instance_size  = sizeof(HypervTestDev),
318
    .class_init     = hv_test_dev_class_init,
319
};
320
321
static void hv_test_dev_register_types(void)
322
63
{
323
63
    type_register_static(&hv_test_dev_info);
324
63
}
325
type_init(hv_test_dev_register_types);