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/device.h>
  10 #include <linux/cdev.h>
  11 #include <linux/module.h>
  12
  13 struct iommu_group;
  14 struct vfio_device;
  15 struct vfio_container;
  16
  17 enum vfio_group_type {
  18         /*
  19          * Physical device with IOMMU backing.
  20          */
  21         VFIO_IOMMU,
  22
  23         /*
  24          * Virtual device without IOMMU backing. The VFIO core fakes up an
  25          * iommu_group as the iommu_group sysfs interface is part of the
  26          * userspace ABI.  The user of these devices must not be able to
  27          * directly trigger unmediated DMA.
  28          */
  29         VFIO_EMULATED_IOMMU,
  30
  31         /*
  32          * Physical device without IOMMU backing. The VFIO core fakes up an
  33          * iommu_group as the iommu_group sysfs interface is part of the
  34          * userspace ABI.  Users can trigger unmediated DMA by the device,
  35          * usage is highly dangerous, requires an explicit opt-in and will
  36          * taint the kernel.
  37          */
  38         VFIO_NO_IOMMU,
  39 };
  40
  41 struct vfio_group {
  42         struct device                   dev;
  43         struct cdev                     cdev;
  44         /*
  45          * When drivers is non-zero a driver is attached to the struct device
  46          * that provided the iommu_group and thus the iommu_group is a valid
  47          * pointer. When drivers is 0 the driver is being detached. Once users
  48          * reaches 0 then the iommu_group is invalid.
  49          */
  50         refcount_t                      drivers;
  51         unsigned int                    container_users;
  52         struct iommu_group              *iommu_group;
  53         struct vfio_container           *container;
  54         struct list_head                device_list;
  55         struct mutex                    device_lock;
  56         struct list_head                vfio_next;
  57         struct list_head                container_next;
  58         enum vfio_group_type            type;
  59         struct mutex                    group_lock;
  60         struct kvm                      *kvm;
  61         struct file                     *opened_file;
  62         struct blocking_notifier_head   notifier;
  63 };
  64
  65 /* events for the backend driver notify callback */
  66 enum vfio_iommu_notify_type {
  67         VFIO_IOMMU_CONTAINER_CLOSE = 0,
  68 };
  69
  70 /**
  71  * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
  72  */
  73 struct vfio_iommu_driver_ops {
  74         char            *name;
  75         struct module   *owner;
  76         void            *(*open)(unsigned long arg);
  77         void            (*release)(void *iommu_data);
  78         long            (*ioctl)(void *iommu_data, unsigned int cmd,
  79                                  unsigned long arg);
  80         int             (*attach_group)(void *iommu_data,
  81                                         struct iommu_group *group,
  82                                         enum vfio_group_type);
  83         void            (*detach_group)(void *iommu_data,
  84                                         struct iommu_group *group);
  85         int             (*pin_pages)(void *iommu_data,
  86                                      struct iommu_group *group,
  87                                      dma_addr_t user_iova,
  88                                      int npage, int prot,
  89                                      struct page **pages);
  90         void            (*unpin_pages)(void *iommu_data,
  91                                        dma_addr_t user_iova, int npage);
  92         void            (*register_device)(void *iommu_data,
  93                                            struct vfio_device *vdev);
  94         void            (*unregister_device)(void *iommu_data,
  95                                              struct vfio_device *vdev);
  96         int             (*dma_rw)(void *iommu_data, dma_addr_t user_iova,
  97                                   void *data, size_t count, bool write);
  98         struct iommu_domain *(*group_iommu_domain)(void *iommu_data,
  99                                                    struct iommu_group *group);
 100         void            (*notify)(void *iommu_data,
 101                                   enum vfio_iommu_notify_type event);
 102 };
 103
 104 struct vfio_iommu_driver {
 105         const struct vfio_iommu_driver_ops      *ops;
 106         struct list_head                        vfio_next;
 107 };
 108
 109 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
 110 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops);
 111
 112 bool vfio_assert_device_open(struct vfio_device *device);
 113
 114 struct vfio_container *vfio_container_from_file(struct file *filep);
 115 int vfio_device_assign_container(struct vfio_device *device);
 116 void vfio_device_unassign_container(struct vfio_device *device);
 117 int vfio_container_attach_group(struct vfio_container *container,
 118                                 struct vfio_group *group);
 119 void vfio_group_detach_container(struct vfio_group *group);
 120 void vfio_device_container_register(struct vfio_device *device);
 121 void vfio_device_container_unregister(struct vfio_device *device);
 122 long vfio_container_ioctl_check_extension(struct vfio_container *container,
 123                                           unsigned long arg);
 124 int __init vfio_container_init(void);
 125 void vfio_container_cleanup(void);
 126
 127 #ifdef CONFIG_VFIO_NOIOMMU
 128 extern bool vfio_noiommu __read_mostly;
 129 #else
 130 enum { vfio_noiommu = false };
 131 #endif
 132
 133 #endif