hw/virtio/vhost-backend.c

   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 }