4 * Copyright IBM, Corp. 2007
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
17 #include "exec/memory.h"
18 #include "hw/qdev-core.h"
20 #include "migration/vmstate.h"
21 #include "qemu/event_notifier.h"
22 #include "standard-headers/linux/virtio_config.h"
23 #include "standard-headers/linux/virtio_ring.h"
24 #include "qom/object.h"
27 * A guest should never accept this. It implies negotiation is broken
28 * between the driver frontend and the device. This bit is re-used for
29 * vhost-user to advertise VHOST_USER_F_PROTOCOL_FEATURES between QEMU
30 * and a vhost-user backend.
32 #define VIRTIO_F_BAD_FEATURE 30
34 #define VIRTIO_LEGACY_FEATURES ((0x1ULL << VIRTIO_F_BAD_FEATURE) | \
35 (0x1ULL << VIRTIO_F_NOTIFY_ON_EMPTY) | \
36 (0x1ULL << VIRTIO_F_ANY_LAYOUT))
40 static inline hwaddr
vring_align(hwaddr addr
,
43 return QEMU_ALIGN_UP(addr
, align
);
46 typedef struct VirtIOFeature
{
51 typedef struct VirtIOConfigSizeParams
{
54 const VirtIOFeature
*feature_sizes
;
55 } VirtIOConfigSizeParams
;
57 size_t virtio_get_config_size(const VirtIOConfigSizeParams
*params
,
58 uint64_t host_features
);
60 typedef struct VirtQueue VirtQueue
;
62 #define VIRTQUEUE_MAX_SIZE 1024
64 typedef struct VirtQueueElement
77 #define VIRTIO_QUEUE_MAX 1024
79 #define VIRTIO_NO_VECTOR 0xffff
81 /* special index value used internally for config irqs */
82 #define VIRTIO_CONFIG_IRQ_IDX -1
84 #define TYPE_VIRTIO_DEVICE "virtio-device"
85 OBJECT_DECLARE_TYPE(VirtIODevice
, VirtioDeviceClass
, VIRTIO_DEVICE
)
89 const char *feature_desc
;
90 } qmp_virtio_feature_map_t
;
92 enum virtio_device_endian
{
93 VIRTIO_DEVICE_ENDIAN_UNKNOWN
,
94 VIRTIO_DEVICE_ENDIAN_LITTLE
,
95 VIRTIO_DEVICE_ENDIAN_BIG
,
99 * struct VirtIODevice - common VirtIO structure
100 * @name: name of the device
101 * @status: VirtIO Device Status field
106 DeviceState parent_obj
;
112 * These fields represent a set of VirtIO features at various
113 * levels of the stack. @host_features indicates the complete
114 * feature set the VirtIO device can offer to the driver.
115 * @guest_features indicates which features the VirtIO driver has
116 * selected by writing to the feature register. Finally
117 * @backend_features represents everything supported by the
118 * backend (e.g. vhost) and could potentially be a subset of the
119 * total feature set offered by QEMU.
121 uint64_t host_features
;
122 uint64_t guest_features
;
123 uint64_t backend_features
;
127 uint16_t config_vector
;
131 MemoryListener listener
;
133 /* @vm_running: current VM running state via virtio_vmstate_change() */
135 bool broken
; /* device in invalid state, needs reset */
136 bool use_disabled_flag
; /* allow use of 'disable' flag when needed */
137 bool disabled
; /* device in temporarily disabled state */
139 * @use_started: true if the @started flag should be used to check the
140 * current state of the VirtIO device. Otherwise status bits
141 * should be checked for a current status of the device.
142 * @use_started is only set via QMP and defaults to true for all
143 * modern machines (since 4.1).
147 bool start_on_kick
; /* when virtio 1.0 feature has not been negotiated */
148 bool disable_legacy_check
;
150 VMChangeStateEntry
*vmstate
;
152 uint8_t device_endian
;
153 bool use_guest_notifier_mask
;
154 AddressSpace
*dma_as
;
155 QLIST_HEAD(, VirtQueue
) *vector_queues
;
156 QTAILQ_ENTRY(VirtIODevice
) next
;
157 EventNotifier config_notifier
;
160 struct VirtioDeviceClass
{
165 /* This is what a VirtioDevice must implement */
166 DeviceRealize realize
;
167 DeviceUnrealize unrealize
;
168 uint64_t (*get_features
)(VirtIODevice
*vdev
,
169 uint64_t requested_features
,
171 uint64_t (*bad_features
)(VirtIODevice
*vdev
);
172 void (*set_features
)(VirtIODevice
*vdev
, uint64_t val
);
173 int (*validate_features
)(VirtIODevice
*vdev
);
174 void (*get_config
)(VirtIODevice
*vdev
, uint8_t *config
);
175 void (*set_config
)(VirtIODevice
*vdev
, const uint8_t *config
);
176 void (*reset
)(VirtIODevice
*vdev
);
177 void (*set_status
)(VirtIODevice
*vdev
, uint8_t val
);
178 /* Device must validate queue_index. */
179 void (*queue_reset
)(VirtIODevice
*vdev
, uint32_t queue_index
);
180 /* Device must validate queue_index. */
181 void (*queue_enable
)(VirtIODevice
*vdev
, uint32_t queue_index
);
182 /* For transitional devices, this is a bitmap of features
183 * that are only exposed on the legacy interface but not
186 uint64_t legacy_features
;
187 /* Test and clear event pending status.
188 * Should be called after unmask to avoid losing events.
189 * If backend does not support masking,
190 * must check in frontend instead.
192 bool (*guest_notifier_pending
)(VirtIODevice
*vdev
, int n
);
193 /* Mask/unmask events from this vq. Any events reported
194 * while masked will become pending.
195 * If backend does not support masking,
196 * must mask in frontend instead.
198 void (*guest_notifier_mask
)(VirtIODevice
*vdev
, int n
, bool mask
);
199 int (*start_ioeventfd
)(VirtIODevice
*vdev
);
200 void (*stop_ioeventfd
)(VirtIODevice
*vdev
);
201 /* Saving and loading of a device; trying to deprecate save/load
202 * use vmsd for new devices.
204 void (*save
)(VirtIODevice
*vdev
, QEMUFile
*f
);
205 int (*load
)(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
206 /* Post load hook in vmsd is called early while device is processed, and
207 * when VirtIODevice isn't fully initialized. Devices should use this instead,
208 * unless they specifically want to verify the migration stream as it's
209 * processed, e.g. for bounds checking.
211 int (*post_load
)(VirtIODevice
*vdev
);
212 const VMStateDescription
*vmsd
;
213 bool (*primary_unplug_pending
)(void *opaque
);
214 struct vhost_dev
*(*get_vhost
)(VirtIODevice
*vdev
);
217 void virtio_instance_init_common(Object
*proxy_obj
, void *data
,
218 size_t vdev_size
, const char *vdev_name
);
220 void virtio_init(VirtIODevice
*vdev
, uint16_t device_id
, size_t config_size
);
222 void virtio_cleanup(VirtIODevice
*vdev
);
224 void virtio_error(VirtIODevice
*vdev
, const char *fmt
, ...) G_GNUC_PRINTF(2, 3);
226 /* Set the child bus name. */
227 void virtio_device_set_child_bus_name(VirtIODevice
*vdev
, char *bus_name
);
229 typedef void (*VirtIOHandleOutput
)(VirtIODevice
*, VirtQueue
*);
231 VirtQueue
*virtio_add_queue(VirtIODevice
*vdev
, int queue_size
,
232 VirtIOHandleOutput handle_output
);
234 void virtio_del_queue(VirtIODevice
*vdev
, int n
);
236 void virtio_delete_queue(VirtQueue
*vq
);
238 void virtqueue_push(VirtQueue
*vq
, const VirtQueueElement
*elem
,
240 void virtqueue_flush(VirtQueue
*vq
, unsigned int count
);
241 void virtqueue_detach_element(VirtQueue
*vq
, const VirtQueueElement
*elem
,
243 void virtqueue_unpop(VirtQueue
*vq
, const VirtQueueElement
*elem
,
245 bool virtqueue_rewind(VirtQueue
*vq
, unsigned int num
);
246 void virtqueue_fill(VirtQueue
*vq
, const VirtQueueElement
*elem
,
247 unsigned int len
, unsigned int idx
);
249 void virtqueue_map(VirtIODevice
*vdev
, VirtQueueElement
*elem
);
250 void *virtqueue_pop(VirtQueue
*vq
, size_t sz
);
251 unsigned int virtqueue_drop_all(VirtQueue
*vq
);
252 void *qemu_get_virtqueue_element(VirtIODevice
*vdev
, QEMUFile
*f
, size_t sz
);
253 void qemu_put_virtqueue_element(VirtIODevice
*vdev
, QEMUFile
*f
,
254 VirtQueueElement
*elem
);
255 int virtqueue_avail_bytes(VirtQueue
*vq
, unsigned int in_bytes
,
256 unsigned int out_bytes
);
257 void virtqueue_get_avail_bytes(VirtQueue
*vq
, unsigned int *in_bytes
,
258 unsigned int *out_bytes
,
259 unsigned max_in_bytes
, unsigned max_out_bytes
);
261 void virtio_notify_irqfd(VirtIODevice
*vdev
, VirtQueue
*vq
);
262 void virtio_notify(VirtIODevice
*vdev
, VirtQueue
*vq
);
264 int virtio_save(VirtIODevice
*vdev
, QEMUFile
*f
);
266 extern const VMStateInfo virtio_vmstate_info
;
268 #define VMSTATE_VIRTIO_DEVICE \
271 .info = &virtio_vmstate_info, \
272 .flags = VMS_SINGLE, \
275 int virtio_load(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
277 void virtio_notify_config(VirtIODevice
*vdev
);
279 bool virtio_queue_get_notification(VirtQueue
*vq
);
280 void virtio_queue_set_notification(VirtQueue
*vq
, int enable
);
282 int virtio_queue_ready(VirtQueue
*vq
);
284 int virtio_queue_empty(VirtQueue
*vq
);
286 /* Host binding interface. */
288 uint32_t virtio_config_readb(VirtIODevice
*vdev
, uint32_t addr
);
289 uint32_t virtio_config_readw(VirtIODevice
*vdev
, uint32_t addr
);
290 uint32_t virtio_config_readl(VirtIODevice
*vdev
, uint32_t addr
);
291 void virtio_config_writeb(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
292 void virtio_config_writew(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
293 void virtio_config_writel(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
294 uint32_t virtio_config_modern_readb(VirtIODevice
*vdev
, uint32_t addr
);
295 uint32_t virtio_config_modern_readw(VirtIODevice
*vdev
, uint32_t addr
);
296 uint32_t virtio_config_modern_readl(VirtIODevice
*vdev
, uint32_t addr
);
297 void virtio_config_modern_writeb(VirtIODevice
*vdev
,
298 uint32_t addr
, uint32_t data
);
299 void virtio_config_modern_writew(VirtIODevice
*vdev
,
300 uint32_t addr
, uint32_t data
);
301 void virtio_config_modern_writel(VirtIODevice
*vdev
,
302 uint32_t addr
, uint32_t data
);
303 void virtio_queue_set_addr(VirtIODevice
*vdev
, int n
, hwaddr addr
);
304 hwaddr
virtio_queue_get_addr(VirtIODevice
*vdev
, int n
);
305 void virtio_queue_set_num(VirtIODevice
*vdev
, int n
, int num
);
306 int virtio_queue_get_num(VirtIODevice
*vdev
, int n
);
307 int virtio_queue_get_max_num(VirtIODevice
*vdev
, int n
);
308 int virtio_get_num_queues(VirtIODevice
*vdev
);
309 void virtio_queue_set_rings(VirtIODevice
*vdev
, int n
, hwaddr desc
,
310 hwaddr avail
, hwaddr used
);
311 void virtio_queue_update_rings(VirtIODevice
*vdev
, int n
);
312 void virtio_queue_set_align(VirtIODevice
*vdev
, int n
, int align
);
313 void virtio_queue_notify(VirtIODevice
*vdev
, int n
);
314 uint16_t virtio_queue_vector(VirtIODevice
*vdev
, int n
);
315 void virtio_queue_set_vector(VirtIODevice
*vdev
, int n
, uint16_t vector
);
316 int virtio_queue_set_host_notifier_mr(VirtIODevice
*vdev
, int n
,
317 MemoryRegion
*mr
, bool assign
);
318 int virtio_set_status(VirtIODevice
*vdev
, uint8_t val
);
319 void virtio_reset(void *opaque
);
320 void virtio_queue_reset(VirtIODevice
*vdev
, uint32_t queue_index
);
321 void virtio_queue_enable(VirtIODevice
*vdev
, uint32_t queue_index
);
322 void virtio_update_irq(VirtIODevice
*vdev
);
323 int virtio_set_features(VirtIODevice
*vdev
, uint64_t val
);
326 typedef struct VirtIOBlkConf VirtIOBlkConf
;
327 struct virtio_net_conf
;
328 typedef struct virtio_serial_conf virtio_serial_conf
;
329 typedef struct virtio_input_conf virtio_input_conf
;
330 typedef struct VirtIOSCSIConf VirtIOSCSIConf
;
331 typedef struct VirtIORNGConf VirtIORNGConf
;
333 #define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
334 DEFINE_PROP_BIT64("indirect_desc", _state, _field, \
335 VIRTIO_RING_F_INDIRECT_DESC, true), \
336 DEFINE_PROP_BIT64("event_idx", _state, _field, \
337 VIRTIO_RING_F_EVENT_IDX, true), \
338 DEFINE_PROP_BIT64("notify_on_empty", _state, _field, \
339 VIRTIO_F_NOTIFY_ON_EMPTY, true), \
340 DEFINE_PROP_BIT64("any_layout", _state, _field, \
341 VIRTIO_F_ANY_LAYOUT, true), \
342 DEFINE_PROP_BIT64("iommu_platform", _state, _field, \
343 VIRTIO_F_IOMMU_PLATFORM, false), \
344 DEFINE_PROP_BIT64("packed", _state, _field, \
345 VIRTIO_F_RING_PACKED, false), \
346 DEFINE_PROP_BIT64("queue_reset", _state, _field, \
347 VIRTIO_F_RING_RESET, true)
349 hwaddr
virtio_queue_get_desc_addr(VirtIODevice
*vdev
, int n
);
350 bool virtio_queue_enabled_legacy(VirtIODevice
*vdev
, int n
);
351 bool virtio_queue_enabled(VirtIODevice
*vdev
, int n
);
352 hwaddr
virtio_queue_get_avail_addr(VirtIODevice
*vdev
, int n
);
353 hwaddr
virtio_queue_get_used_addr(VirtIODevice
*vdev
, int n
);
354 hwaddr
virtio_queue_get_desc_size(VirtIODevice
*vdev
, int n
);
355 hwaddr
virtio_queue_get_avail_size(VirtIODevice
*vdev
, int n
);
356 hwaddr
virtio_queue_get_used_size(VirtIODevice
*vdev
, int n
);
357 unsigned int virtio_queue_get_last_avail_idx(VirtIODevice
*vdev
, int n
);
358 void virtio_queue_set_last_avail_idx(VirtIODevice
*vdev
, int n
,
360 void virtio_queue_restore_last_avail_idx(VirtIODevice
*vdev
, int n
);
361 void virtio_queue_invalidate_signalled_used(VirtIODevice
*vdev
, int n
);
362 void virtio_queue_update_used_idx(VirtIODevice
*vdev
, int n
);
363 VirtQueue
*virtio_get_queue(VirtIODevice
*vdev
, int n
);
364 uint16_t virtio_get_queue_index(VirtQueue
*vq
);
365 EventNotifier
*virtio_queue_get_guest_notifier(VirtQueue
*vq
);
366 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
368 int virtio_device_start_ioeventfd(VirtIODevice
*vdev
);
369 int virtio_device_grab_ioeventfd(VirtIODevice
*vdev
);
370 void virtio_device_release_ioeventfd(VirtIODevice
*vdev
);
371 bool virtio_device_ioeventfd_enabled(VirtIODevice
*vdev
);
372 EventNotifier
*virtio_queue_get_host_notifier(VirtQueue
*vq
);
373 void virtio_queue_set_host_notifier_enabled(VirtQueue
*vq
, bool enabled
);
374 void virtio_queue_host_notifier_read(EventNotifier
*n
);
375 void virtio_queue_aio_attach_host_notifier(VirtQueue
*vq
, AioContext
*ctx
);
376 void virtio_queue_aio_attach_host_notifier_no_poll(VirtQueue
*vq
, AioContext
*ctx
);
377 void virtio_queue_aio_detach_host_notifier(VirtQueue
*vq
, AioContext
*ctx
);
378 VirtQueue
*virtio_vector_first_queue(VirtIODevice
*vdev
, uint16_t vector
);
379 VirtQueue
*virtio_vector_next_queue(VirtQueue
*vq
);
380 EventNotifier
*virtio_config_get_guest_notifier(VirtIODevice
*vdev
);
381 void virtio_config_set_guest_notifier_fd_handler(VirtIODevice
*vdev
,
382 bool assign
, bool with_irqfd
);
384 static inline void virtio_add_feature(uint64_t *features
, unsigned int fbit
)
387 *features
|= (1ULL << fbit
);
390 static inline void virtio_clear_feature(uint64_t *features
, unsigned int fbit
)
393 *features
&= ~(1ULL << fbit
);
396 static inline bool virtio_has_feature(uint64_t features
, unsigned int fbit
)
399 return !!(features
& (1ULL << fbit
));
402 static inline bool virtio_vdev_has_feature(VirtIODevice
*vdev
,
405 return virtio_has_feature(vdev
->guest_features
, fbit
);
408 static inline bool virtio_host_has_feature(VirtIODevice
*vdev
,
411 return virtio_has_feature(vdev
->host_features
, fbit
);
414 static inline bool virtio_is_big_endian(VirtIODevice
*vdev
)
416 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
417 assert(vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_UNKNOWN
);
418 return vdev
->device_endian
== VIRTIO_DEVICE_ENDIAN_BIG
;
420 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
425 * virtio_device_started() - check if device started
426 * @vdev - the VirtIO device
427 * @status - the devices status bits
429 * Check if the device is started. For most modern machines this is
430 * tracked via the @vdev->started field (to support migration),
431 * otherwise we check for the final negotiated status bit that
432 * indicates everything is ready.
434 static inline bool virtio_device_started(VirtIODevice
*vdev
, uint8_t status
)
436 if (vdev
->use_started
) {
437 return vdev
->started
;
440 return status
& VIRTIO_CONFIG_S_DRIVER_OK
;
444 * virtio_device_should_start() - check if device startable
445 * @vdev - the VirtIO device
446 * @status - the devices status bits
448 * This is similar to virtio_device_started() but also encapsulates a
449 * check on the VM status which would prevent a device starting
452 static inline bool virtio_device_should_start(VirtIODevice
*vdev
, uint8_t status
)
454 if (!vdev
->vm_running
) {
458 return virtio_device_started(vdev
, status
);
461 static inline void virtio_set_started(VirtIODevice
*vdev
, bool started
)
464 vdev
->start_on_kick
= false;
467 if (vdev
->use_started
) {
468 vdev
->started
= started
;
472 static inline void virtio_set_disabled(VirtIODevice
*vdev
, bool disable
)
474 if (vdev
->use_disabled_flag
) {
475 vdev
->disabled
= disable
;
479 static inline bool virtio_device_disabled(VirtIODevice
*vdev
)
481 return unlikely(vdev
->disabled
|| vdev
->broken
);
484 bool virtio_legacy_allowed(VirtIODevice
*vdev
);
485 bool virtio_legacy_check_disabled(VirtIODevice
*vdev
);