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