include/linux/vfio.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * VFIO API definition
   4  *
   5  * Copyright (C) 2012 Red Hat, Inc.  All rights reserved.
   6  *     Author: Alex Williamson <alex.williamson@redhat.com>
   7  */
   8 #ifndef VFIO_H
   9 #define VFIO_H
  10
  11
  12 #include <linux/iommu.h>
  13 #include <linux/mm.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/poll.h>
  16 #include <uapi/linux/vfio.h>
  17
  18 struct kvm;
  19
  20 /*
  21  * VFIO devices can be placed in a set, this allows all devices to share this
  22  * structure and the VFIO core will provide a lock that is held around
  23  * open_device()/close_device() for all devices in the set.
  24  */
  25 struct vfio_device_set {
  26         void *set_id;
  27         struct mutex lock;
  28         struct list_head device_list;
  29         unsigned int device_count;
  30 };
  31
  32 struct vfio_device {
  33         struct device *dev;
  34         const struct vfio_device_ops *ops;
  35         /*
  36          * mig_ops is a static property of the vfio_device which must be set
  37          * prior to registering the vfio_device.
  38          */
  39         const struct vfio_migration_ops *mig_ops;
  40         struct vfio_group *group;
  41         struct vfio_device_set *dev_set;
  42         struct list_head dev_set_list;
  43         unsigned int migration_flags;
  44         /* Driver must reference the kvm during open_device or never touch it */
  45         struct kvm *kvm;
  46
  47         /* Members below here are private, not for driver use */
  48         refcount_t refcount;
  49         unsigned int open_count;
  50         struct completion comp;
  51         struct list_head group_next;
  52         struct notifier_block iommu_nb;
  53 };
  54
  55 /**
  56  * struct vfio_device_ops - VFIO bus driver device callbacks
  57  *
  58  * @open_device: Called when the first file descriptor is opened for this device
  59  * @close_device: Opposite of open_device
  60  * @read: Perform read(2) on device file descriptor
  61  * @write: Perform write(2) on device file descriptor
  62  * @ioctl: Perform ioctl(2) on device file descriptor, supporting VFIO_DEVICE_*
  63  *         operations documented below
  64  * @mmap: Perform mmap(2) on a region of the device file descriptor
  65  * @request: Request for the bus driver to release the device
  66  * @match: Optional device name match callback (return: 0 for no-match, >0 for
  67  *         match, -errno for abort (ex. match with insufficient or incorrect
  68  *         additional args)
  69  * @dma_unmap: Called when userspace unmaps IOVA from the container
  70  *             this device is attached to.
  71  * @device_feature: Optional, fill in the VFIO_DEVICE_FEATURE ioctl
  72  */
  73 struct vfio_device_ops {
  74         char    *name;
  75         int     (*open_device)(struct vfio_device *vdev);
  76         void    (*close_device)(struct vfio_device *vdev);
  77         ssize_t (*read)(struct vfio_device *vdev, char __user *buf,
  78                         size_t count, loff_t *ppos);
  79         ssize_t (*write)(struct vfio_device *vdev, const char __user *buf,
  80                          size_t count, loff_t *size);
  81         long    (*ioctl)(struct vfio_device *vdev, unsigned int cmd,
  82                          unsigned long arg);
  83         int     (*mmap)(struct vfio_device *vdev, struct vm_area_struct *vma);
  84         void    (*request)(struct vfio_device *vdev, unsigned int count);
  85         int     (*match)(struct vfio_device *vdev, char *buf);
  86         void    (*dma_unmap)(struct vfio_device *vdev, u64 iova, u64 length);
  87         int     (*device_feature)(struct vfio_device *device, u32 flags,
  88                                   void __user *arg, size_t argsz);
  89 };
  90
  91 /**
  92  * @migration_set_state: Optional callback to change the migration state for
  93  *         devices that support migration. It's mandatory for
  94  *         VFIO_DEVICE_FEATURE_MIGRATION migration support.
  95  *         The returned FD is used for data transfer according to the FSM
  96  *         definition. The driver is responsible to ensure that FD reaches end
  97  *         of stream or error whenever the migration FSM leaves a data transfer
  98  *         state or before close_device() returns.
  99  * @migration_get_state: Optional callback to get the migration state for
 100  *         devices that support migration. It's mandatory for
 101  *         VFIO_DEVICE_FEATURE_MIGRATION migration support.
 102  */
 103 struct vfio_migration_ops {
 104         struct file *(*migration_set_state)(
 105                 struct vfio_device *device,
 106                 enum vfio_device_mig_state new_state);
 107         int (*migration_get_state)(struct vfio_device *device,
 108                                    enum vfio_device_mig_state *curr_state);
 109 };
 110
 111 /**
 112  * vfio_check_feature - Validate user input for the VFIO_DEVICE_FEATURE ioctl
 113  * @flags: Arg from the device_feature op
 114  * @argsz: Arg from the device_feature op
 115  * @supported_ops: Combination of VFIO_DEVICE_FEATURE_GET and SET the driver
 116  *                 supports
 117  * @minsz: Minimum data size the driver accepts
 118  *
 119  * For use in a driver's device_feature op. Checks that the inputs to the
 120  * VFIO_DEVICE_FEATURE ioctl are correct for the driver's feature. Returns 1 if
 121  * the driver should execute the get or set, otherwise the relevant
 122  * value should be returned.
 123  */
 124 static inline int vfio_check_feature(u32 flags, size_t argsz, u32 supported_ops,
 125                                     size_t minsz)
 126 {
 127         if ((flags & (VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_SET)) &
 128             ~supported_ops)
 129                 return -EINVAL;
 130         if (flags & VFIO_DEVICE_FEATURE_PROBE)
 131                 return 0;
 132         /* Without PROBE one of GET or SET must be requested */
 133         if (!(flags & (VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_SET)))
 134                 return -EINVAL;
 135         if (argsz < minsz)
 136                 return -EINVAL;
 137         return 1;
 138 }
 139
 140 void vfio_init_group_dev(struct vfio_device *device, struct device *dev,
 141                          const struct vfio_device_ops *ops);
 142 void vfio_uninit_group_dev(struct vfio_device *device);
 143 int vfio_register_group_dev(struct vfio_device *device);
 144 int vfio_register_emulated_iommu_dev(struct vfio_device *device);
 145 void vfio_unregister_group_dev(struct vfio_device *device);
 146
 147 int vfio_assign_device_set(struct vfio_device *device, void *set_id);
 148
 149 int vfio_mig_get_next_state(struct vfio_device *device,
 150                             enum vfio_device_mig_state cur_fsm,
 151                             enum vfio_device_mig_state new_fsm,
 152                             enum vfio_device_mig_state *next_fsm);
 153
 154 /*
 155  * External user API
 156  */
 157 struct iommu_group *vfio_file_iommu_group(struct file *file);
 158 bool vfio_file_enforced_coherent(struct file *file);
 159 void vfio_file_set_kvm(struct file *file, struct kvm *kvm);
 160 bool vfio_file_has_dev(struct file *file, struct vfio_device *device);
 161
 162 #define VFIO_PIN_PAGES_MAX_ENTRIES      (PAGE_SIZE/sizeof(unsigned long))
 163
 164 int vfio_pin_pages(struct vfio_device *device, unsigned long *user_pfn,
 165                    int npage, int prot, unsigned long *phys_pfn);
 166 int vfio_unpin_pages(struct vfio_device *device, unsigned long *user_pfn,
 167                      int npage);
 168 int vfio_dma_rw(struct vfio_device *device, dma_addr_t user_iova,
 169                 void *data, size_t len, bool write);
 170
 171 /*
 172  * Sub-module helpers
 173  */
 174 struct vfio_info_cap {
 175         struct vfio_info_cap_header *buf;
 176         size_t size;
 177 };
 178 struct vfio_info_cap_header *vfio_info_cap_add(struct vfio_info_cap *caps,
 179                                                size_t size, u16 id,
 180                                                u16 version);
 181 void vfio_info_cap_shift(struct vfio_info_cap *caps, size_t offset);
 182
 183 int vfio_info_add_capability(struct vfio_info_cap *caps,
 184                              struct vfio_info_cap_header *cap, size_t size);
 185
 186 int vfio_set_irqs_validate_and_prepare(struct vfio_irq_set *hdr,
 187                                        int num_irqs, int max_irq_type,
 188                                        size_t *data_size);
 189
 190 struct pci_dev;
 191 #if IS_ENABLED(CONFIG_VFIO_SPAPR_EEH)
 192 void vfio_spapr_pci_eeh_open(struct pci_dev *pdev);
 193 void vfio_spapr_pci_eeh_release(struct pci_dev *pdev);
 194 long vfio_spapr_iommu_eeh_ioctl(struct iommu_group *group, unsigned int cmd,
 195                                 unsigned long arg);
 196 #else
 197 static inline void vfio_spapr_pci_eeh_open(struct pci_dev *pdev)
 198 {
 199 }
 200
 201 static inline void vfio_spapr_pci_eeh_release(struct pci_dev *pdev)
 202 {
 203 }
 204
 205 static inline long vfio_spapr_iommu_eeh_ioctl(struct iommu_group *group,
 206                                               unsigned int cmd,
 207                                               unsigned long arg)
 208 {
 209         return -ENOTTY;
 210 }
 211 #endif /* CONFIG_VFIO_SPAPR_EEH */
 212
 213 /*
 214  * IRQfd - generic
 215  */
 216 struct virqfd {
 217         void                    *opaque;
 218         struct eventfd_ctx      *eventfd;
 219         int                     (*handler)(void *, void *);
 220         void                    (*thread)(void *, void *);
 221         void                    *data;
 222         struct work_struct      inject;
 223         wait_queue_entry_t              wait;
 224         poll_table              pt;
 225         struct work_struct      shutdown;
 226         struct virqfd           **pvirqfd;
 227 };
 228
 229 int vfio_virqfd_enable(void *opaque, int (*handler)(void *, void *),
 230                        void (*thread)(void *, void *), void *data,
 231                        struct virqfd **pvirqfd, int fd);
 232 void vfio_virqfd_disable(struct virqfd **pvirqfd);
 233
 234 #endif /* VFIO_H */