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