4 #include "hw/virtio/vhost-backend.h"
5 #include "hw/virtio/virtio.h"
6 #include "exec/memory.h"
8 #define VHOST_F_DEVICE_IOTLB 63
9 #define VHOST_USER_F_PROTOCOL_FEATURES 30
11 /* Generic structures common for any vhost based device. */
13 struct vhost_inflight
{
21 struct vhost_virtqueue
{
28 unsigned long long desc_phys
;
30 unsigned long long avail_phys
;
32 unsigned long long used_phys
;
34 EventNotifier masked_notifier
;
35 EventNotifier error_notifier
;
36 EventNotifier masked_config_notifier
;
37 struct vhost_dev
*dev
;
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
48 unsigned long long size
;
51 vhost_log_chunk_t
*log
;
56 struct vhost_dev
*hdev
;
60 QLIST_ENTRY(vhost_iommu
) iommu_next
;
63 typedef struct VhostDevConfigOps
{
64 /* Vhost device config space changed callback
66 int (*vhost_dev_config_notifier
)(struct vhost_dev
*dev
);
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)
78 MemoryListener memory_listener
;
79 MemoryListener iommu_listener
;
80 struct vhost_memory
*mem
;
82 MemoryRegionSection
*mem_sections
;
84 MemoryRegionSection
*tmp_sections
;
85 struct vhost_virtqueue
*vqs
;
87 /* the first virtqueue which would be used by this vhost dev */
89 /* one past the last vq index for the virtio device (not vhost) */
91 /* if non-zero, minimum required value for max_queues */
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.
98 * @features: available features provided by the backend
99 * @acked_features: final negotiated features with front-end driver
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.
108 uint64_t acked_features
;
109 uint64_t backend_features
;
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).
117 uint64_t protocol_features
;
120 uint64_t backend_cap
;
121 /* @started: is the vhost device started? */
125 Error
*migration_blocker
;
126 const VhostOps
*vhost_ops
;
128 struct vhost_log
*log
;
129 QLIST_ENTRY(vhost_dev
) entry
;
130 QLIST_HEAD(, vhost_iommu
) iommu_list
;
132 const VhostDevConfigOps
*config_ops
;
135 extern const VhostOps kernel_ops
;
136 extern const VhostOps user_ops
;
137 extern const VhostOps vdpa_ops
;
140 struct vhost_dev dev
;
141 struct vhost_virtqueue vqs
[2];
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
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.
159 * Return: 0 on success, non-zero on error while setting errp.
161 int vhost_dev_init(struct vhost_dev
*hdev
, void *opaque
,
162 VhostBackendType backend_type
,
163 uint32_t busyloop_timeout
, Error
**errp
);
166 * vhost_dev_cleanup() - tear down and cleanup vhost interface
167 * @hdev: the common vhost_dev structure
169 void vhost_dev_cleanup(struct vhost_dev
*hdev
);
172 * vhost_dev_enable_notifiers() - enable event notifiers
173 * @hdev: common vhost_dev structure
174 * @vdev: the VirtIODevice structure
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.
180 * Return: 0 on success, < 0 on error.
182 int vhost_dev_enable_notifiers(struct vhost_dev
*hdev
, VirtIODevice
*vdev
);
185 * vhost_dev_disable_notifiers - disable event notifications
186 * @hdev: common vhost_dev structure
187 * @vdev: the VirtIODevice structure
189 * Disable direct notifications to vhost device.
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
);
196 * vhost_dev_is_started() - report status of vhost device
197 * @hdev: common vhost_dev structure
199 * Return the started status of the vhost device
201 static inline bool vhost_dev_is_started(struct vhost_dev
*hdev
)
203 return hdev
->started
;
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
212 * Starts the vhost device. From this point VirtIO feature negotiation
213 * can start and the device can start processing VirtIO transactions.
215 * Return: 0 on success, < 0 on error.
217 int vhost_dev_start(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, bool vrings
);
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
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).
229 void vhost_dev_stop(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, bool vrings
);
232 * DOC: vhost device configuration handling
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.
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
250 * Return: 0 on success, < 0 on error while setting errp
252 int vhost_dev_get_config(struct vhost_dev
*hdev
, uint8_t *config
,
253 uint32_t config_len
, Error
**errp
);
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
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.
267 * Return: 0 on success, non-zero on error
269 int vhost_dev_set_config(struct vhost_dev
*dev
, const uint8_t *data
,
270 uint32_t offset
, uint32_t size
, uint32_t flags
);
273 * vhost_dev_set_config_notifier() - register VhostDevConfigOps
274 * @hdev: common vhost_dev_structure
277 * If the device is expected to change configuration a notifier can be
278 * setup to handle the case.
280 void vhost_dev_set_config_notifier(struct vhost_dev
*dev
,
281 const VhostDevConfigOps
*ops
);
284 /* Test and clear masked event pending status.
285 * Should be called after unmask to avoid losing events.
287 bool vhost_virtqueue_pending(struct vhost_dev
*hdev
, int n
);
289 /* Mask/unmask events from this vq.
291 void vhost_virtqueue_mask(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, int n
,
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
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.
304 uint64_t vhost_get_features(struct vhost_dev
*hdev
, const int *feature_bits
,
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
313 * This sets the internal hdev->acked_features to the intersection of
314 * the backends advertised features and the supported feature_bits.
316 void vhost_ack_features(struct vhost_dev
*hdev
, const int *feature_bits
,
318 bool vhost_has_free_slot(void);
320 int vhost_net_set_backend(struct vhost_dev
*hdev
,
321 struct vhost_vring_file
*file
);
323 int vhost_device_iotlb_miss(struct vhost_dev
*dev
, uint64_t iova
, int write
);
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
);
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
);