drivers/vfio/vfio.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   4  *     Author: Alex Williamson <alex.williamson@redhat.com>
   5  */
   6 #ifndef __VFIO_VFIO_H__
   7 #define __VFIO_VFIO_H__
   8
   9 #include <linux/file.h>
  10 #include <linux/device.h>
  11 #include <linux/cdev.h>
  12 #include <linux/module.h>
  13 #include <linux/vfio.h>
  14
  15 struct iommufd_ctx;
  16 struct iommu_group;
  17 struct vfio_container;
  18
  19 struct vfio_device_file {
  20         struct vfio_device *device;
  21         struct vfio_group *group;
  22
  23         u8 access_granted;
  24         u32 devid; /* only valid when iommufd is valid */
  25         spinlock_t kvm_ref_lock; /* protect kvm field */
  26         struct kvm *kvm;
  27         struct iommufd_ctx *iommufd; /* protected by struct vfio_device_set::lock */
  28 };
  29
  30 void vfio_device_put_registration(struct vfio_device *device);
  31 bool vfio_device_try_get_registration(struct vfio_device *device);
  32 int vfio_df_open(struct vfio_device_file *df);
  33 void vfio_df_close(struct vfio_device_file *df);
  34 struct vfio_device_file *
  35 vfio_allocate_device_file(struct vfio_device *device);
  36
  37 extern const struct file_operations vfio_device_fops;
  38
  39 #ifdef CONFIG_VFIO_NOIOMMU
  40 extern bool vfio_noiommu __read_mostly;
  41 #else
  42 enum { vfio_noiommu = false };
  43 #endif
  44
  45 enum vfio_group_type {
  46         /*
  47          * Physical device with IOMMU backing.
  48          */
  49         VFIO_IOMMU,
  50
  51         /*
  52          * Virtual device without IOMMU backing. The VFIO core fakes up an
  53          * iommu_group as the iommu_group sysfs interface is part of the
  54          * userspace ABI.  The user of these devices must not be able to
  55          * directly trigger unmediated DMA.
  56          */
  57         VFIO_EMULATED_IOMMU,
  58
  59         /*
  60          * Physical device without IOMMU backing. The VFIO core fakes up an
  61          * iommu_group as the iommu_group sysfs interface is part of the
  62          * userspace ABI.  Users can trigger unmediated DMA by the device,
  63          * usage is highly dangerous, requires an explicit opt-in and will
  64          * taint the kernel.
  65          */
  66         VFIO_NO_IOMMU,
  67 };
  68
  69 #if IS_ENABLED(CONFIG_VFIO_GROUP)
  70 struct vfio_group {
  71         struct device                   dev;
  72         struct cdev                     cdev;
  73         /*
  74          * When drivers is non-zero a driver is attached to the struct device
  75          * that provided the iommu_group and thus the iommu_group is a valid
  76          * pointer. When drivers is 0 the driver is being detached. Once users
  77          * reaches 0 then the iommu_group is invalid.
  78          */
  79         refcount_t                      drivers;
  80         unsigned int                    container_users;
  81         struct iommu_group              *iommu_group;
  82         struct vfio_container           *container;
  83         struct list_head                device_list;
  84         struct mutex                    device_lock;
  85         struct list_head                vfio_next;
  86 #if IS_ENABLED(CONFIG_VFIO_CONTAINER)
  87         struct list_head                container_next;
  88 #endif
  89         enum vfio_group_type            type;
  90         struct mutex                    group_lock;
  91         struct kvm                      *kvm;
  92         struct file                     *opened_file;
  93         struct blocking_notifier_head   notifier;
  94         struct iommufd_ctx              *iommufd;
  95         spinlock_t                      kvm_ref_lock;
  96         unsigned int                    cdev_device_open_cnt;
  97 };
  98
  99 int vfio_device_block_group(struct vfio_device *device);
 100 void vfio_device_unblock_group(struct vfio_device *device);
 101 int vfio_device_set_group(struct vfio_device *device,
 102                           enum vfio_group_type type);
 103 void vfio_device_remove_group(struct vfio_device *device);
 104 void vfio_device_group_register(struct vfio_device *device);
 105 void vfio_device_group_unregister(struct vfio_device *device);
 106 int vfio_device_group_use_iommu(struct vfio_device *device);
 107 void vfio_device_group_unuse_iommu(struct vfio_device *device);
 108 void vfio_df_group_close(struct vfio_device_file *df);
 109 struct vfio_group *vfio_group_from_file(struct file *file);
 110 bool vfio_group_enforced_coherent(struct vfio_group *group);
 111 void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm);
 112 bool vfio_device_has_container(struct vfio_device *device);
 113 int __init vfio_group_init(void);
 114 void vfio_group_cleanup(void);
 115
 116 static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
 117 {
 118         return IS_ENABLED(CONFIG_VFIO_NOIOMMU) &&
 119                vdev->group->type == VFIO_NO_IOMMU;
 120 }
 121 #else
 122 struct vfio_group;
 123
 124 static inline int vfio_device_block_group(struct vfio_device *device)
 125 {
 126         return 0;
 127 }
 128
 129 static inline void vfio_device_unblock_group(struct vfio_device *device)
 130 {
 131 }
 132
 133 static inline int vfio_device_set_group(struct vfio_device *device,
 134                                         enum vfio_group_type type)
 135 {
 136         return 0;
 137 }
 138
 139 static inline void vfio_device_remove_group(struct vfio_device *device)
 140 {
 141 }
 142
 143 static inline void vfio_device_group_register(struct vfio_device *device)
 144 {
 145 }
 146
 147 static inline void vfio_device_group_unregister(struct vfio_device *device)
 148 {
 149 }
 150
 151 static inline int vfio_device_group_use_iommu(struct vfio_device *device)
 152 {
 153         return -EOPNOTSUPP;
 154 }
 155
 156 static inline void vfio_device_group_unuse_iommu(struct vfio_device *device)
 157 {
 158 }
 159
 160 static inline void vfio_df_group_close(struct vfio_device_file *df)
 161 {
 162 }
 163
 164 static inline struct vfio_group *vfio_group_from_file(struct file *file)
 165 {
 166         return NULL;
 167 }
 168
 169 static inline bool vfio_group_enforced_coherent(struct vfio_group *group)
 170 {
 171         return true;
 172 }
 173
 174 static inline void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm)
 175 {
 176 }
 177
 178 static inline bool vfio_device_has_container(struct vfio_device *device)
 179 {
 180         return false;
 181 }
 182
 183 static inline int __init vfio_group_init(void)
 184 {
 185         return 0;
 186 }
 187
 188 static inline void vfio_group_cleanup(void)
 189 {
 190 }
 191
 192 static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
 193 {
 194         return false;
 195 }
 196 #endif /* CONFIG_VFIO_GROUP */
 197
 198 #if IS_ENABLED(CONFIG_VFIO_CONTAINER)
 199 /**
 200  * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
 201  */
 202 struct vfio_iommu_driver_ops {
 203         char            *name;
 204         struct module   *owner;
 205         void            *(*open)(unsigned long arg);
 206         void            (*release)(void *iommu_data);
 207         long            (*ioctl)(void *iommu_data, unsigned int cmd,
 208                                  unsigned long arg);
 209         int             (*attach_group)(void *iommu_data,
 210                                         struct iommu_group *group,
 211                                         enum vfio_group_type);
 212         void            (*detach_group)(void *iommu_data,
 213                                         struct iommu_group *group);
 214         int             (*pin_pages)(void *iommu_data,
 215                                      struct iommu_group *group,
 216                                      dma_addr_t user_iova,
 217                                      int npage, int prot,
 218                                      struct page **pages);
 219         void            (*unpin_pages)(void *iommu_data,
 220                                        dma_addr_t user_iova, int npage);
 221         void            (*register_device)(void *iommu_data,
 222                                            struct vfio_device *vdev);
 223         void            (*unregister_device)(void *iommu_data,
 224                                              struct vfio_device *vdev);
 225         int             (*dma_rw)(void *iommu_data, dma_addr_t user_iova,
 226                                   void *data, size_t count, bool write);
 227         struct iommu_domain *(*group_iommu_domain)(void *iommu_data,
 228                                                    struct iommu_group *group);
 229 };
 230
 231 struct vfio_iommu_driver {
 232         const struct vfio_iommu_driver_ops      *ops;
 233         struct list_head                        vfio_next;
 234 };
 235
 236 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
 237 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops);
 238
 239 struct vfio_container *vfio_container_from_file(struct file *filep);
 240 int vfio_group_use_container(struct vfio_group *group);
 241 void vfio_group_unuse_container(struct vfio_group *group);
 242 int vfio_container_attach_group(struct vfio_container *container,
 243                                 struct vfio_group *group);
 244 void vfio_group_detach_container(struct vfio_group *group);
 245 void vfio_device_container_register(struct vfio_device *device);
 246 void vfio_device_container_unregister(struct vfio_device *device);
 247 int vfio_device_container_pin_pages(struct vfio_device *device,
 248                                     dma_addr_t iova, int npage,
 249                                     int prot, struct page **pages);
 250 void vfio_device_container_unpin_pages(struct vfio_device *device,
 251                                        dma_addr_t iova, int npage);
 252 int vfio_device_container_dma_rw(struct vfio_device *device,
 253                                  dma_addr_t iova, void *data,
 254                                  size_t len, bool write);
 255
 256 int __init vfio_container_init(void);
 257 void vfio_container_cleanup(void);
 258 #else
 259 static inline struct vfio_container *
 260 vfio_container_from_file(struct file *filep)
 261 {
 262         return NULL;
 263 }
 264
 265 static inline int vfio_group_use_container(struct vfio_group *group)
 266 {
 267         return -EOPNOTSUPP;
 268 }
 269
 270 static inline void vfio_group_unuse_container(struct vfio_group *group)
 271 {
 272 }
 273
 274 static inline int vfio_container_attach_group(struct vfio_container *container,
 275                                               struct vfio_group *group)
 276 {
 277         return -EOPNOTSUPP;
 278 }
 279
 280 static inline void vfio_group_detach_container(struct vfio_group *group)
 281 {
 282 }
 283
 284 static inline void vfio_device_container_register(struct vfio_device *device)
 285 {
 286 }
 287
 288 static inline void vfio_device_container_unregister(struct vfio_device *device)
 289 {
 290 }
 291
 292 static inline int vfio_device_container_pin_pages(struct vfio_device *device,
 293                                                   dma_addr_t iova, int npage,
 294                                                   int prot, struct page **pages)
 295 {
 296         return -EOPNOTSUPP;
 297 }
 298
 299 static inline void vfio_device_container_unpin_pages(struct vfio_device *device,
 300                                                      dma_addr_t iova, int npage)
 301 {
 302 }
 303
 304 static inline int vfio_device_container_dma_rw(struct vfio_device *device,
 305                                                dma_addr_t iova, void *data,
 306                                                size_t len, bool write)
 307 {
 308         return -EOPNOTSUPP;
 309 }
 310
 311 static inline int vfio_container_init(void)
 312 {
 313         return 0;
 314 }
 315 static inline void vfio_container_cleanup(void)
 316 {
 317 }
 318 #endif
 319
 320 #if IS_ENABLED(CONFIG_IOMMUFD)
 321 bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
 322                                          struct iommufd_ctx *ictx);
 323 int vfio_df_iommufd_bind(struct vfio_device_file *df);
 324 void vfio_df_iommufd_unbind(struct vfio_device_file *df);
 325 int vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
 326                                     struct iommufd_ctx *ictx);
 327 #else
 328 static inline bool
 329 vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
 330                                     struct iommufd_ctx *ictx)
 331 {
 332         return false;
 333 }
 334
 335 static inline int vfio_df_iommufd_bind(struct vfio_device_file *fd)
 336 {
 337         return -EOPNOTSUPP;
 338 }
 339
 340 static inline void vfio_df_iommufd_unbind(struct vfio_device_file *df)
 341 {
 342 }
 343
 344 static inline int
 345 vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
 346                                 struct iommufd_ctx *ictx)
 347 {
 348         return -EOPNOTSUPP;
 349 }
 350 #endif
 351
 352 int vfio_df_ioctl_attach_pt(struct vfio_device_file *df,
 353                             struct vfio_device_attach_iommufd_pt __user *arg);
 354 int vfio_df_ioctl_detach_pt(struct vfio_device_file *df,
 355                             struct vfio_device_detach_iommufd_pt __user *arg);
 356
 357 #if IS_ENABLED(CONFIG_VFIO_DEVICE_CDEV)
 358 void vfio_init_device_cdev(struct vfio_device *device);
 359
 360 static inline int vfio_device_add(struct vfio_device *device)
 361 {
 362         /* cdev does not support noiommu device */
 363         if (vfio_device_is_noiommu(device))
 364                 return device_add(&device->device);
 365         vfio_init_device_cdev(device);
 366         return cdev_device_add(&device->cdev, &device->device);
 367 }
 368
 369 static inline void vfio_device_del(struct vfio_device *device)
 370 {
 371         if (vfio_device_is_noiommu(device))
 372                 device_del(&device->device);
 373         else
 374                 cdev_device_del(&device->cdev, &device->device);
 375 }
 376
 377 int vfio_device_fops_cdev_open(struct inode *inode, struct file *filep);
 378 long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
 379                                 struct vfio_device_bind_iommufd __user *arg);
 380 void vfio_df_unbind_iommufd(struct vfio_device_file *df);
 381 int vfio_cdev_init(struct class *device_class);
 382 void vfio_cdev_cleanup(void);
 383 #else
 384 static inline void vfio_init_device_cdev(struct vfio_device *device)
 385 {
 386 }
 387
 388 static inline int vfio_device_add(struct vfio_device *device)
 389 {
 390         return device_add(&device->device);
 391 }
 392
 393 static inline void vfio_device_del(struct vfio_device *device)
 394 {
 395         device_del(&device->device);
 396 }
 397
 398 static inline int vfio_device_fops_cdev_open(struct inode *inode,
 399                                              struct file *filep)
 400 {
 401         return 0;
 402 }
 403
 404 static inline long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
 405                                               struct vfio_device_bind_iommufd __user *arg)
 406 {
 407         return -ENOTTY;
 408 }
 409
 410 static inline void vfio_df_unbind_iommufd(struct vfio_device_file *df)
 411 {
 412 }
 413
 414 static inline int vfio_cdev_init(struct class *device_class)
 415 {
 416         return 0;
 417 }
 418
 419 static inline void vfio_cdev_cleanup(void)
 420 {
 421 }
 422 #endif /* CONFIG_VFIO_DEVICE_CDEV */
 423
 424 #if IS_ENABLED(CONFIG_VFIO_VIRQFD)
 425 int __init vfio_virqfd_init(void);
 426 void vfio_virqfd_exit(void);
 427 #else
 428 static inline int __init vfio_virqfd_init(void)
 429 {
 430         return 0;
 431 }
 432 static inline void vfio_virqfd_exit(void)
 433 {
 434 }
 435 #endif
 436
 437 #ifdef CONFIG_HAVE_KVM
 438 void vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm);
 439 void vfio_device_put_kvm(struct vfio_device *device);
 440 #else
 441 static inline void vfio_device_get_kvm_safe(struct vfio_device *device,
 442                                             struct kvm *kvm)
 443 {
 444 }
 445
 446 static inline void vfio_device_put_kvm(struct vfio_device *device)
 447 {
 448 }
 449 #endif
 450
 451 #endif