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