xref: /openbmc/qemu/hw/virtio/vhost-backend.c (revision effd60c8)
1 /*
2  * vhost-backend
3  *
4  * Copyright (c) 2013 Virtual Open Systems Sarl.
5  *
6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
7  * See the COPYING file in the top-level directory.
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 #include "hw/virtio/vhost-vdpa.h"
19 #ifdef CONFIG_VHOST_KERNEL
20 #include <linux/vhost.h>
21 #include <sys/ioctl.h>
22 
23 static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int request,
24                              void *arg)
25 {
26     int fd = (uintptr_t) dev->opaque;
27     int ret;
28 
29     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
30 
31     ret = ioctl(fd, request, arg);
32     return ret < 0 ? -errno : ret;
33 }
34 
35 static int vhost_kernel_init(struct vhost_dev *dev, void *opaque, Error **errp)
36 {
37     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
38 
39     dev->opaque = opaque;
40 
41     return 0;
42 }
43 
44 static int vhost_kernel_cleanup(struct vhost_dev *dev)
45 {
46     int fd = (uintptr_t) dev->opaque;
47 
48     assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
49 
50     return close(fd) < 0 ? -errno : 0;
51 }
52 
53 static int vhost_kernel_memslots_limit(struct vhost_dev *dev)
54 {
55     int limit = 64;
56     char *s;
57 
58     if (g_file_get_contents("/sys/module/vhost/parameters/max_mem_regions",
59                             &s, NULL, NULL)) {
60         uint64_t val = g_ascii_strtoull(s, NULL, 10);
61         if (val < INT_MAX && val > 0) {
62             g_free(s);
63             return val;
64         }
65         error_report("ignoring invalid max_mem_regions value in vhost module:"
66                      " %s", s);
67     }
68     g_free(s);
69     return limit;
70 }
71 
72 static int vhost_kernel_net_set_backend(struct vhost_dev *dev,
73                                         struct vhost_vring_file *file)
74 {
75     return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
76 }
77 
78 static int vhost_kernel_scsi_set_endpoint(struct vhost_dev *dev,
79                                           struct vhost_scsi_target *target)
80 {
81     return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
82 }
83 
84 static int vhost_kernel_scsi_clear_endpoint(struct vhost_dev *dev,
85                                             struct vhost_scsi_target *target)
86 {
87     return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
88 }
89 
90 static int vhost_kernel_scsi_get_abi_version(struct vhost_dev *dev, int *version)
91 {
92     return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
93 }
94 
95 static int vhost_kernel_set_log_base(struct vhost_dev *dev, uint64_t base,
96                                      struct vhost_log *log)
97 {
98     return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
99 }
100 
101 static int vhost_kernel_set_mem_table(struct vhost_dev *dev,
102                                       struct vhost_memory *mem)
103 {
104     return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
105 }
106 
107 static int vhost_kernel_set_vring_addr(struct vhost_dev *dev,
108                                        struct vhost_vring_addr *addr)
109 {
110     return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
111 }
112 
113 static int vhost_kernel_set_vring_endian(struct vhost_dev *dev,
114                                          struct vhost_vring_state *ring)
115 {
116     return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
117 }
118 
119 static int vhost_kernel_set_vring_num(struct vhost_dev *dev,
120                                       struct vhost_vring_state *ring)
121 {
122     return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
123 }
124 
125 static int vhost_kernel_set_vring_base(struct vhost_dev *dev,
126                                        struct vhost_vring_state *ring)
127 {
128     return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
129 }
130 
131 static int vhost_kernel_get_vring_base(struct vhost_dev *dev,
132                                        struct vhost_vring_state *ring)
133 {
134     return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
135 }
136 
137 static int vhost_kernel_set_vring_kick(struct vhost_dev *dev,
138                                        struct vhost_vring_file *file)
139 {
140     return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
141 }
142 
143 static int vhost_kernel_set_vring_call(struct vhost_dev *dev,
144                                        struct vhost_vring_file *file)
145 {
146     return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
147 }
148 
149 static int vhost_kernel_set_vring_err(struct vhost_dev *dev,
150                                       struct vhost_vring_file *file)
151 {
152     return vhost_kernel_call(dev, VHOST_SET_VRING_ERR, file);
153 }
154 
155 static int vhost_kernel_set_vring_busyloop_timeout(struct vhost_dev *dev,
156                                                    struct vhost_vring_state *s)
157 {
158     return vhost_kernel_call(dev, VHOST_SET_VRING_BUSYLOOP_TIMEOUT, s);
159 }
160 
161 static int vhost_kernel_new_worker(struct vhost_dev *dev,
162                                    struct vhost_worker_state *worker)
163 {
164     return vhost_kernel_call(dev, VHOST_NEW_WORKER, worker);
165 }
166 
167 static int vhost_kernel_free_worker(struct vhost_dev *dev,
168                                     struct vhost_worker_state *worker)
169 {
170     return vhost_kernel_call(dev, VHOST_FREE_WORKER, worker);
171 }
172 
173 static int vhost_kernel_attach_vring_worker(struct vhost_dev *dev,
174                                             struct vhost_vring_worker *worker)
175 {
176     return vhost_kernel_call(dev, VHOST_ATTACH_VRING_WORKER, worker);
177 }
178 
179 static int vhost_kernel_get_vring_worker(struct vhost_dev *dev,
180                                          struct vhost_vring_worker *worker)
181 {
182     return vhost_kernel_call(dev, VHOST_GET_VRING_WORKER, worker);
183 }
184 
185 static int vhost_kernel_set_features(struct vhost_dev *dev,
186                                      uint64_t features)
187 {
188     return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
189 }
190 
191 static int vhost_kernel_set_backend_cap(struct vhost_dev *dev)
192 {
193     uint64_t features;
194     uint64_t f = 0x1ULL << VHOST_BACKEND_F_IOTLB_MSG_V2;
195     int r;
196 
197     if (vhost_kernel_call(dev, VHOST_GET_BACKEND_FEATURES, &features)) {
198         return 0;
199     }
200 
201     features &= f;
202     r = vhost_kernel_call(dev, VHOST_SET_BACKEND_FEATURES,
203                               &features);
204     if (r) {
205         return 0;
206     }
207 
208     dev->backend_cap = features;
209 
210     return 0;
211 }
212 
213 static int vhost_kernel_get_features(struct vhost_dev *dev,
214                                      uint64_t *features)
215 {
216     return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
217 }
218 
219 static int vhost_kernel_set_owner(struct vhost_dev *dev)
220 {
221     return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
222 }
223 
224 static int vhost_kernel_get_vq_index(struct vhost_dev *dev, int idx)
225 {
226     assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
227 
228     return idx - dev->vq_index;
229 }
230 
231 static int vhost_kernel_vsock_set_guest_cid(struct vhost_dev *dev,
232                                             uint64_t guest_cid)
233 {
234     return vhost_kernel_call(dev, VHOST_VSOCK_SET_GUEST_CID, &guest_cid);
235 }
236 
237 static int vhost_kernel_vsock_set_running(struct vhost_dev *dev, int start)
238 {
239     return vhost_kernel_call(dev, VHOST_VSOCK_SET_RUNNING, &start);
240 }
241 
242 static void vhost_kernel_iotlb_read(void *opaque)
243 {
244     struct vhost_dev *dev = opaque;
245     ssize_t len;
246 
247     if (dev->backend_cap &
248         (0x1ULL << VHOST_BACKEND_F_IOTLB_MSG_V2)) {
249         struct vhost_msg_v2 msg;
250 
251         while ((len = read((uintptr_t)dev->opaque, &msg, sizeof msg)) > 0) {
252             if (len < sizeof msg) {
253                 error_report("Wrong vhost message len: %d", (int)len);
254                 break;
255             }
256             if (msg.type != VHOST_IOTLB_MSG_V2) {
257                 error_report("Unknown vhost iotlb message type");
258                 break;
259             }
260 
261             vhost_backend_handle_iotlb_msg(dev, &msg.iotlb);
262         }
263     } else {
264         struct vhost_msg msg;
265 
266         while ((len = read((uintptr_t)dev->opaque, &msg, sizeof msg)) > 0) {
267             if (len < sizeof msg) {
268                 error_report("Wrong vhost message len: %d", (int)len);
269                 break;
270             }
271             if (msg.type != VHOST_IOTLB_MSG) {
272                 error_report("Unknown vhost iotlb message type");
273                 break;
274             }
275 
276             vhost_backend_handle_iotlb_msg(dev, &msg.iotlb);
277         }
278     }
279 }
280 
281 static int vhost_kernel_send_device_iotlb_msg(struct vhost_dev *dev,
282                                               struct vhost_iotlb_msg *imsg)
283 {
284     if (dev->backend_cap & (1ULL << VHOST_BACKEND_F_IOTLB_MSG_V2)) {
285         struct vhost_msg_v2 msg = {};
286 
287         msg.type = VHOST_IOTLB_MSG_V2;
288         msg.iotlb = *imsg;
289 
290         if (write((uintptr_t)dev->opaque, &msg, sizeof msg) != sizeof msg) {
291             error_report("Fail to update device iotlb");
292             return -EFAULT;
293         }
294     } else {
295         struct vhost_msg msg = {};
296 
297         msg.type = VHOST_IOTLB_MSG;
298         msg.iotlb = *imsg;
299 
300         if (write((uintptr_t)dev->opaque, &msg, sizeof msg) != sizeof msg) {
301             error_report("Fail to update device iotlb");
302             return -EFAULT;
303         }
304     }
305 
306     return 0;
307 }
308 
309 static void vhost_kernel_set_iotlb_callback(struct vhost_dev *dev,
310                                            int enabled)
311 {
312     if (enabled)
313         qemu_set_fd_handler((uintptr_t)dev->opaque,
314                             vhost_kernel_iotlb_read, NULL, dev);
315     else
316         qemu_set_fd_handler((uintptr_t)dev->opaque, NULL, NULL, NULL);
317 }
318 
319 const VhostOps kernel_ops = {
320         .backend_type = VHOST_BACKEND_TYPE_KERNEL,
321         .vhost_backend_init = vhost_kernel_init,
322         .vhost_backend_cleanup = vhost_kernel_cleanup,
323         .vhost_backend_memslots_limit = vhost_kernel_memslots_limit,
324         .vhost_net_set_backend = vhost_kernel_net_set_backend,
325         .vhost_scsi_set_endpoint = vhost_kernel_scsi_set_endpoint,
326         .vhost_scsi_clear_endpoint = vhost_kernel_scsi_clear_endpoint,
327         .vhost_scsi_get_abi_version = vhost_kernel_scsi_get_abi_version,
328         .vhost_set_log_base = vhost_kernel_set_log_base,
329         .vhost_set_mem_table = vhost_kernel_set_mem_table,
330         .vhost_set_vring_addr = vhost_kernel_set_vring_addr,
331         .vhost_set_vring_endian = vhost_kernel_set_vring_endian,
332         .vhost_set_vring_num = vhost_kernel_set_vring_num,
333         .vhost_set_vring_base = vhost_kernel_set_vring_base,
334         .vhost_get_vring_base = vhost_kernel_get_vring_base,
335         .vhost_set_vring_kick = vhost_kernel_set_vring_kick,
336         .vhost_set_vring_call = vhost_kernel_set_vring_call,
337         .vhost_set_vring_err = vhost_kernel_set_vring_err,
338         .vhost_set_vring_busyloop_timeout =
339                                 vhost_kernel_set_vring_busyloop_timeout,
340         .vhost_get_vring_worker = vhost_kernel_get_vring_worker,
341         .vhost_attach_vring_worker = vhost_kernel_attach_vring_worker,
342         .vhost_new_worker = vhost_kernel_new_worker,
343         .vhost_free_worker = vhost_kernel_free_worker,
344         .vhost_set_features = vhost_kernel_set_features,
345         .vhost_get_features = vhost_kernel_get_features,
346         .vhost_set_backend_cap = vhost_kernel_set_backend_cap,
347         .vhost_set_owner = vhost_kernel_set_owner,
348         .vhost_get_vq_index = vhost_kernel_get_vq_index,
349         .vhost_vsock_set_guest_cid = vhost_kernel_vsock_set_guest_cid,
350         .vhost_vsock_set_running = vhost_kernel_vsock_set_running,
351         .vhost_set_iotlb_callback = vhost_kernel_set_iotlb_callback,
352         .vhost_send_device_iotlb_msg = vhost_kernel_send_device_iotlb_msg,
353 };
354 #endif
355 
356 int vhost_backend_update_device_iotlb(struct vhost_dev *dev,
357                                              uint64_t iova, uint64_t uaddr,
358                                              uint64_t len,
359                                              IOMMUAccessFlags perm)
360 {
361     struct vhost_iotlb_msg imsg;
362 
363     imsg.iova =  iova;
364     imsg.uaddr = uaddr;
365     imsg.size = len;
366     imsg.type = VHOST_IOTLB_UPDATE;
367 
368     switch (perm) {
369     case IOMMU_RO:
370         imsg.perm = VHOST_ACCESS_RO;
371         break;
372     case IOMMU_WO:
373         imsg.perm = VHOST_ACCESS_WO;
374         break;
375     case IOMMU_RW:
376         imsg.perm = VHOST_ACCESS_RW;
377         break;
378     default:
379         return -EINVAL;
380     }
381 
382     if (dev->vhost_ops && dev->vhost_ops->vhost_send_device_iotlb_msg)
383         return dev->vhost_ops->vhost_send_device_iotlb_msg(dev, &imsg);
384 
385     return -ENODEV;
386 }
387 
388 int vhost_backend_invalidate_device_iotlb(struct vhost_dev *dev,
389                                                  uint64_t iova, uint64_t len)
390 {
391     struct vhost_iotlb_msg imsg;
392 
393     imsg.iova = iova;
394     imsg.size = len;
395     imsg.type = VHOST_IOTLB_INVALIDATE;
396 
397     if (dev->vhost_ops && dev->vhost_ops->vhost_send_device_iotlb_msg)
398         return dev->vhost_ops->vhost_send_device_iotlb_msg(dev, &imsg);
399 
400     return -ENODEV;
401 }
402 
403 int vhost_backend_handle_iotlb_msg(struct vhost_dev *dev,
404                                           struct vhost_iotlb_msg *imsg)
405 {
406     int ret = 0;
407 
408     if (unlikely(!dev->vdev)) {
409         error_report("Unexpected IOTLB message when virtio device is stopped");
410         return -EINVAL;
411     }
412 
413     switch (imsg->type) {
414     case VHOST_IOTLB_MISS:
415         ret = vhost_device_iotlb_miss(dev, imsg->iova,
416                                       imsg->perm != VHOST_ACCESS_RO);
417         break;
418     case VHOST_IOTLB_ACCESS_FAIL:
419         /* FIXME: report device iotlb error */
420         error_report("Access failure IOTLB message type not supported");
421         ret = -ENOTSUP;
422         break;
423     case VHOST_IOTLB_UPDATE:
424     case VHOST_IOTLB_INVALIDATE:
425     default:
426         error_report("Unexpected IOTLB message type");
427         ret = -EINVAL;
428         break;
429     }
430 
431     return ret;
432 }
433