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.
20 #include "sysemu/sysemu.h"
21 #include "qemu/event_notifier.h"
22 #include "standard-headers/linux/virtio_config.h"
23 #include "standard-headers/linux/virtio_ring.h"
25 /* A guest should never accept this. It implies negotiation is broken. */
26 #define VIRTIO_F_BAD_FEATURE 30
28 #define VIRTIO_LEGACY_FEATURES ((0x1ULL << VIRTIO_F_BAD_FEATURE) | \
29 (0x1ULL << VIRTIO_F_NOTIFY_ON_EMPTY) | \
30 (0x1ULL << VIRTIO_F_ANY_LAYOUT))
34 static inline hwaddr
vring_align(hwaddr addr
,
37 return (addr
+ align
- 1) & ~(align
- 1);
40 typedef struct VirtQueue VirtQueue
;
42 #define VIRTQUEUE_MAX_SIZE 1024
44 typedef struct VirtQueueElement
55 #define VIRTIO_QUEUE_MAX 1024
57 #define VIRTIO_NO_VECTOR 0xffff
59 #define TYPE_VIRTIO_DEVICE "virtio-device"
60 #define VIRTIO_DEVICE_GET_CLASS(obj) \
61 OBJECT_GET_CLASS(VirtioDeviceClass, obj, TYPE_VIRTIO_DEVICE)
62 #define VIRTIO_DEVICE_CLASS(klass) \
63 OBJECT_CLASS_CHECK(VirtioDeviceClass, klass, TYPE_VIRTIO_DEVICE)
64 #define VIRTIO_DEVICE(obj) \
65 OBJECT_CHECK(VirtIODevice, (obj), TYPE_VIRTIO_DEVICE)
67 enum virtio_device_endian
{
68 VIRTIO_DEVICE_ENDIAN_UNKNOWN
,
69 VIRTIO_DEVICE_ENDIAN_LITTLE
,
70 VIRTIO_DEVICE_ENDIAN_BIG
,
75 DeviceState parent_obj
;
80 uint64_t guest_features
;
81 uint64_t host_features
;
84 uint16_t config_vector
;
90 VMChangeStateEntry
*vmstate
;
92 uint8_t device_endian
;
93 bool use_guest_notifier_mask
;
94 QLIST_HEAD(, VirtQueue
) *vector_queues
;
97 typedef struct VirtioDeviceClass
{
102 /* This is what a VirtioDevice must implement */
103 DeviceRealize realize
;
104 DeviceUnrealize unrealize
;
105 uint64_t (*get_features
)(VirtIODevice
*vdev
,
106 uint64_t requested_features
,
108 uint64_t (*bad_features
)(VirtIODevice
*vdev
);
109 void (*set_features
)(VirtIODevice
*vdev
, uint64_t val
);
110 int (*validate_features
)(VirtIODevice
*vdev
);
111 void (*get_config
)(VirtIODevice
*vdev
, uint8_t *config
);
112 void (*set_config
)(VirtIODevice
*vdev
, const uint8_t *config
);
113 void (*reset
)(VirtIODevice
*vdev
);
114 void (*set_status
)(VirtIODevice
*vdev
, uint8_t val
);
115 /* Test and clear event pending status.
116 * Should be called after unmask to avoid losing events.
117 * If backend does not support masking,
118 * must check in frontend instead.
120 bool (*guest_notifier_pending
)(VirtIODevice
*vdev
, int n
);
121 /* Mask/unmask events from this vq. Any events reported
122 * while masked will become pending.
123 * If backend does not support masking,
124 * must mask in frontend instead.
126 void (*guest_notifier_mask
)(VirtIODevice
*vdev
, int n
, bool mask
);
127 void (*save
)(VirtIODevice
*vdev
, QEMUFile
*f
);
128 int (*load
)(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
131 void virtio_instance_init_common(Object
*proxy_obj
, void *data
,
132 size_t vdev_size
, const char *vdev_name
);
134 void virtio_init(VirtIODevice
*vdev
, const char *name
,
135 uint16_t device_id
, size_t config_size
);
136 void virtio_cleanup(VirtIODevice
*vdev
);
138 /* Set the child bus name. */
139 void virtio_device_set_child_bus_name(VirtIODevice
*vdev
, char *bus_name
);
141 typedef void (*VirtIOHandleOutput
)(VirtIODevice
*, VirtQueue
*);
143 VirtQueue
*virtio_add_queue(VirtIODevice
*vdev
, int queue_size
,
144 VirtIOHandleOutput handle_output
);
146 VirtQueue
*virtio_add_queue_aio(VirtIODevice
*vdev
, int queue_size
,
147 VirtIOHandleOutput handle_output
);
149 void virtio_del_queue(VirtIODevice
*vdev
, int n
);
151 void *virtqueue_alloc_element(size_t sz
, unsigned out_num
, unsigned in_num
);
152 void virtqueue_push(VirtQueue
*vq
, const VirtQueueElement
*elem
,
154 void virtqueue_flush(VirtQueue
*vq
, unsigned int count
);
155 void virtqueue_discard(VirtQueue
*vq
, const VirtQueueElement
*elem
,
157 bool virtqueue_rewind(VirtQueue
*vq
, unsigned int num
);
158 void virtqueue_fill(VirtQueue
*vq
, const VirtQueueElement
*elem
,
159 unsigned int len
, unsigned int idx
);
161 void virtqueue_map(VirtQueueElement
*elem
);
162 void *virtqueue_pop(VirtQueue
*vq
, size_t sz
);
163 void *qemu_get_virtqueue_element(QEMUFile
*f
, size_t sz
);
164 void qemu_put_virtqueue_element(QEMUFile
*f
, VirtQueueElement
*elem
);
165 int virtqueue_avail_bytes(VirtQueue
*vq
, unsigned int in_bytes
,
166 unsigned int out_bytes
);
167 void virtqueue_get_avail_bytes(VirtQueue
*vq
, unsigned int *in_bytes
,
168 unsigned int *out_bytes
,
169 unsigned max_in_bytes
, unsigned max_out_bytes
);
171 bool virtio_should_notify(VirtIODevice
*vdev
, VirtQueue
*vq
);
172 void virtio_notify(VirtIODevice
*vdev
, VirtQueue
*vq
);
174 void virtio_save(VirtIODevice
*vdev
, QEMUFile
*f
);
175 void virtio_vmstate_save(QEMUFile
*f
, void *opaque
, size_t size
);
177 #define VMSTATE_VIRTIO_DEVICE(devname, v, getf, putf) \
178 static const VMStateDescription vmstate_virtio_ ## devname = { \
179 .name = "virtio-" #devname , \
180 .minimum_version_id = v, \
182 .fields = (VMStateField[]) { \
185 .info = &(const VMStateInfo) {\
190 .flags = VMS_SINGLE, \
192 VMSTATE_END_OF_LIST() \
196 int virtio_load(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
);
198 void virtio_notify_config(VirtIODevice
*vdev
);
200 void virtio_queue_set_notification(VirtQueue
*vq
, int enable
);
202 int virtio_queue_ready(VirtQueue
*vq
);
204 int virtio_queue_empty(VirtQueue
*vq
);
206 /* Host binding interface. */
208 uint32_t virtio_config_readb(VirtIODevice
*vdev
, uint32_t addr
);
209 uint32_t virtio_config_readw(VirtIODevice
*vdev
, uint32_t addr
);
210 uint32_t virtio_config_readl(VirtIODevice
*vdev
, uint32_t addr
);
211 void virtio_config_writeb(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
212 void virtio_config_writew(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
213 void virtio_config_writel(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
);
214 uint32_t virtio_config_modern_readb(VirtIODevice
*vdev
, uint32_t addr
);
215 uint32_t virtio_config_modern_readw(VirtIODevice
*vdev
, uint32_t addr
);
216 uint32_t virtio_config_modern_readl(VirtIODevice
*vdev
, uint32_t addr
);
217 void virtio_config_modern_writeb(VirtIODevice
*vdev
,
218 uint32_t addr
, uint32_t data
);
219 void virtio_config_modern_writew(VirtIODevice
*vdev
,
220 uint32_t addr
, uint32_t data
);
221 void virtio_config_modern_writel(VirtIODevice
*vdev
,
222 uint32_t addr
, uint32_t data
);
223 void virtio_queue_set_addr(VirtIODevice
*vdev
, int n
, hwaddr addr
);
224 hwaddr
virtio_queue_get_addr(VirtIODevice
*vdev
, int n
);
225 void virtio_queue_set_num(VirtIODevice
*vdev
, int n
, int num
);
226 int virtio_queue_get_num(VirtIODevice
*vdev
, int n
);
227 int virtio_get_num_queues(VirtIODevice
*vdev
);
228 void virtio_queue_set_rings(VirtIODevice
*vdev
, int n
, hwaddr desc
,
229 hwaddr avail
, hwaddr used
);
230 void virtio_queue_update_rings(VirtIODevice
*vdev
, int n
);
231 void virtio_queue_set_align(VirtIODevice
*vdev
, int n
, int align
);
232 void virtio_queue_notify(VirtIODevice
*vdev
, int n
);
233 uint16_t virtio_queue_vector(VirtIODevice
*vdev
, int n
);
234 void virtio_queue_set_vector(VirtIODevice
*vdev
, int n
, uint16_t vector
);
235 int virtio_set_status(VirtIODevice
*vdev
, uint8_t val
);
236 void virtio_reset(void *opaque
);
237 void virtio_update_irq(VirtIODevice
*vdev
);
238 int virtio_set_features(VirtIODevice
*vdev
, uint64_t val
);
241 typedef struct VirtIOBlkConf VirtIOBlkConf
;
242 struct virtio_net_conf
;
243 typedef struct virtio_serial_conf virtio_serial_conf
;
244 typedef struct virtio_input_conf virtio_input_conf
;
245 typedef struct VirtIOSCSIConf VirtIOSCSIConf
;
246 typedef struct VirtIORNGConf VirtIORNGConf
;
248 #define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
249 DEFINE_PROP_BIT64("indirect_desc", _state, _field, \
250 VIRTIO_RING_F_INDIRECT_DESC, true), \
251 DEFINE_PROP_BIT64("event_idx", _state, _field, \
252 VIRTIO_RING_F_EVENT_IDX, true), \
253 DEFINE_PROP_BIT64("notify_on_empty", _state, _field, \
254 VIRTIO_F_NOTIFY_ON_EMPTY, true), \
255 DEFINE_PROP_BIT64("any_layout", _state, _field, \
256 VIRTIO_F_ANY_LAYOUT, true)
258 hwaddr
virtio_queue_get_desc_addr(VirtIODevice
*vdev
, int n
);
259 hwaddr
virtio_queue_get_avail_addr(VirtIODevice
*vdev
, int n
);
260 hwaddr
virtio_queue_get_used_addr(VirtIODevice
*vdev
, int n
);
261 hwaddr
virtio_queue_get_ring_addr(VirtIODevice
*vdev
, int n
);
262 hwaddr
virtio_queue_get_desc_size(VirtIODevice
*vdev
, int n
);
263 hwaddr
virtio_queue_get_avail_size(VirtIODevice
*vdev
, int n
);
264 hwaddr
virtio_queue_get_used_size(VirtIODevice
*vdev
, int n
);
265 hwaddr
virtio_queue_get_ring_size(VirtIODevice
*vdev
, int n
);
266 uint16_t virtio_queue_get_last_avail_idx(VirtIODevice
*vdev
, int n
);
267 void virtio_queue_set_last_avail_idx(VirtIODevice
*vdev
, int n
, uint16_t idx
);
268 void virtio_queue_invalidate_signalled_used(VirtIODevice
*vdev
, int n
);
269 VirtQueue
*virtio_get_queue(VirtIODevice
*vdev
, int n
);
270 uint16_t virtio_get_queue_index(VirtQueue
*vq
);
271 EventNotifier
*virtio_queue_get_guest_notifier(VirtQueue
*vq
);
272 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
274 EventNotifier
*virtio_queue_get_host_notifier(VirtQueue
*vq
);
275 void virtio_queue_set_host_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
277 void virtio_queue_aio_set_host_notifier_handler(VirtQueue
*vq
, AioContext
*ctx
,
278 void (*fn
)(VirtIODevice
*,
280 void virtio_irq(VirtQueue
*vq
);
281 VirtQueue
*virtio_vector_first_queue(VirtIODevice
*vdev
, uint16_t vector
);
282 VirtQueue
*virtio_vector_next_queue(VirtQueue
*vq
);
284 static inline void virtio_add_feature(uint64_t *features
, unsigned int fbit
)
287 *features
|= (1ULL << fbit
);
290 static inline void virtio_clear_feature(uint64_t *features
, unsigned int fbit
)
293 *features
&= ~(1ULL << fbit
);
296 static inline bool virtio_has_feature(uint64_t features
, unsigned int fbit
)
299 return !!(features
& (1ULL << fbit
));
302 static inline bool virtio_vdev_has_feature(VirtIODevice
*vdev
,
305 return virtio_has_feature(vdev
->guest_features
, fbit
);
308 static inline bool virtio_host_has_feature(VirtIODevice
*vdev
,
311 return virtio_has_feature(vdev
->host_features
, fbit
);
314 static inline bool virtio_is_big_endian(VirtIODevice
*vdev
)
316 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
317 assert(vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_UNKNOWN
);
318 return vdev
->device_endian
== VIRTIO_DEVICE_ENDIAN_BIG
;
320 /* Devices conforming to VIRTIO 1.0 or later are always LE. */