include/hw/virtio/vhost.h

   1 #ifndef VHOST_H
   2 #define VHOST_H
   3
   4 #include "hw/virtio/vhost-backend.h"
   5 #include "hw/virtio/virtio.h"
   6 #include "exec/memory.h"
   7
   8 #define VHOST_F_DEVICE_IOTLB 63
   9 #define VHOST_USER_F_PROTOCOL_FEATURES 30
  10
  11 /* Generic structures common for any vhost based device. */
  12
  13 struct vhost_inflight {
  14     int fd;
  15     void *addr;
  16     uint64_t size;
  17     uint64_t offset;
  18     uint16_t queue_size;
  19 };
  20
  21 struct vhost_virtqueue {
  22     int kick;
  23     int call;
  24     void *desc;
  25     void *avail;
  26     void *used;
  27     int num;
  28     unsigned long long desc_phys;
  29     unsigned desc_size;
  30     unsigned long long avail_phys;
  31     unsigned avail_size;
  32     unsigned long long used_phys;
  33     unsigned used_size;
  34     EventNotifier masked_notifier;
  35     EventNotifier error_notifier;
  36     struct vhost_dev *dev;
  37 };
  38
  39 typedef unsigned long vhost_log_chunk_t;
  40 #define VHOST_LOG_PAGE 0x1000
  41 #define VHOST_LOG_BITS (8 * sizeof(vhost_log_chunk_t))
  42 #define VHOST_LOG_CHUNK (VHOST_LOG_PAGE * VHOST_LOG_BITS)
  43 #define VHOST_INVALID_FEATURE_BIT   (0xff)
  44
  45 struct vhost_log {
  46     unsigned long long size;
  47     int refcnt;
  48     int fd;
  49     vhost_log_chunk_t *log;
  50 };
  51
  52 struct vhost_dev;
  53 struct vhost_iommu {
  54     struct vhost_dev *hdev;
  55     MemoryRegion *mr;
  56     hwaddr iommu_offset;
  57     IOMMUNotifier n;
  58     QLIST_ENTRY(vhost_iommu) iommu_next;
  59 };
  60
  61 typedef struct VhostDevConfigOps {
  62     /* Vhost device config space changed callback
  63      */
  64     int (*vhost_dev_config_notifier)(struct vhost_dev *dev);
  65 } VhostDevConfigOps;
  66
  67 struct vhost_memory;
  68
  69 /**
  70  * struct vhost_dev - common vhost_dev structure
  71  * @vhost_ops: backend specific ops
  72  * @config_ops: ops for config changes (see @vhost_dev_set_config_notifier)
  73  */
  74 struct vhost_dev {
  75     VirtIODevice *vdev;
  76     MemoryListener memory_listener;
  77     MemoryListener iommu_listener;
  78     struct vhost_memory *mem;
  79     int n_mem_sections;
  80     MemoryRegionSection *mem_sections;
  81     int n_tmp_sections;
  82     MemoryRegionSection *tmp_sections;
  83     struct vhost_virtqueue *vqs;
  84     unsigned int nvqs;
  85     /* the first virtqueue which would be used by this vhost dev */
  86     int vq_index;
  87     /* one past the last vq index for the virtio device (not vhost) */
  88     int vq_index_end;
  89     /* if non-zero, minimum required value for max_queues */
  90     int num_queues;
  91     uint64_t features;
  92     /** @acked_features: final set of negotiated features */
  93     uint64_t acked_features;
  94     /** @backend_features: backend specific feature bits */
  95     uint64_t backend_features;
  96     /** @protocol_features: final negotiated protocol features */
  97     uint64_t protocol_features;
  98     uint64_t max_queues;
  99     uint64_t backend_cap;
 100     /* @started: is the vhost device started? */
 101     bool started;
 102     bool log_enabled;
 103     uint64_t log_size;
 104     Error *migration_blocker;
 105     const VhostOps *vhost_ops;
 106     void *opaque;
 107     struct vhost_log *log;
 108     QLIST_ENTRY(vhost_dev) entry;
 109     QLIST_HEAD(, vhost_iommu) iommu_list;
 110     IOMMUNotifier n;
 111     const VhostDevConfigOps *config_ops;
 112 };
 113
 114 extern const VhostOps kernel_ops;
 115 extern const VhostOps user_ops;
 116 extern const VhostOps vdpa_ops;
 117
 118 struct vhost_net {
 119     struct vhost_dev dev;
 120     struct vhost_virtqueue vqs[2];
 121     int backend;
 122     NetClientState *nc;
 123 };
 124
 125 /**
 126  * vhost_dev_init() - initialise the vhost interface
 127  * @hdev: the common vhost_dev structure
 128  * @opaque: opaque ptr passed to backend (vhost/vhost-user/vdpa)
 129  * @backend_type: type of backend
 130  * @busyloop_timeout: timeout for polling virtqueue
 131  * @errp: error handle
 132  *
 133  * The initialisation of the vhost device will trigger the
 134  * initialisation of the backend and potentially capability
 135  * negotiation of backend interface. Configuration of the VirtIO
 136  * itself won't happen until the interface is started.
 137  *
 138  * Return: 0 on success, non-zero on error while setting errp.
 139  */
 140 int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
 141                    VhostBackendType backend_type,
 142                    uint32_t busyloop_timeout, Error **errp);
 143
 144 /**
 145  * vhost_dev_cleanup() - tear down and cleanup vhost interface
 146  * @hdev: the common vhost_dev structure
 147  */
 148 void vhost_dev_cleanup(struct vhost_dev *hdev);
 149
 150 /**
 151  * vhost_dev_enable_notifiers() - enable event notifiers
 152  * @hdev: common vhost_dev structure
 153  * @vdev: the VirtIODevice structure
 154  *
 155  * Enable notifications directly to the vhost device rather than being
 156  * triggered by QEMU itself. Notifications should be enabled before
 157  * the vhost device is started via @vhost_dev_start.
 158  *
 159  * Return: 0 on success, < 0 on error.
 160  */
 161 int vhost_dev_enable_notifiers(struct vhost_dev *hdev, VirtIODevice *vdev);
 162
 163 /**
 164  * vhost_dev_disable_notifiers - disable event notifications
 165  * @hdev: common vhost_dev structure
 166  * @vdev: the VirtIODevice structure
 167  *
 168  * Disable direct notifications to vhost device.
 169  */
 170 void vhost_dev_disable_notifiers(struct vhost_dev *hdev, VirtIODevice *vdev);
 171
 172 /**
 173  * vhost_dev_is_started() - report status of vhost device
 174  * @hdev: common vhost_dev structure
 175  *
 176  * Return the started status of the vhost device
 177  */
 178 static inline bool vhost_dev_is_started(struct vhost_dev *hdev)
 179 {
 180     return hdev->started;
 181 }
 182
 183 /**
 184  * vhost_dev_start() - start the vhost device
 185  * @hdev: common vhost_dev structure
 186  * @vdev: the VirtIODevice structure
 187  *
 188  * Starts the vhost device. From this point VirtIO feature negotiation
 189  * can start and the device can start processing VirtIO transactions.
 190  *
 191  * Return: 0 on success, < 0 on error.
 192  */
 193 int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev);
 194
 195 /**
 196  * vhost_dev_stop() - stop the vhost device
 197  * @hdev: common vhost_dev structure
 198  * @vdev: the VirtIODevice structure
 199  *
 200  * Stop the vhost device. After the device is stopped the notifiers
 201  * can be disabled (@vhost_dev_disable_notifiers) and the device can
 202  * be torn down (@vhost_dev_cleanup).
 203  */
 204 void vhost_dev_stop(struct vhost_dev *hdev, VirtIODevice *vdev);
 205
 206 /**
 207  * DOC: vhost device configuration handling
 208  *
 209  * The VirtIO device configuration space is used for rarely changing
 210  * or initialisation time parameters. The configuration can be updated
 211  * by either the guest driver or the device itself. If the device can
 212  * change the configuration over time the vhost handler should
 213  * register a @VhostDevConfigOps structure with
 214  * @vhost_dev_set_config_notifier so the guest can be notified. Some
 215  * devices register a handler anyway and will signal an error if an
 216  * unexpected config change happens.
 217  */
 218
 219 /**
 220  * vhost_dev_get_config() - fetch device configuration
 221  * @hdev: common vhost_dev_structure
 222  * @config: pointer to device appropriate config structure
 223  * @config_len: size of device appropriate config structure
 224  *
 225  * Return: 0 on success, < 0 on error while setting errp
 226  */
 227 int vhost_dev_get_config(struct vhost_dev *hdev, uint8_t *config,
 228                          uint32_t config_len, Error **errp);
 229
 230 /**
 231  * vhost_dev_set_config() - set device configuration
 232  * @hdev: common vhost_dev_structure
 233  * @data: pointer to data to set
 234  * @offset: offset into configuration space
 235  * @size: length of set
 236  * @flags: @VhostSetConfigType flags
 237  *
 238  * By use of @offset/@size a subset of the configuration space can be
 239  * written to. The @flags are used to indicate if it is a normal
 240  * transaction or related to migration.
 241  *
 242  * Return: 0 on success, non-zero on error
 243  */
 244 int vhost_dev_set_config(struct vhost_dev *dev, const uint8_t *data,
 245                          uint32_t offset, uint32_t size, uint32_t flags);
 246
 247 /**
 248  * vhost_dev_set_config_notifier() - register VhostDevConfigOps
 249  * @hdev: common vhost_dev_structure
 250  * @ops: notifier ops
 251  *
 252  * If the device is expected to change configuration a notifier can be
 253  * setup to handle the case.
 254  */
 255 void vhost_dev_set_config_notifier(struct vhost_dev *dev,
 256                                    const VhostDevConfigOps *ops);
 257
 258
 259 /* Test and clear masked event pending status.
 260  * Should be called after unmask to avoid losing events.
 261  */
 262 bool vhost_virtqueue_pending(struct vhost_dev *hdev, int n);
 263
 264 /* Mask/unmask events from this vq.
 265  */
 266 void vhost_virtqueue_mask(struct vhost_dev *hdev, VirtIODevice *vdev, int n,
 267                           bool mask);
 268
 269 /**
 270  * vhost_get_features() - return a sanitised set of feature bits
 271  * @hdev: common vhost_dev structure
 272  * @feature_bits: pointer to terminated table of feature bits
 273  * @features: original feature set
 274  *
 275  * This returns a set of features bits that is an intersection of what
 276  * is supported by the vhost backend (hdev->features), the supported
 277  * feature_bits and the requested feature set.
 278  */
 279 uint64_t vhost_get_features(struct vhost_dev *hdev, const int *feature_bits,
 280                             uint64_t features);
 281
 282 /**
 283  * vhost_ack_features() - set vhost acked_features
 284  * @hdev: common vhost_dev structure
 285  * @feature_bits: pointer to terminated table of feature bits
 286  * @features: requested feature set
 287  *
 288  * This sets the internal hdev->acked_features to the intersection of
 289  * the backends advertised features and the supported feature_bits.
 290  */
 291 void vhost_ack_features(struct vhost_dev *hdev, const int *feature_bits,
 292                         uint64_t features);
 293 bool vhost_has_free_slot(void);
 294
 295 int vhost_net_set_backend(struct vhost_dev *hdev,
 296                           struct vhost_vring_file *file);
 297
 298 int vhost_device_iotlb_miss(struct vhost_dev *dev, uint64_t iova, int write);
 299
 300 void vhost_dev_reset_inflight(struct vhost_inflight *inflight);
 301 void vhost_dev_free_inflight(struct vhost_inflight *inflight);
 302 void vhost_dev_save_inflight(struct vhost_inflight *inflight, QEMUFile *f);
 303 int vhost_dev_load_inflight(struct vhost_inflight *inflight, QEMUFile *f);
 304 int vhost_dev_prepare_inflight(struct vhost_dev *hdev, VirtIODevice *vdev);
 305 int vhost_dev_set_inflight(struct vhost_dev *dev,
 306                            struct vhost_inflight *inflight);
 307 int vhost_dev_get_inflight(struct vhost_dev *dev, uint16_t queue_size,
 308                            struct vhost_inflight *inflight);
 309 #endif