1 /*
2 * Vhost Vdpa Device
3 *
4 * Copyright (c) Huawei Technologies Co., Ltd. 2022. All Rights Reserved.
5 *
6 * Authors:
7 * Longpeng <longpeng2@huawei.com>
8 *
9 * Largely based on the "vhost-user-blk-pci.c" and "vhost-user-blk.c"
10 * implemented by:
11 * Changpeng Liu <changpeng.liu@intel.com>
12 *
13 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
14 * See the COPYING.LIB file in the top-level directory.
15 */
16 #include "qemu/osdep.h"
17 #include <sys/ioctl.h>
18 #include <linux/vhost.h>
19 #include "qapi/error.h"
20 #include "qemu/error-report.h"
21 #include "qemu/cutils.h"
22 #include "hw/qdev-core.h"
23 #include "hw/qdev-properties.h"
24 #include "hw/qdev-properties-system.h"
25 #include "hw/virtio/vhost.h"
26 #include "hw/virtio/virtio.h"
27 #include "hw/virtio/virtio-bus.h"
28 #include "hw/virtio/vdpa-dev.h"
29 #include "sysemu/sysemu.h"
30 #include "sysemu/runstate.h"
31
32 static void
vhost_vdpa_device_dummy_handle_output(VirtIODevice * vdev,VirtQueue * vq)33 vhost_vdpa_device_dummy_handle_output(VirtIODevice *vdev, VirtQueue *vq)
34 {
35 /* Nothing to do */
36 }
37
38 static uint32_t
vhost_vdpa_device_get_u32(int fd,unsigned long int cmd,Error ** errp)39 vhost_vdpa_device_get_u32(int fd, unsigned long int cmd, Error **errp)
40 {
41 uint32_t val = (uint32_t)-1;
42
43 if (ioctl(fd, cmd, &val) < 0) {
44 error_setg(errp, "vhost-vdpa-device: cmd 0x%lx failed: %s",
45 cmd, strerror(errno));
46 }
47
48 return val;
49 }
50
vhost_vdpa_device_realize(DeviceState * dev,Error ** errp)51 static void vhost_vdpa_device_realize(DeviceState *dev, Error **errp)
52 {
53 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
54 VhostVdpaDevice *v = VHOST_VDPA_DEVICE(vdev);
55 struct vhost_vdpa_iova_range iova_range;
56 uint16_t max_queue_size;
57 struct vhost_virtqueue *vqs;
58 int i, ret;
59
60 if (!v->vhostdev) {
61 error_setg(errp, "vhost-vdpa-device: vhostdev are missing");
62 return;
63 }
64
65 v->vhostfd = qemu_open(v->vhostdev, O_RDWR, errp);
66 if (*errp) {
67 return;
68 }
69 v->vdpa.device_fd = v->vhostfd;
70
71 v->vdev_id = vhost_vdpa_device_get_u32(v->vhostfd,
72 VHOST_VDPA_GET_DEVICE_ID, errp);
73 if (*errp) {
74 goto out;
75 }
76
77 max_queue_size = vhost_vdpa_device_get_u32(v->vhostfd,
78 VHOST_VDPA_GET_VRING_NUM, errp);
79 if (*errp) {
80 goto out;
81 }
82
83 if (v->queue_size > max_queue_size) {
84 error_setg(errp, "vhost-vdpa-device: invalid queue_size: %u (max:%u)",
85 v->queue_size, max_queue_size);
86 goto out;
87 } else if (!v->queue_size) {
88 v->queue_size = max_queue_size;
89 }
90
91 v->num_queues = vhost_vdpa_device_get_u32(v->vhostfd,
92 VHOST_VDPA_GET_VQS_COUNT, errp);
93 if (*errp) {
94 goto out;
95 }
96
97 if (!v->num_queues || v->num_queues > VIRTIO_QUEUE_MAX) {
98 error_setg(errp, "invalid number of virtqueues: %u (max:%u)",
99 v->num_queues, VIRTIO_QUEUE_MAX);
100 goto out;
101 }
102
103 v->dev.nvqs = v->num_queues;
104 vqs = g_new0(struct vhost_virtqueue, v->dev.nvqs);
105 v->dev.vqs = vqs;
106 v->dev.vq_index = 0;
107 v->dev.vq_index_end = v->dev.nvqs;
108 v->dev.backend_features = 0;
109 v->started = false;
110
111 ret = vhost_vdpa_get_iova_range(v->vhostfd, &iova_range);
112 if (ret < 0) {
113 error_setg(errp, "vhost-vdpa-device: get iova range failed: %s",
114 strerror(-ret));
115 goto free_vqs;
116 }
117 v->vdpa.iova_range = iova_range;
118
119 ret = vhost_dev_init(&v->dev, &v->vdpa, VHOST_BACKEND_TYPE_VDPA, 0, NULL);
120 if (ret < 0) {
121 error_setg(errp, "vhost-vdpa-device: vhost initialization failed: %s",
122 strerror(-ret));
123 goto free_vqs;
124 }
125
126 v->config_size = vhost_vdpa_device_get_u32(v->vhostfd,
127 VHOST_VDPA_GET_CONFIG_SIZE,
128 errp);
129 if (*errp) {
130 goto vhost_cleanup;
131 }
132
133 /*
134 * Invoke .post_init() to initialize the transport-specific fields
135 * before calling virtio_init().
136 */
137 if (v->post_init && v->post_init(v, errp) < 0) {
138 goto vhost_cleanup;
139 }
140
141 v->config = g_malloc0(v->config_size);
142
143 ret = vhost_dev_get_config(&v->dev, v->config, v->config_size, NULL);
144 if (ret < 0) {
145 error_setg(errp, "vhost-vdpa-device: get config failed");
146 goto free_config;
147 }
148
149 virtio_init(vdev, v->vdev_id, v->config_size);
150
151 v->virtqs = g_new0(VirtQueue *, v->dev.nvqs);
152 for (i = 0; i < v->dev.nvqs; i++) {
153 v->virtqs[i] = virtio_add_queue(vdev, v->queue_size,
154 vhost_vdpa_device_dummy_handle_output);
155 }
156
157 return;
158
159 free_config:
160 g_free(v->config);
161 vhost_cleanup:
162 vhost_dev_cleanup(&v->dev);
163 free_vqs:
164 g_free(vqs);
165 out:
166 qemu_close(v->vhostfd);
167 v->vhostfd = -1;
168 }
169
vhost_vdpa_device_unrealize(DeviceState * dev)170 static void vhost_vdpa_device_unrealize(DeviceState *dev)
171 {
172 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
173 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
174 int i;
175
176 virtio_set_status(vdev, 0);
177
178 for (i = 0; i < s->num_queues; i++) {
179 virtio_delete_queue(s->virtqs[i]);
180 }
181 g_free(s->virtqs);
182 virtio_cleanup(vdev);
183
184 g_free(s->config);
185 g_free(s->dev.vqs);
186 vhost_dev_cleanup(&s->dev);
187 qemu_close(s->vhostfd);
188 s->vhostfd = -1;
189 }
190
191 static void
vhost_vdpa_device_get_config(VirtIODevice * vdev,uint8_t * config)192 vhost_vdpa_device_get_config(VirtIODevice *vdev, uint8_t *config)
193 {
194 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
195
196 memcpy(config, s->config, s->config_size);
197 }
198
199 static void
vhost_vdpa_device_set_config(VirtIODevice * vdev,const uint8_t * config)200 vhost_vdpa_device_set_config(VirtIODevice *vdev, const uint8_t *config)
201 {
202 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
203 int ret;
204
205 ret = vhost_dev_set_config(&s->dev, s->config, 0, s->config_size,
206 VHOST_SET_CONFIG_TYPE_FRONTEND);
207 if (ret) {
208 error_report("set device config space failed");
209 return;
210 }
211 }
212
vhost_vdpa_device_get_features(VirtIODevice * vdev,uint64_t features,Error ** errp)213 static uint64_t vhost_vdpa_device_get_features(VirtIODevice *vdev,
214 uint64_t features,
215 Error **errp)
216 {
217 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
218 uint64_t backend_features = s->dev.features;
219
220 if (!virtio_has_feature(features, VIRTIO_F_IOMMU_PLATFORM)) {
221 virtio_clear_feature(&backend_features, VIRTIO_F_IOMMU_PLATFORM);
222 }
223
224 return backend_features;
225 }
226
vhost_vdpa_device_start(VirtIODevice * vdev,Error ** errp)227 static int vhost_vdpa_device_start(VirtIODevice *vdev, Error **errp)
228 {
229 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
230 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
231 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
232 int i, ret;
233
234 if (!k->set_guest_notifiers) {
235 error_setg(errp, "binding does not support guest notifiers");
236 return -ENOSYS;
237 }
238
239 ret = vhost_dev_enable_notifiers(&s->dev, vdev);
240 if (ret < 0) {
241 error_setg_errno(errp, -ret, "Error enabling host notifiers");
242 return ret;
243 }
244
245 ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, true);
246 if (ret < 0) {
247 error_setg_errno(errp, -ret, "Error binding guest notifier");
248 goto err_host_notifiers;
249 }
250
251 s->dev.acked_features = vdev->guest_features;
252
253 ret = vhost_dev_start(&s->dev, vdev, false);
254 if (ret < 0) {
255 error_setg_errno(errp, -ret, "Error starting vhost");
256 goto err_guest_notifiers;
257 }
258 for (i = 0; i < s->dev.nvqs; ++i) {
259 vhost_vdpa_set_vring_ready(&s->vdpa, i);
260 }
261 s->started = true;
262
263 /*
264 * guest_notifier_mask/pending not used yet, so just unmask
265 * everything here. virtio-pci will do the right thing by
266 * enabling/disabling irqfd.
267 */
268 for (i = 0; i < s->dev.nvqs; i++) {
269 vhost_virtqueue_mask(&s->dev, vdev, i, false);
270 }
271
272 return ret;
273
274 err_guest_notifiers:
275 k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
276 err_host_notifiers:
277 vhost_dev_disable_notifiers(&s->dev, vdev);
278 return ret;
279 }
280
vhost_vdpa_device_stop(VirtIODevice * vdev)281 static void vhost_vdpa_device_stop(VirtIODevice *vdev)
282 {
283 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
284 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
285 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
286 int ret;
287
288 if (!s->started) {
289 return;
290 }
291 s->started = false;
292
293 if (!k->set_guest_notifiers) {
294 return;
295 }
296
297 vhost_dev_stop(&s->dev, vdev, false);
298
299 ret = k->set_guest_notifiers(qbus->parent, s->dev.nvqs, false);
300 if (ret < 0) {
301 error_report("vhost guest notifier cleanup failed: %d", ret);
302 return;
303 }
304
305 vhost_dev_disable_notifiers(&s->dev, vdev);
306 }
307
vhost_vdpa_device_set_status(VirtIODevice * vdev,uint8_t status)308 static void vhost_vdpa_device_set_status(VirtIODevice *vdev, uint8_t status)
309 {
310 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(vdev);
311 bool should_start = virtio_device_started(vdev, status);
312 Error *local_err = NULL;
313 int ret;
314
315 if (!vdev->vm_running) {
316 should_start = false;
317 }
318
319 if (s->started == should_start) {
320 return;
321 }
322
323 if (should_start) {
324 ret = vhost_vdpa_device_start(vdev, &local_err);
325 if (ret < 0) {
326 error_reportf_err(local_err, "vhost-vdpa-device: start failed: ");
327 }
328 } else {
329 vhost_vdpa_device_stop(vdev);
330 }
331 }
332
333 static Property vhost_vdpa_device_properties[] = {
334 DEFINE_PROP_STRING("vhostdev", VhostVdpaDevice, vhostdev),
335 DEFINE_PROP_UINT16("queue-size", VhostVdpaDevice, queue_size, 0),
336 DEFINE_PROP_END_OF_LIST(),
337 };
338
339 static const VMStateDescription vmstate_vhost_vdpa_device = {
340 .name = "vhost-vdpa-device",
341 .unmigratable = 1,
342 .minimum_version_id = 1,
343 .version_id = 1,
344 .fields = (VMStateField[]) {
345 VMSTATE_VIRTIO_DEVICE,
346 VMSTATE_END_OF_LIST()
347 },
348 };
349
vhost_vdpa_device_class_init(ObjectClass * klass,void * data)350 static void vhost_vdpa_device_class_init(ObjectClass *klass, void *data)
351 {
352 DeviceClass *dc = DEVICE_CLASS(klass);
353 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
354
355 device_class_set_props(dc, vhost_vdpa_device_properties);
356 dc->desc = "VDPA-based generic device assignment";
357 dc->vmsd = &vmstate_vhost_vdpa_device;
358 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
359 vdc->realize = vhost_vdpa_device_realize;
360 vdc->unrealize = vhost_vdpa_device_unrealize;
361 vdc->get_config = vhost_vdpa_device_get_config;
362 vdc->set_config = vhost_vdpa_device_set_config;
363 vdc->get_features = vhost_vdpa_device_get_features;
364 vdc->set_status = vhost_vdpa_device_set_status;
365 }
366
vhost_vdpa_device_instance_init(Object * obj)367 static void vhost_vdpa_device_instance_init(Object *obj)
368 {
369 VhostVdpaDevice *s = VHOST_VDPA_DEVICE(obj);
370
371 device_add_bootindex_property(obj, &s->bootindex, "bootindex",
372 NULL, DEVICE(obj));
373 }
374
375 static const TypeInfo vhost_vdpa_device_info = {
376 .name = TYPE_VHOST_VDPA_DEVICE,
377 .parent = TYPE_VIRTIO_DEVICE,
378 .instance_size = sizeof(VhostVdpaDevice),
379 .class_init = vhost_vdpa_device_class_init,
380 .instance_init = vhost_vdpa_device_instance_init,
381 };
382
register_vhost_vdpa_device_type(void)383 static void register_vhost_vdpa_device_type(void)
384 {
385 type_register_static(&vhost_vdpa_device_info);
386 }
387
388 type_init(register_vhost_vdpa_device_type);
389