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     /**
  92      * vhost feature handling requires matching the feature set
  93      * offered by a backend which may be a subset of the total
  94      * features eventually offered to the guest.
  95      *
  96      * @features: available features provided by the backend
  97      * @acked_features: final negotiated features with front-end driver
  98      *
  99      * @backend_features: this is used in a couple of places to either
 100      * store VHOST_USER_F_PROTOCOL_FEATURES to apply to
 101      * VHOST_USER_SET_FEATURES or VHOST_NET_F_VIRTIO_NET_HDR. Its
 102      * future use should be discouraged and the variable retired as
 103      * its easy to confuse with the VirtIO backend_features.
 104      */
 105     uint64_t features;
 106     uint64_t acked_features;
 107     uint64_t backend_features;
 108
 109     /**
 110      * @protocol_features: is the vhost-user only feature set by
 111      * VHOST_USER_SET_PROTOCOL_FEATURES. Protocol features are only
 112      * negotiated if VHOST_USER_F_PROTOCOL_FEATURES has been offered
 113      * by the backend (see @features).
 114      */
 115     uint64_t protocol_features;
 116
 117     uint64_t max_queues;
 118     uint64_t backend_cap;
 119     /* @started: is the vhost device started? */
 120     bool started;
 121     bool log_enabled;
 122     uint64_t log_size;
 123     Error *migration_blocker;
 124     const VhostOps *vhost_ops;
 125     void *opaque;
 126     struct vhost_log *log;
 127     QLIST_ENTRY(vhost_dev) entry;
 128     QLIST_HEAD(, vhost_iommu) iommu_list;
 129     IOMMUNotifier n;
 130     const VhostDevConfigOps *config_ops;
 131 };
 132
 133 extern const VhostOps kernel_ops;
 134 extern const VhostOps user_ops;
 135 extern const VhostOps vdpa_ops;
 136
 137 struct vhost_net {
 138     struct vhost_dev dev;
 139     struct vhost_virtqueue vqs[2];
 140     int backend;
 141     NetClientState *nc;
 142 };
 143
 144 /**
 145  * vhost_dev_init() - initialise the vhost interface
 146  * @hdev: the common vhost_dev structure
 147  * @opaque: opaque ptr passed to backend (vhost/vhost-user/vdpa)
 148  * @backend_type: type of backend
 149  * @busyloop_timeout: timeout for polling virtqueue
 150  * @errp: error handle
 151  *
 152  * The initialisation of the vhost device will trigger the
 153  * initialisation of the backend and potentially capability
 154  * negotiation of backend interface. Configuration of the VirtIO
 155  * itself won't happen until the interface is started.
 156  *
 157  * Return: 0 on success, non-zero on error while setting errp.
 158  */
 159 int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
 160                    VhostBackendType backend_type,
 161                    uint32_t busyloop_timeout, Error **errp);
 162
 163 /**
 164  * vhost_dev_cleanup() - tear down and cleanup vhost interface
 165  * @hdev: the common vhost_dev structure
 166  */
 167 void vhost_dev_cleanup(struct vhost_dev *hdev);
 168
 169 /**
 170  * vhost_dev_enable_notifiers() - enable event notifiers
 171  * @hdev: common vhost_dev structure
 172  * @vdev: the VirtIODevice structure
 173  *
 174  * Enable notifications directly to the vhost device rather than being
 175  * triggered by QEMU itself. Notifications should be enabled before
 176  * the vhost device is started via @vhost_dev_start.
 177  *
 178  * Return: 0 on success, < 0 on error.
 179  */
 180 int vhost_dev_enable_notifiers(struct vhost_dev *hdev, VirtIODevice *vdev);
 181
 182 /**
 183  * vhost_dev_disable_notifiers - disable event notifications
 184  * @hdev: common vhost_dev structure
 185  * @vdev: the VirtIODevice structure
 186  *
 187  * Disable direct notifications to vhost device.
 188  */
 189 void vhost_dev_disable_notifiers(struct vhost_dev *hdev, VirtIODevice *vdev);
 190
 191 /**
 192  * vhost_dev_is_started() - report status of vhost device
 193  * @hdev: common vhost_dev structure
 194  *
 195  * Return the started status of the vhost device
 196  */
 197 static inline bool vhost_dev_is_started(struct vhost_dev *hdev)
 198 {
 199     return hdev->started;
 200 }
 201
 202 /**
 203  * vhost_dev_start() - start the vhost device
 204  * @hdev: common vhost_dev structure
 205  * @vdev: the VirtIODevice structure
 206  * @vrings: true to have vrings enabled in this call
 207  *
 208  * Starts the vhost device. From this point VirtIO feature negotiation
 209  * can start and the device can start processing VirtIO transactions.
 210  *
 211  * Return: 0 on success, < 0 on error.
 212  */
 213 int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev, bool vrings);
 214
 215 /**
 216  * vhost_dev_stop() - stop the vhost device
 217  * @hdev: common vhost_dev structure
 218  * @vdev: the VirtIODevice structure
 219  * @vrings: true to have vrings disabled in this call
 220  *
 221  * Stop the vhost device. After the device is stopped the notifiers
 222  * can be disabled (@vhost_dev_disable_notifiers) and the device can
 223  * be torn down (@vhost_dev_cleanup).
 224  */
 225 void vhost_dev_stop(struct vhost_dev *hdev, VirtIODevice *vdev, bool vrings);
 226
 227 /**
 228  * DOC: vhost device configuration handling
 229  *
 230  * The VirtIO device configuration space is used for rarely changing
 231  * or initialisation time parameters. The configuration can be updated
 232  * by either the guest driver or the device itself. If the device can
 233  * change the configuration over time the vhost handler should
 234  * register a @VhostDevConfigOps structure with
 235  * @vhost_dev_set_config_notifier so the guest can be notified. Some
 236  * devices register a handler anyway and will signal an error if an
 237  * unexpected config change happens.
 238  */
 239
 240 /**
 241  * vhost_dev_get_config() - fetch device configuration
 242  * @hdev: common vhost_dev_structure
 243  * @config: pointer to device appropriate config structure
 244  * @config_len: size of device appropriate config structure
 245  *
 246  * Return: 0 on success, < 0 on error while setting errp
 247  */
 248 int vhost_dev_get_config(struct vhost_dev *hdev, uint8_t *config,
 249                          uint32_t config_len, Error **errp);
 250
 251 /**
 252  * vhost_dev_set_config() - set device configuration
 253  * @hdev: common vhost_dev_structure
 254  * @data: pointer to data to set
 255  * @offset: offset into configuration space
 256  * @size: length of set
 257  * @flags: @VhostSetConfigType flags
 258  *
 259  * By use of @offset/@size a subset of the configuration space can be
 260  * written to. The @flags are used to indicate if it is a normal
 261  * transaction or related to migration.
 262  *
 263  * Return: 0 on success, non-zero on error
 264  */
 265 int vhost_dev_set_config(struct vhost_dev *dev, const uint8_t *data,
 266                          uint32_t offset, uint32_t size, uint32_t flags);
 267
 268 /**
 269  * vhost_dev_set_config_notifier() - register VhostDevConfigOps
 270  * @hdev: common vhost_dev_structure
 271  * @ops: notifier ops
 272  *
 273  * If the device is expected to change configuration a notifier can be
 274  * setup to handle the case.
 275  */
 276 void vhost_dev_set_config_notifier(struct vhost_dev *dev,
 277                                    const VhostDevConfigOps *ops);
 278
 279
 280 /* Test and clear masked event pending status.
 281  * Should be called after unmask to avoid losing events.
 282  */
 283 bool vhost_virtqueue_pending(struct vhost_dev *hdev, int n);
 284
 285 /* Mask/unmask events from this vq.
 286  */
 287 void vhost_virtqueue_mask(struct vhost_dev *hdev, VirtIODevice *vdev, int n,
 288                           bool mask);
 289
 290 /**
 291  * vhost_get_features() - return a sanitised set of feature bits
 292  * @hdev: common vhost_dev structure
 293  * @feature_bits: pointer to terminated table of feature bits
 294  * @features: original feature set
 295  *
 296  * This returns a set of features bits that is an intersection of what
 297  * is supported by the vhost backend (hdev->features), the supported
 298  * feature_bits and the requested feature set.
 299  */
 300 uint64_t vhost_get_features(struct vhost_dev *hdev, const int *feature_bits,
 301                             uint64_t features);
 302
 303 /**
 304  * vhost_ack_features() - set vhost acked_features
 305  * @hdev: common vhost_dev structure
 306  * @feature_bits: pointer to terminated table of feature bits
 307  * @features: requested feature set
 308  *
 309  * This sets the internal hdev->acked_features to the intersection of
 310  * the backends advertised features and the supported feature_bits.
 311  */
 312 void vhost_ack_features(struct vhost_dev *hdev, const int *feature_bits,
 313                         uint64_t features);
 314 bool vhost_has_free_slot(void);
 315
 316 int vhost_net_set_backend(struct vhost_dev *hdev,
 317                           struct vhost_vring_file *file);
 318
 319 int vhost_device_iotlb_miss(struct vhost_dev *dev, uint64_t iova, int write);
 320
 321 int vhost_virtqueue_start(struct vhost_dev *dev, struct VirtIODevice *vdev,
 322                           struct vhost_virtqueue *vq, unsigned idx);
 323 void vhost_virtqueue_stop(struct vhost_dev *dev, struct VirtIODevice *vdev,
 324                           struct vhost_virtqueue *vq, unsigned idx);
 325
 326 void vhost_dev_reset_inflight(struct vhost_inflight *inflight);
 327 void vhost_dev_free_inflight(struct vhost_inflight *inflight);
 328 void vhost_dev_save_inflight(struct vhost_inflight *inflight, QEMUFile *f);
 329 int vhost_dev_load_inflight(struct vhost_inflight *inflight, QEMUFile *f);
 330 int vhost_dev_prepare_inflight(struct vhost_dev *hdev, VirtIODevice *vdev);
 331 int vhost_dev_set_inflight(struct vhost_dev *dev,
 332                            struct vhost_inflight *inflight);
 333 int vhost_dev_get_inflight(struct vhost_dev *dev, uint16_t queue_size,
 334                            struct vhost_inflight *inflight);
 335 #endif