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