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     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 }