1
2
3
4
5
6
7
8
9
10
11#include "qemu/osdep.h"
12#include "hw/virtio/vhost.h"
13#include "hw/virtio/vhost-backend.h"
14#include "qemu/error-report.h"
15#include "qemu/main-loop.h"
16#include "standard-headers/linux/vhost_types.h"
17
18#ifdef CONFIG_VHOST_KERNEL
19#include <linux/vhost.h>
20#include <sys/ioctl.h>
21
22static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int request,
23 void *arg)
24{
25 int fd = (uintptr_t) dev->opaque;
26
27 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
28
29 return ioctl(fd, request, arg);
30}
31
32static int vhost_kernel_init(struct vhost_dev *dev, void *opaque)
33{
34 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
35
36 dev->opaque = opaque;
37
38 return 0;
39}
40
41static int vhost_kernel_cleanup(struct vhost_dev *dev)
42{
43 int fd = (uintptr_t) dev->opaque;
44
45 assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
46
47 return close(fd);
48}
49
50static int vhost_kernel_memslots_limit(struct vhost_dev *dev)
51{
52 int limit = 64;
53 char *s;
54
55 if (g_file_get_contents("/sys/module/vhost/parameters/max_mem_regions",
56 &s, NULL, NULL)) {
57 uint64_t val = g_ascii_strtoull(s, NULL, 10);
58 if (!((val == G_MAXUINT64 || !val) && errno)) {
59 g_free(s);
60 return val;
61 }
62 error_report("ignoring invalid max_mem_regions value in vhost module:"
63 " %s", s);
64 }
65 g_free(s);
66 return limit;
67}
68
69static int vhost_kernel_net_set_backend(struct vhost_dev *dev,
70 struct vhost_vring_file *file)
71{
72 return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
73}
74
75static int vhost_kernel_scsi_set_endpoint(struct vhost_dev *dev,
76 struct vhost_scsi_target *target)
77{
78 return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
79}
80
81static int vhost_kernel_scsi_clear_endpoint(struct vhost_dev *dev,
82 struct vhost_scsi_target *target)
83{
84 return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
85}
86
87static int vhost_kernel_scsi_get_abi_version(struct vhost_dev *dev, int *version)
88{
89 return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
90}
91
92static int vhost_kernel_set_log_base(struct vhost_dev *dev, uint64_t base,
93 struct vhost_log *log)
94{
95 return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
96}
97
98static int vhost_kernel_set_mem_table(struct vhost_dev *dev,
99 struct vhost_memory *mem)
100{
101 return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
102}
103
104static int vhost_kernel_set_vring_addr(struct vhost_dev *dev,
105 struct vhost_vring_addr *addr)
106{
107 return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
108}
109
110static int vhost_kernel_set_vring_endian(struct vhost_dev *dev,
111 struct vhost_vring_state *ring)
112{
113 return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
114}
115
116static int vhost_kernel_set_vring_num(struct vhost_dev *dev,
117 struct vhost_vring_state *ring)
118{
119 return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
120}
121
122static int vhost_kernel_set_vring_base(struct vhost_dev *dev,
123 struct vhost_vring_state *ring)
124{
125 return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
126}
127
128static int vhost_kernel_get_vring_base(struct vhost_dev *dev,
129 struct vhost_vring_state *ring)
130{
131 return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
132}
133
134static int vhost_kernel_set_vring_kick(struct vhost_dev *dev,
135 struct vhost_vring_file *file)
136{
137 return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
138}
139
140static int vhost_kernel_set_vring_call(struct vhost_dev *dev,
141 struct vhost_vring_file *file)
142{
143 return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
144}
145
146static int vhost_kernel_set_vring_busyloop_timeout(struct vhost_dev *dev,
147 struct vhost_vring_state *s)
148{
149 return vhost_kernel_call(dev, VHOST_SET_VRING_BUSYLOOP_TIMEOUT, s);
150}
151
152static int vhost_kernel_set_features(struct vhost_dev *dev,
153 uint64_t features)
154{
155 return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
156}
157
158static int vhost_kernel_get_features(struct vhost_dev *dev,
159 uint64_t *features)
160{
161 return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
162}
163
164static int vhost_kernel_set_owner(struct vhost_dev *dev)
165{
166 return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
167}
168
169static int vhost_kernel_reset_device(struct vhost_dev *dev)
170{
171 return vhost_kernel_call(dev, VHOST_RESET_OWNER, NULL);
172}
173
174static int vhost_kernel_get_vq_index(struct vhost_dev *dev, int idx)
175{
176 assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
177
178 return idx - dev->vq_index;
179}
180
181#ifdef CONFIG_VHOST_VSOCK
182static int vhost_kernel_vsock_set_guest_cid(struct vhost_dev *dev,
183 uint64_t guest_cid)
184{
185 return vhost_kernel_call(dev, VHOST_VSOCK_SET_GUEST_CID, &guest_cid);
186}
187
188static int vhost_kernel_vsock_set_running(struct vhost_dev *dev, int start)
189{
190 return vhost_kernel_call(dev, VHOST_VSOCK_SET_RUNNING, &start);
191}
192#endif
193
194static void vhost_kernel_iotlb_read(void *opaque)
195{
196 struct vhost_dev *dev = opaque;
197 struct vhost_msg msg;
198 ssize_t len;
199
200 while ((len = read((uintptr_t)dev->opaque, &msg, sizeof msg)) > 0) {
201 if (len < sizeof msg) {
202 error_report("Wrong vhost message len: %d", (int)len);
203 break;
204 }
205 if (msg.type != VHOST_IOTLB_MSG) {
206 error_report("Unknown vhost iotlb message type");
207 break;
208 }
209
210 vhost_backend_handle_iotlb_msg(dev, &msg.iotlb);
211 }
212}
213
214static int vhost_kernel_send_device_iotlb_msg(struct vhost_dev *dev,
215 struct vhost_iotlb_msg *imsg)
216{
217 struct vhost_msg msg;
218
219 msg.type = VHOST_IOTLB_MSG;
220 msg.iotlb = *imsg;
221
222 if (write((uintptr_t)dev->opaque, &msg, sizeof msg) != sizeof msg) {
223 error_report("Fail to update device iotlb");
224 return -EFAULT;
225 }
226
227 return 0;
228}
229
230static void vhost_kernel_set_iotlb_callback(struct vhost_dev *dev,
231 int enabled)
232{
233 if (enabled)
234 qemu_set_fd_handler((uintptr_t)dev->opaque,
235 vhost_kernel_iotlb_read, NULL, dev);
236 else
237 qemu_set_fd_handler((uintptr_t)dev->opaque, NULL, NULL, NULL);
238}
239
240static const VhostOps kernel_ops = {
241 .backend_type = VHOST_BACKEND_TYPE_KERNEL,
242 .vhost_backend_init = vhost_kernel_init,
243 .vhost_backend_cleanup = vhost_kernel_cleanup,
244 .vhost_backend_memslots_limit = vhost_kernel_memslots_limit,
245 .vhost_net_set_backend = vhost_kernel_net_set_backend,
246 .vhost_scsi_set_endpoint = vhost_kernel_scsi_set_endpoint,
247 .vhost_scsi_clear_endpoint = vhost_kernel_scsi_clear_endpoint,
248 .vhost_scsi_get_abi_version = vhost_kernel_scsi_get_abi_version,
249 .vhost_set_log_base = vhost_kernel_set_log_base,
250 .vhost_set_mem_table = vhost_kernel_set_mem_table,
251 .vhost_set_vring_addr = vhost_kernel_set_vring_addr,
252 .vhost_set_vring_endian = vhost_kernel_set_vring_endian,
253 .vhost_set_vring_num = vhost_kernel_set_vring_num,
254 .vhost_set_vring_base = vhost_kernel_set_vring_base,
255 .vhost_get_vring_base = vhost_kernel_get_vring_base,
256 .vhost_set_vring_kick = vhost_kernel_set_vring_kick,
257 .vhost_set_vring_call = vhost_kernel_set_vring_call,
258 .vhost_set_vring_busyloop_timeout =
259 vhost_kernel_set_vring_busyloop_timeout,
260 .vhost_set_features = vhost_kernel_set_features,
261 .vhost_get_features = vhost_kernel_get_features,
262 .vhost_set_owner = vhost_kernel_set_owner,
263 .vhost_reset_device = vhost_kernel_reset_device,
264 .vhost_get_vq_index = vhost_kernel_get_vq_index,
265#ifdef CONFIG_VHOST_VSOCK
266 .vhost_vsock_set_guest_cid = vhost_kernel_vsock_set_guest_cid,
267 .vhost_vsock_set_running = vhost_kernel_vsock_set_running,
268#endif
269 .vhost_set_iotlb_callback = vhost_kernel_set_iotlb_callback,
270 .vhost_send_device_iotlb_msg = vhost_kernel_send_device_iotlb_msg,
271};
272#endif
273
274int vhost_set_backend_type(struct vhost_dev *dev, VhostBackendType backend_type)
275{
276 int r = 0;
277
278 switch (backend_type) {
279#ifdef CONFIG_VHOST_KERNEL
280 case VHOST_BACKEND_TYPE_KERNEL:
281 dev->vhost_ops = &kernel_ops;
282 break;
283#endif
284#ifdef CONFIG_VHOST_USER
285 case VHOST_BACKEND_TYPE_USER:
286 dev->vhost_ops = &user_ops;
287 break;
288#endif
289 default:
290 error_report("Unknown vhost backend type");
291 r = -1;
292 }
293
294 return r;
295}
296
297int vhost_backend_update_device_iotlb(struct vhost_dev *dev,
298 uint64_t iova, uint64_t uaddr,
299 uint64_t len,
300 IOMMUAccessFlags perm)
301{
302 struct vhost_iotlb_msg imsg;
303
304 imsg.iova = iova;
305 imsg.uaddr = uaddr;
306 imsg.size = len;
307 imsg.type = VHOST_IOTLB_UPDATE;
308
309 switch (perm) {
310 case IOMMU_RO:
311 imsg.perm = VHOST_ACCESS_RO;
312 break;
313 case IOMMU_WO:
314 imsg.perm = VHOST_ACCESS_WO;
315 break;
316 case IOMMU_RW:
317 imsg.perm = VHOST_ACCESS_RW;
318 break;
319 default:
320 return -EINVAL;
321 }
322
323 if (dev->vhost_ops && dev->vhost_ops->vhost_send_device_iotlb_msg)
324 return dev->vhost_ops->vhost_send_device_iotlb_msg(dev, &imsg);
325
326 return -ENODEV;
327}
328
329int vhost_backend_invalidate_device_iotlb(struct vhost_dev *dev,
330 uint64_t iova, uint64_t len)
331{
332 struct vhost_iotlb_msg imsg;
333
334 imsg.iova = iova;
335 imsg.size = len;
336 imsg.type = VHOST_IOTLB_INVALIDATE;
337
338 if (dev->vhost_ops && dev->vhost_ops->vhost_send_device_iotlb_msg)
339 return dev->vhost_ops->vhost_send_device_iotlb_msg(dev, &imsg);
340
341 return -ENODEV;
342}
343
344int vhost_backend_handle_iotlb_msg(struct vhost_dev *dev,
345 struct vhost_iotlb_msg *imsg)
346{
347 int ret = 0;
348
349 switch (imsg->type) {
350 case VHOST_IOTLB_MISS:
351 ret = vhost_device_iotlb_miss(dev, imsg->iova,
352 imsg->perm != VHOST_ACCESS_RO);
353 break;
354 case VHOST_IOTLB_ACCESS_FAIL:
355
356 error_report("Access failure IOTLB message type not supported");
357 ret = -ENOTSUP;
358 break;
359 case VHOST_IOTLB_UPDATE:
360 case VHOST_IOTLB_INVALIDATE:
361 default:
362 error_report("Unexpected IOTLB message type");
363 ret = -EINVAL;
364 break;
365 }
366
367 return ret;
368}
369
