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