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"
26 /* A guest should never accept this. It implies negotiation is broken. */
27 #define VIRTIO_F_BAD_FEATURE 30
29 #define VIRTIO_LEGACY_FEATURES ((0x1ULL << VIRTIO_F_BAD_FEATURE) | \
30 (0x1ULL << VIRTIO_F_NOTIFY_ON_EMPTY) | \
31 (0x1ULL << VIRTIO_F_ANY_LAYOUT))
35 static inline hwaddr
vring_align(hwaddr addr
,
38 return QEMU_ALIGN_UP(addr
, align
);
41 typedef struct VirtIOFeature
{
46 size_t virtio_feature_get_config_size(VirtIOFeature
*features
,
47 uint64_t host_features
);
49 typedef struct VirtQueue VirtQueue
;
51 #define VIRTQUEUE_MAX_SIZE 1024
53 typedef struct VirtQueueElement
66 #define VIRTIO_QUEUE_MAX 1024
68 #define VIRTIO_NO_VECTOR 0xffff
70 #define TYPE_VIRTIO_DEVICE "virtio-device"
71 typedef struct VirtioDeviceClass VirtioDeviceClass
;
72 DECLARE_OBJ_CHECKERS(VirtIODevice
, VirtioDeviceClass
,
73 VIRTIO_DEVICE
, TYPE_VIRTIO_DEVICE
)
75 enum virtio_device_endian
{
76 VIRTIO_DEVICE_ENDIAN_UNKNOWN
,
77 VIRTIO_DEVICE_ENDIAN_LITTLE
,
78 VIRTIO_DEVICE_ENDIAN_BIG
,
83 DeviceState parent_obj
;
88 uint64_t guest_features
;
89 uint64_t host_features
;
90 uint64_t backend_features
;
93 uint16_t config_vector
;
97 MemoryListener listener
;
100 bool broken
; /* device in invalid state, needs reset */
101 bool use_disabled_flag
; /* allow use of 'disable' flag when needed */
102 bool disabled
; /* device in temporarily disabled state */
105 bool start_on_kick
; /* when virtio 1.0 feature has not been negotiated */
106 VMChangeStateEntry
*vmstate
;
108 uint8_t device_endian
;
109 bool use_guest_notifier_mask
;
110 AddressSpace
*dma_as
;
111 QLIST_HEAD(, VirtQueue
) *vector_queues
;
114 struct VirtioDeviceClass
{
119 /* This is what a VirtioDevice must implement */
120 DeviceRealize realize
;
121 DeviceUnrealize unrealize
;
122 uint64_t (*get_features
)(VirtIODevice
*vdev
,
123 uint64_t requested_features
,
125 uint64_t (*bad_features
)(VirtIODevice
*vdev
);
126 void (*set_features
)(VirtIODevice
*vdev
, uint64_t val
);
127 int (*validate_features
)(VirtIODevice
*vdev
);
128 void (*get_config
)(VirtIODevice
*vdev
, uint8_t *config
);
129 void (*set_config
)(VirtIODevice
*vdev
, const uint8_t *config
);
130 void (*reset
)(VirtIODevice
*vdev
);
131 void (*set_status
)(VirtIODevice
*vdev
, uint8_t val
);
132 /* For transitional devices, this is a bitmap of features
133 * that are only exposed on the legacy interface but not
136 uint64_t legacy_features
;
137 /* Test and clear event pending status.
138 * Should be called after unmask to avoid losing events.
139 * If backend does not support masking,
140 * must check in frontend instead.
142 bool (*guest_notifier_pending
)(VirtIODevice
*vdev
, int n
);
143 /* Mask/unmask events from this vq. Any events reported
144 * while masked will become pending.
145 * If backend does not support masking,
146 * must mask in frontend instead.
148 void (*guest_notifier_mask
)(VirtIODevice
*vdev
, int n
, bool mask
);
149 int (*start_ioeventfd
)(VirtIODevice
*vdev
);
150 void (*stop_ioeventfd
)(VirtIODevice
*vdev
);
151 /* Saving and loading of a device; trying to deprecate save/load
152 * use vmsd for new devices.
154 void (*save
)(VirtIODevice
*vdev
, QEMUFile
*f
);
155 int (*load
)(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
156 /* Post load hook in vmsd is called early while device is processed, and
157 * when VirtIODevice isn't fully initialized. Devices should use this instead,
158 * unless they specifically want to verify the migration stream as it's
159 * processed, e.g. for bounds checking.
161 int (*post_load
)(VirtIODevice
*vdev
);
162 const VMStateDescription
*vmsd
;
163 bool (*primary_unplug_pending
)(void *opaque
);
166 void virtio_instance_init_common(Object
*proxy_obj
, void *data
,
167 size_t vdev_size
, const char *vdev_name
);
169 void virtio_init(VirtIODevice
*vdev
, const char *name
,
170 uint16_t device_id
, size_t config_size
);
171 void virtio_cleanup(VirtIODevice
*vdev
);
173 void virtio_error(VirtIODevice
*vdev
, const char *fmt
, ...) GCC_FMT_ATTR(2, 3);
175 /* Set the child bus name. */
176 void virtio_device_set_child_bus_name(VirtIODevice
*vdev
, char *bus_name
);
178 typedef void (*VirtIOHandleOutput
)(VirtIODevice
*, VirtQueue
*);
179 typedef bool (*VirtIOHandleAIOOutput
)(VirtIODevice
*, VirtQueue
*);
181 VirtQueue
*virtio_add_queue(VirtIODevice
*vdev
, int queue_size
,
182 VirtIOHandleOutput handle_output
);
184 void virtio_del_queue(VirtIODevice
*vdev
, int n
);
186 void virtio_delete_queue(VirtQueue
*vq
);
188 void virtqueue_push(VirtQueue
*vq
, const VirtQueueElement
*elem
,
190 void virtqueue_flush(VirtQueue
*vq
, unsigned int count
);
191 void virtqueue_detach_element(VirtQueue
*vq
, const VirtQueueElement
*elem
,
193 void virtqueue_unpop(VirtQueue
*vq
, const VirtQueueElement
*elem
,
195 bool virtqueue_rewind(VirtQueue
*vq
, unsigned int num
);
196 void virtqueue_fill(VirtQueue
*vq
, const VirtQueueElement
*elem
,
197 unsigned int len
, unsigned int idx
);
199 void virtqueue_map(VirtIODevice
*vdev
, VirtQueueElement
*elem
);
200 void *virtqueue_pop(VirtQueue
*vq
, size_t sz
);
201 unsigned int virtqueue_drop_all(VirtQueue
*vq
);
202 void *qemu_get_virtqueue_element(VirtIODevice
*vdev
, QEMUFile
*f
, size_t sz
);
203 void qemu_put_virtqueue_element(VirtIODevice
*vdev
, QEMUFile
*f
,
204 VirtQueueElement
*elem
);
205 int virtqueue_avail_bytes(VirtQueue
*vq
, unsigned int in_bytes
,
206 unsigned int out_bytes
);
207 void virtqueue_get_avail_bytes(VirtQueue
*vq
, unsigned int *in_bytes
,
208 unsigned int *out_bytes
,
209 unsigned max_in_bytes
, unsigned max_out_bytes
);
211 void virtio_notify_irqfd(VirtIODevice
*vdev
, VirtQueue
*vq
);
212 void virtio_notify(VirtIODevice
*vdev
, VirtQueue
*vq
);
214 int virtio_save(VirtIODevice
*vdev
, QEMUFile
*f
);
216 extern const VMStateInfo virtio_vmstate_info
;
218 #define VMSTATE_VIRTIO_DEVICE \
221 .info = &virtio_vmstate_info, \
222 .flags = VMS_SINGLE, \
225 int virtio_load(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
227 void virtio_notify_config(VirtIODevice
*vdev
);
229 bool virtio_queue_get_notification(VirtQueue
*vq
);
230 void virtio_queue_set_notification(VirtQueue
*vq
, int enable
);
232 int virtio_queue_ready(VirtQueue
*vq
);
234 int virtio_queue_empty(VirtQueue
*vq
);
236 /* Host binding interface. */
238 uint32_t virtio_config_readb(VirtIODevice
*vdev
, uint32_t addr
);
239 uint32_t virtio_config_readw(VirtIODevice
*vdev
, uint32_t addr
);
240 uint32_t virtio_config_readl(VirtIODevice
*vdev
, uint32_t addr
);
241 void virtio_config_writeb(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
242 void virtio_config_writew(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
243 void virtio_config_writel(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
244 uint32_t virtio_config_modern_readb(VirtIODevice
*vdev
, uint32_t addr
);
245 uint32_t virtio_config_modern_readw(VirtIODevice
*vdev
, uint32_t addr
);
246 uint32_t virtio_config_modern_readl(VirtIODevice
*vdev
, uint32_t addr
);
247 void virtio_config_modern_writeb(VirtIODevice
*vdev
,
248 uint32_t addr
, uint32_t data
);
249 void virtio_config_modern_writew(VirtIODevice
*vdev
,
250 uint32_t addr
, uint32_t data
);
251 void virtio_config_modern_writel(VirtIODevice
*vdev
,
252 uint32_t addr
, uint32_t data
);
253 void virtio_queue_set_addr(VirtIODevice
*vdev
, int n
, hwaddr addr
);
254 hwaddr
virtio_queue_get_addr(VirtIODevice
*vdev
, int n
);
255 void virtio_queue_set_num(VirtIODevice
*vdev
, int n
, int num
);
256 int virtio_queue_get_num(VirtIODevice
*vdev
, int n
);
257 int virtio_queue_get_max_num(VirtIODevice
*vdev
, int n
);
258 int virtio_get_num_queues(VirtIODevice
*vdev
);
259 void virtio_queue_set_rings(VirtIODevice
*vdev
, int n
, hwaddr desc
,
260 hwaddr avail
, hwaddr used
);
261 void virtio_queue_update_rings(VirtIODevice
*vdev
, int n
);
262 void virtio_queue_set_align(VirtIODevice
*vdev
, int n
, int align
);
263 void virtio_queue_notify(VirtIODevice
*vdev
, int n
);
264 uint16_t virtio_queue_vector(VirtIODevice
*vdev
, int n
);
265 void virtio_queue_set_vector(VirtIODevice
*vdev
, int n
, uint16_t vector
);
266 int virtio_queue_set_host_notifier_mr(VirtIODevice
*vdev
, int n
,
267 MemoryRegion
*mr
, bool assign
);
268 int virtio_set_status(VirtIODevice
*vdev
, uint8_t val
);
269 void virtio_reset(void *opaque
);
270 void virtio_update_irq(VirtIODevice
*vdev
);
271 int virtio_set_features(VirtIODevice
*vdev
, uint64_t val
);
274 typedef struct VirtIOBlkConf VirtIOBlkConf
;
275 struct virtio_net_conf
;
276 typedef struct virtio_serial_conf virtio_serial_conf
;
277 typedef struct virtio_input_conf virtio_input_conf
;
278 typedef struct VirtIOSCSIConf VirtIOSCSIConf
;
279 typedef struct VirtIORNGConf VirtIORNGConf
;
281 #define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
282 DEFINE_PROP_BIT64("indirect_desc", _state, _field, \
283 VIRTIO_RING_F_INDIRECT_DESC, true), \
284 DEFINE_PROP_BIT64("event_idx", _state, _field, \
285 VIRTIO_RING_F_EVENT_IDX, true), \
286 DEFINE_PROP_BIT64("notify_on_empty", _state, _field, \
287 VIRTIO_F_NOTIFY_ON_EMPTY, true), \
288 DEFINE_PROP_BIT64("any_layout", _state, _field, \
289 VIRTIO_F_ANY_LAYOUT, true), \
290 DEFINE_PROP_BIT64("iommu_platform", _state, _field, \
291 VIRTIO_F_IOMMU_PLATFORM, false), \
292 DEFINE_PROP_BIT64("packed", _state, _field, \
293 VIRTIO_F_RING_PACKED, false)
295 hwaddr
virtio_queue_get_desc_addr(VirtIODevice
*vdev
, int n
);
296 bool virtio_queue_enabled_legacy(VirtIODevice
*vdev
, int n
);
297 bool virtio_queue_enabled(VirtIODevice
*vdev
, int n
);
298 hwaddr
virtio_queue_get_avail_addr(VirtIODevice
*vdev
, int n
);
299 hwaddr
virtio_queue_get_used_addr(VirtIODevice
*vdev
, int n
);
300 hwaddr
virtio_queue_get_desc_size(VirtIODevice
*vdev
, int n
);
301 hwaddr
virtio_queue_get_avail_size(VirtIODevice
*vdev
, int n
);
302 hwaddr
virtio_queue_get_used_size(VirtIODevice
*vdev
, int n
);
303 unsigned int virtio_queue_get_last_avail_idx(VirtIODevice
*vdev
, int n
);
304 void virtio_queue_set_last_avail_idx(VirtIODevice
*vdev
, int n
,
306 void virtio_queue_restore_last_avail_idx(VirtIODevice
*vdev
, int n
);
307 void virtio_queue_invalidate_signalled_used(VirtIODevice
*vdev
, int n
);
308 void virtio_queue_update_used_idx(VirtIODevice
*vdev
, int n
);
309 VirtQueue
*virtio_get_queue(VirtIODevice
*vdev
, int n
);
310 uint16_t virtio_get_queue_index(VirtQueue
*vq
);
311 EventNotifier
*virtio_queue_get_guest_notifier(VirtQueue
*vq
);
312 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
314 int virtio_device_start_ioeventfd(VirtIODevice
*vdev
);
315 int virtio_device_grab_ioeventfd(VirtIODevice
*vdev
);
316 void virtio_device_release_ioeventfd(VirtIODevice
*vdev
);
317 bool virtio_device_ioeventfd_enabled(VirtIODevice
*vdev
);
318 EventNotifier
*virtio_queue_get_host_notifier(VirtQueue
*vq
);
319 void virtio_queue_set_host_notifier_enabled(VirtQueue
*vq
, bool enabled
);
320 void virtio_queue_host_notifier_read(EventNotifier
*n
);
321 void virtio_queue_aio_set_host_notifier_handler(VirtQueue
*vq
, AioContext
*ctx
,
322 VirtIOHandleAIOOutput handle_output
);
323 VirtQueue
*virtio_vector_first_queue(VirtIODevice
*vdev
, uint16_t vector
);
324 VirtQueue
*virtio_vector_next_queue(VirtQueue
*vq
);
326 static inline void virtio_add_feature(uint64_t *features
, unsigned int fbit
)
329 *features
|= (1ULL << fbit
);
332 static inline void virtio_clear_feature(uint64_t *features
, unsigned int fbit
)
335 *features
&= ~(1ULL << fbit
);
338 static inline bool virtio_has_feature(uint64_t features
, unsigned int fbit
)
341 return !!(features
& (1ULL << fbit
));
344 static inline bool virtio_vdev_has_feature(VirtIODevice
*vdev
,
347 return virtio_has_feature(vdev
->guest_features
, fbit
);
350 static inline bool virtio_host_has_feature(VirtIODevice
*vdev
,
353 return virtio_has_feature(vdev
->host_features
, fbit
);
356 static inline bool virtio_is_big_endian(VirtIODevice
*vdev
)
358 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
359 assert(vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_UNKNOWN
);
360 return vdev
->device_endian
== VIRTIO_DEVICE_ENDIAN_BIG
;
362 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
366 static inline bool virtio_device_started(VirtIODevice
*vdev
, uint8_t status
)
368 if (vdev
->use_started
) {
369 return vdev
->started
;
372 return status
& VIRTIO_CONFIG_S_DRIVER_OK
;
375 static inline void virtio_set_started(VirtIODevice
*vdev
, bool started
)
378 vdev
->start_on_kick
= false;
381 if (vdev
->use_started
) {
382 vdev
->started
= started
;
386 static inline void virtio_set_disabled(VirtIODevice
*vdev
, bool disable
)
388 if (vdev
->use_disabled_flag
) {
389 vdev
->disabled
= disable
;
393 static inline bool virtio_device_disabled(VirtIODevice
*vdev
)
395 return unlikely(vdev
->disabled
|| vdev
->broken
);
398 bool virtio_legacy_allowed(VirtIODevice
*vdev
);