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 #define VU_REALIZE_CONN_RETRIES 3
13 /* Generic structures common for any vhost based device. */
15 struct vhost_inflight
{
23 struct vhost_virtqueue
{
30 unsigned long long desc_phys
;
32 unsigned long long avail_phys
;
34 unsigned long long used_phys
;
36 EventNotifier masked_notifier
;
37 EventNotifier error_notifier
;
38 EventNotifier masked_config_notifier
;
39 struct vhost_dev
*dev
;
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
50 unsigned long long size
;
53 vhost_log_chunk_t
*log
;
58 struct vhost_dev
*hdev
;
62 QLIST_ENTRY(vhost_iommu
) iommu_next
;
65 typedef struct VhostDevConfigOps
{
66 /* Vhost device config space changed callback
68 int (*vhost_dev_config_notifier
)(struct vhost_dev
*dev
);
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)
80 MemoryListener memory_listener
;
81 MemoryListener iommu_listener
;
82 struct vhost_memory
*mem
;
84 MemoryRegionSection
*mem_sections
;
86 MemoryRegionSection
*tmp_sections
;
87 struct vhost_virtqueue
*vqs
;
89 /* the first virtqueue which would be used by this vhost dev */
91 /* one past the last vq index for the virtio device (not vhost) */
93 /* if non-zero, minimum required value for max_queues */
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.
100 * @features: available features provided by the backend
101 * @acked_features: final negotiated features with front-end driver
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.
110 uint64_t acked_features
;
111 uint64_t backend_features
;
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).
119 uint64_t protocol_features
;
122 uint64_t backend_cap
;
123 /* @started: is the vhost device started? */
127 Error
*migration_blocker
;
128 const VhostOps
*vhost_ops
;
130 struct vhost_log
*log
;
131 QLIST_ENTRY(vhost_dev
) entry
;
132 QLIST_HEAD(, vhost_iommu
) iommu_list
;
134 const VhostDevConfigOps
*config_ops
;
137 extern const VhostOps kernel_ops
;
138 extern const VhostOps user_ops
;
139 extern const VhostOps vdpa_ops
;
142 struct vhost_dev dev
;
143 struct vhost_virtqueue vqs
[2];
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
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.
161 * Return: 0 on success, non-zero on error while setting errp.
163 int vhost_dev_init(struct vhost_dev
*hdev
, void *opaque
,
164 VhostBackendType backend_type
,
165 uint32_t busyloop_timeout
, Error
**errp
);
168 * vhost_dev_cleanup() - tear down and cleanup vhost interface
169 * @hdev: the common vhost_dev structure
171 void vhost_dev_cleanup(struct vhost_dev
*hdev
);
174 * vhost_dev_enable_notifiers() - enable event notifiers
175 * @hdev: common vhost_dev structure
176 * @vdev: the VirtIODevice structure
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.
182 * Return: 0 on success, < 0 on error.
184 int vhost_dev_enable_notifiers(struct vhost_dev
*hdev
, VirtIODevice
*vdev
);
187 * vhost_dev_disable_notifiers - disable event notifications
188 * @hdev: common vhost_dev structure
189 * @vdev: the VirtIODevice structure
191 * Disable direct notifications to vhost device.
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
);
198 * vhost_dev_is_started() - report status of vhost device
199 * @hdev: common vhost_dev structure
201 * Return the started status of the vhost device
203 static inline bool vhost_dev_is_started(struct vhost_dev
*hdev
)
205 return hdev
->started
;
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
214 * Starts the vhost device. From this point VirtIO feature negotiation
215 * can start and the device can start processing VirtIO transactions.
217 * Return: 0 on success, < 0 on error.
219 int vhost_dev_start(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, bool vrings
);
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
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).
231 void vhost_dev_stop(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, bool vrings
);
234 * DOC: vhost device configuration handling
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.
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
252 * Return: 0 on success, < 0 on error while setting errp
254 int vhost_dev_get_config(struct vhost_dev
*hdev
, uint8_t *config
,
255 uint32_t config_len
, Error
**errp
);
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
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.
269 * Return: 0 on success, non-zero on error
271 int vhost_dev_set_config(struct vhost_dev
*dev
, const uint8_t *data
,
272 uint32_t offset
, uint32_t size
, uint32_t flags
);
275 * vhost_dev_set_config_notifier() - register VhostDevConfigOps
276 * @hdev: common vhost_dev_structure
279 * If the device is expected to change configuration a notifier can be
280 * setup to handle the case.
282 void vhost_dev_set_config_notifier(struct vhost_dev
*dev
,
283 const VhostDevConfigOps
*ops
);
286 /* Test and clear masked event pending status.
287 * Should be called after unmask to avoid losing events.
289 bool vhost_virtqueue_pending(struct vhost_dev
*hdev
, int n
);
291 /* Mask/unmask events from this vq.
293 void vhost_virtqueue_mask(struct vhost_dev
*hdev
, VirtIODevice
*vdev
, int n
,
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
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.
306 uint64_t vhost_get_features(struct vhost_dev
*hdev
, const int *feature_bits
,
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
315 * This sets the internal hdev->acked_features to the intersection of
316 * the backends advertised features and the supported feature_bits.
318 void vhost_ack_features(struct vhost_dev
*hdev
, const int *feature_bits
,
320 unsigned int vhost_get_max_memslots(void);
321 unsigned int vhost_get_free_memslots(void);
323 int vhost_net_set_backend(struct vhost_dev
*hdev
,
324 struct vhost_vring_file
*file
);
326 void vhost_toggle_device_iotlb(VirtIODevice
*vdev
);
327 int vhost_device_iotlb_miss(struct vhost_dev
*dev
, uint64_t iova
, int write
);
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
);
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
);
346 int vhost_reset_device(struct vhost_dev
*hdev
);
348 static inline int vhost_reset_device(struct vhost_dev
*hdev
)
352 #endif /* CONFIG_VHOST */
355 * vhost_supports_device_state(): Checks whether the back-end supports
356 * transferring internal device state for the purpose of migration.
357 * Support for this feature is required for vhost_set_device_state_fd()
358 * and vhost_check_device_state().
360 * @dev: The vhost device
362 * Returns true if the device supports these commands, and false if it
365 bool vhost_supports_device_state(struct vhost_dev
*dev
);
368 * vhost_set_device_state_fd(): Begin transfer of internal state from/to
369 * the back-end for the purpose of migration. Data is to be transferred
370 * over a pipe according to @direction and @phase. The sending end must
371 * only write to the pipe, and the receiving end must only read from it.
372 * Once the sending end is done, it closes its FD. The receiving end
373 * must take this as the end-of-transfer signal and close its FD, too.
375 * @fd is the back-end's end of the pipe: The write FD for SAVE, and the
376 * read FD for LOAD. This function transfers ownership of @fd to the
377 * back-end, i.e. closes it in the front-end.
379 * The back-end may optionally reply with an FD of its own, if this
380 * improves efficiency on its end. In this case, the returned FD is
381 * stored in *reply_fd. The back-end will discard the FD sent to it,
382 * and the front-end must use *reply_fd for transferring state to/from
385 * @dev: The vhost device
386 * @direction: The direction in which the state is to be transferred.
387 * For outgoing migrations, this is SAVE, and data is read
388 * from the back-end and stored by the front-end in the
390 * For incoming migrations, this is LOAD, and data is read
391 * by the front-end from the migration stream and sent to
392 * the back-end to restore the saved state.
393 * @phase: Which migration phase we are in. Currently, there is only
394 * STOPPED (device and all vrings are stopped), in the future,
395 * more phases such as PRE_COPY or POST_COPY may be added.
396 * @fd: Back-end's end of the pipe through which to transfer state; note
397 * that ownership is transferred to the back-end, so this function
398 * closes @fd in the front-end.
399 * @reply_fd: If the back-end wishes to use a different pipe for state
400 * transfer, this will contain an FD for the front-end to
401 * use. Otherwise, -1 is stored here.
402 * @errp: Potential error description
404 * Returns 0 on success, and -errno on failure.
406 int vhost_set_device_state_fd(struct vhost_dev
*dev
,
407 VhostDeviceStateDirection direction
,
408 VhostDeviceStatePhase phase
,
414 * vhost_set_device_state_fd(): After transferring state from/to the
415 * back-end via vhost_set_device_state_fd(), i.e. once the sending end
416 * has closed the pipe, inquire the back-end to report any potential
417 * errors that have occurred on its side. This allows to sense errors
419 * - During outgoing migration, when the source side had already started
420 * to produce its state, something went wrong and it failed to finish
421 * - During incoming migration, when the received state is somehow
422 * invalid and cannot be processed by the back-end
424 * @dev: The vhost device
425 * @errp: Potential error description
427 * Returns 0 when the back-end reports successful state transfer and
428 * processing, and -errno when an error occurred somewhere.
430 int vhost_check_device_state(struct vhost_dev
*dev
, Error
**errp
);
433 * vhost_save_backend_state(): High-level function to receive a vhost
434 * back-end's state, and save it in @f. Uses
435 * `vhost_set_device_state_fd()` to get the data from the back-end, and
436 * stores it in consecutive chunks that are each prefixed by their
437 * respective length (be32). The end is marked by a 0-length chunk.
439 * Must only be called while the device and all its vrings are stopped
440 * (`VHOST_TRANSFER_STATE_PHASE_STOPPED`).
442 * @dev: The vhost device from which to save the state
443 * @f: Migration stream in which to save the state
444 * @errp: Potential error message
446 * Returns 0 on success, and -errno otherwise.
448 int vhost_save_backend_state(struct vhost_dev
*dev
, QEMUFile
*f
, Error
**errp
);
451 * vhost_load_backend_state(): High-level function to load a vhost
452 * back-end's state from @f, and send it over to the back-end. Reads
453 * the data from @f in the format used by `vhost_save_state()`, and uses
454 * `vhost_set_device_state_fd()` to transfer it to the back-end.
456 * Must only be called while the device and all its vrings are stopped
457 * (`VHOST_TRANSFER_STATE_PHASE_STOPPED`).
459 * @dev: The vhost device to which to send the sate
460 * @f: Migration stream from which to load the state
461 * @errp: Potential error message
463 * Returns 0 on success, and -errno otherwise.
465 int vhost_load_backend_state(struct vhost_dev
*dev
, QEMUFile
*f
, Error
**errp
);