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