]>
Commit | Line | Data |
---|---|---|
821d28b8 MP |
1 | /* |
2 | * Vhost-user RNG virtio device | |
3 | * | |
4 | * Copyright (c) 2021 Mathieu Poirier <mathieu.poirier@linaro.org> | |
5 | * | |
6 | * Implementation seriously tailored on vhost-user-i2c.c | |
7 | * | |
8 | * SPDX-License-Identifier: GPL-2.0-or-later | |
9 | */ | |
10 | ||
11 | #include "qemu/osdep.h" | |
12 | #include "qapi/error.h" | |
13 | #include "hw/qdev-properties.h" | |
14 | #include "hw/virtio/virtio-bus.h" | |
15 | #include "hw/virtio/vhost-user-rng.h" | |
16 | #include "qemu/error-report.h" | |
17 | #include "standard-headers/linux/virtio_ids.h" | |
18 | ||
562a7d23 SG |
19 | static const int feature_bits[] = { |
20 | VIRTIO_F_RING_RESET, | |
21 | VHOST_INVALID_FEATURE_BIT | |
22 | }; | |
23 | ||
821d28b8 MP |
24 | static void vu_rng_start(VirtIODevice *vdev) |
25 | { | |
26 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
27 | BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev))); | |
28 | VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus); | |
29 | int ret; | |
30 | int i; | |
31 | ||
32 | if (!k->set_guest_notifiers) { | |
33 | error_report("binding does not support guest notifiers"); | |
34 | return; | |
35 | } | |
36 | ||
37 | ret = vhost_dev_enable_notifiers(&rng->vhost_dev, vdev); | |
38 | if (ret < 0) { | |
39 | error_report("Error enabling host notifiers: %d", -ret); | |
40 | return; | |
41 | } | |
42 | ||
43 | ret = k->set_guest_notifiers(qbus->parent, rng->vhost_dev.nvqs, true); | |
44 | if (ret < 0) { | |
45 | error_report("Error binding guest notifier: %d", -ret); | |
46 | goto err_host_notifiers; | |
47 | } | |
48 | ||
49 | rng->vhost_dev.acked_features = vdev->guest_features; | |
4daa5054 | 50 | ret = vhost_dev_start(&rng->vhost_dev, vdev, true); |
821d28b8 MP |
51 | if (ret < 0) { |
52 | error_report("Error starting vhost-user-rng: %d", -ret); | |
53 | goto err_guest_notifiers; | |
54 | } | |
55 | ||
56 | /* | |
57 | * guest_notifier_mask/pending not used yet, so just unmask | |
58 | * everything here. virtio-pci will do the right thing by | |
59 | * enabling/disabling irqfd. | |
60 | */ | |
61 | for (i = 0; i < rng->vhost_dev.nvqs; i++) { | |
62 | vhost_virtqueue_mask(&rng->vhost_dev, vdev, i, false); | |
63 | } | |
64 | ||
65 | return; | |
66 | ||
67 | err_guest_notifiers: | |
68 | k->set_guest_notifiers(qbus->parent, rng->vhost_dev.nvqs, false); | |
69 | err_host_notifiers: | |
70 | vhost_dev_disable_notifiers(&rng->vhost_dev, vdev); | |
71 | } | |
72 | ||
73 | static void vu_rng_stop(VirtIODevice *vdev) | |
74 | { | |
75 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
76 | BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev))); | |
77 | VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus); | |
78 | int ret; | |
79 | ||
80 | if (!k->set_guest_notifiers) { | |
81 | return; | |
82 | } | |
83 | ||
4daa5054 | 84 | vhost_dev_stop(&rng->vhost_dev, vdev, true); |
821d28b8 MP |
85 | |
86 | ret = k->set_guest_notifiers(qbus->parent, rng->vhost_dev.nvqs, false); | |
87 | if (ret < 0) { | |
88 | error_report("vhost guest notifier cleanup failed: %d", ret); | |
89 | return; | |
90 | } | |
91 | ||
92 | vhost_dev_disable_notifiers(&rng->vhost_dev, vdev); | |
93 | } | |
94 | ||
95 | static void vu_rng_set_status(VirtIODevice *vdev, uint8_t status) | |
96 | { | |
97 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
259d69c0 | 98 | bool should_start = virtio_device_should_start(vdev, status); |
821d28b8 | 99 | |
b8f3e6a1 | 100 | if (vhost_dev_is_started(&rng->vhost_dev) == should_start) { |
821d28b8 MP |
101 | return; |
102 | } | |
103 | ||
104 | if (should_start) { | |
105 | vu_rng_start(vdev); | |
106 | } else { | |
107 | vu_rng_stop(vdev); | |
108 | } | |
109 | } | |
110 | ||
111 | static uint64_t vu_rng_get_features(VirtIODevice *vdev, | |
112 | uint64_t requested_features, Error **errp) | |
113 | { | |
562a7d23 SG |
114 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); |
115 | ||
116 | return vhost_get_features(&rng->vhost_dev, feature_bits, | |
117 | requested_features); | |
821d28b8 MP |
118 | } |
119 | ||
120 | static void vu_rng_handle_output(VirtIODevice *vdev, VirtQueue *vq) | |
121 | { | |
122 | /* | |
123 | * Not normally called; it's the daemon that handles the queue; | |
124 | * however virtio's cleanup path can call this. | |
125 | */ | |
126 | } | |
127 | ||
128 | static void vu_rng_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask) | |
129 | { | |
130 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
131 | ||
132 | vhost_virtqueue_mask(&rng->vhost_dev, vdev, idx, mask); | |
133 | } | |
134 | ||
135 | static bool vu_rng_guest_notifier_pending(VirtIODevice *vdev, int idx) | |
136 | { | |
137 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
138 | ||
139 | return vhost_virtqueue_pending(&rng->vhost_dev, idx); | |
140 | } | |
141 | ||
142 | static void vu_rng_connect(DeviceState *dev) | |
143 | { | |
144 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); | |
145 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
146 | ||
147 | if (rng->connected) { | |
148 | return; | |
149 | } | |
150 | ||
151 | rng->connected = true; | |
152 | ||
153 | /* restore vhost state */ | |
154 | if (virtio_device_started(vdev, vdev->status)) { | |
155 | vu_rng_start(vdev); | |
156 | } | |
157 | } | |
158 | ||
159 | static void vu_rng_disconnect(DeviceState *dev) | |
160 | { | |
161 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); | |
162 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
163 | ||
164 | if (!rng->connected) { | |
165 | return; | |
166 | } | |
167 | ||
168 | rng->connected = false; | |
169 | ||
b8f3e6a1 | 170 | if (vhost_dev_is_started(&rng->vhost_dev)) { |
821d28b8 MP |
171 | vu_rng_stop(vdev); |
172 | } | |
173 | } | |
174 | ||
175 | static void vu_rng_event(void *opaque, QEMUChrEvent event) | |
176 | { | |
177 | DeviceState *dev = opaque; | |
178 | ||
179 | switch (event) { | |
180 | case CHR_EVENT_OPENED: | |
181 | vu_rng_connect(dev); | |
182 | break; | |
183 | case CHR_EVENT_CLOSED: | |
184 | vu_rng_disconnect(dev); | |
185 | break; | |
186 | case CHR_EVENT_BREAK: | |
187 | case CHR_EVENT_MUX_IN: | |
188 | case CHR_EVENT_MUX_OUT: | |
189 | /* Ignore */ | |
190 | break; | |
191 | } | |
192 | } | |
193 | ||
194 | static void vu_rng_device_realize(DeviceState *dev, Error **errp) | |
195 | { | |
196 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); | |
197 | VHostUserRNG *rng = VHOST_USER_RNG(dev); | |
198 | int ret; | |
199 | ||
200 | if (!rng->chardev.chr) { | |
201 | error_setg(errp, "missing chardev"); | |
202 | return; | |
203 | } | |
204 | ||
205 | if (!vhost_user_init(&rng->vhost_user, &rng->chardev, errp)) { | |
206 | return; | |
207 | } | |
208 | ||
3857cd5c | 209 | virtio_init(vdev, VIRTIO_ID_RNG, 0); |
821d28b8 MP |
210 | |
211 | rng->req_vq = virtio_add_queue(vdev, 4, vu_rng_handle_output); | |
212 | if (!rng->req_vq) { | |
213 | error_setg_errno(errp, -1, "virtio_add_queue() failed"); | |
214 | goto virtio_add_queue_failed; | |
215 | } | |
216 | ||
217 | rng->vhost_dev.nvqs = 1; | |
218 | rng->vhost_dev.vqs = g_new0(struct vhost_virtqueue, rng->vhost_dev.nvqs); | |
219 | ret = vhost_dev_init(&rng->vhost_dev, &rng->vhost_user, | |
220 | VHOST_BACKEND_TYPE_USER, 0, errp); | |
221 | if (ret < 0) { | |
222 | error_setg_errno(errp, -ret, "vhost_dev_init() failed"); | |
223 | goto vhost_dev_init_failed; | |
224 | } | |
225 | ||
226 | qemu_chr_fe_set_handlers(&rng->chardev, NULL, NULL, vu_rng_event, NULL, | |
227 | dev, NULL, true); | |
228 | ||
229 | return; | |
230 | ||
231 | vhost_dev_init_failed: | |
f0dac715 | 232 | g_free(rng->vhost_dev.vqs); |
821d28b8 MP |
233 | virtio_delete_queue(rng->req_vq); |
234 | virtio_add_queue_failed: | |
235 | virtio_cleanup(vdev); | |
236 | vhost_user_cleanup(&rng->vhost_user); | |
237 | } | |
238 | ||
239 | static void vu_rng_device_unrealize(DeviceState *dev) | |
240 | { | |
241 | VirtIODevice *vdev = VIRTIO_DEVICE(dev); | |
242 | VHostUserRNG *rng = VHOST_USER_RNG(dev); | |
f0dac715 | 243 | struct vhost_virtqueue *vhost_vqs = rng->vhost_dev.vqs; |
821d28b8 MP |
244 | |
245 | vu_rng_set_status(vdev, 0); | |
246 | ||
247 | vhost_dev_cleanup(&rng->vhost_dev); | |
f0dac715 | 248 | g_free(vhost_vqs); |
821d28b8 MP |
249 | virtio_delete_queue(rng->req_vq); |
250 | virtio_cleanup(vdev); | |
251 | vhost_user_cleanup(&rng->vhost_user); | |
252 | } | |
253 | ||
c255488d JP |
254 | static struct vhost_dev *vu_rng_get_vhost(VirtIODevice *vdev) |
255 | { | |
256 | VHostUserRNG *rng = VHOST_USER_RNG(vdev); | |
257 | return &rng->vhost_dev; | |
258 | } | |
259 | ||
821d28b8 MP |
260 | static const VMStateDescription vu_rng_vmstate = { |
261 | .name = "vhost-user-rng", | |
262 | .unmigratable = 1, | |
263 | }; | |
264 | ||
265 | static Property vu_rng_properties[] = { | |
266 | DEFINE_PROP_CHR("chardev", VHostUserRNG, chardev), | |
267 | DEFINE_PROP_END_OF_LIST(), | |
268 | }; | |
269 | ||
270 | static void vu_rng_class_init(ObjectClass *klass, void *data) | |
271 | { | |
272 | DeviceClass *dc = DEVICE_CLASS(klass); | |
273 | VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); | |
274 | ||
275 | device_class_set_props(dc, vu_rng_properties); | |
276 | dc->vmsd = &vu_rng_vmstate; | |
277 | set_bit(DEVICE_CATEGORY_INPUT, dc->categories); | |
278 | ||
279 | vdc->realize = vu_rng_device_realize; | |
280 | vdc->unrealize = vu_rng_device_unrealize; | |
281 | vdc->get_features = vu_rng_get_features; | |
282 | vdc->set_status = vu_rng_set_status; | |
283 | vdc->guest_notifier_mask = vu_rng_guest_notifier_mask; | |
284 | vdc->guest_notifier_pending = vu_rng_guest_notifier_pending; | |
c255488d | 285 | vdc->get_vhost = vu_rng_get_vhost; |
821d28b8 MP |
286 | } |
287 | ||
288 | static const TypeInfo vu_rng_info = { | |
289 | .name = TYPE_VHOST_USER_RNG, | |
290 | .parent = TYPE_VIRTIO_DEVICE, | |
291 | .instance_size = sizeof(VHostUserRNG), | |
292 | .class_init = vu_rng_class_init, | |
293 | }; | |
294 | ||
295 | static void vu_rng_register_types(void) | |
296 | { | |
297 | type_register_static(&vu_rng_info); | |
298 | } | |
299 | ||
300 | type_init(vu_rng_register_types) |