1
2
3
4
5
6
7
8
9
10
11
12
13
14#ifndef QEMU_VIRTIO_H
15#define QEMU_VIRTIO_H
16
17#include "exec/memory.h"
18#include "hw/qdev-core.h"
19#include "net/net.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"
25#include "hw/virtio/vhost.h"
26
27
28#define VIRTIO_F_BAD_FEATURE 30
29
30#define VIRTIO_LEGACY_FEATURES ((0x1ULL << VIRTIO_F_BAD_FEATURE) | \
31 (0x1ULL << VIRTIO_F_NOTIFY_ON_EMPTY) | \
32 (0x1ULL << VIRTIO_F_ANY_LAYOUT))
33
34struct VirtQueue;
35
36static inline hwaddr vring_align(hwaddr addr,
37 unsigned long align)
38{
39 return QEMU_ALIGN_UP(addr, align);
40}
41
42typedef struct VirtIOFeature {
43 uint64_t flags;
44 size_t end;
45} VirtIOFeature;
46
47size_t virtio_feature_get_config_size(const VirtIOFeature *features,
48 uint64_t host_features);
49
50typedef struct VirtQueue VirtQueue;
51
52#define VIRTQUEUE_MAX_SIZE 1024
53
54typedef struct VirtQueueElement
55{
56 unsigned int index;
57 unsigned int len;
58 unsigned int ndescs;
59 unsigned int out_num;
60 unsigned int in_num;
61 hwaddr *in_addr;
62 hwaddr *out_addr;
63 struct iovec *in_sg;
64 struct iovec *out_sg;
65} VirtQueueElement;
66
67#define VIRTIO_QUEUE_MAX 1024
68
69#define VIRTIO_NO_VECTOR 0xffff
70
71#define TYPE_VIRTIO_DEVICE "virtio-device"
72OBJECT_DECLARE_TYPE(VirtIODevice, VirtioDeviceClass, VIRTIO_DEVICE)
73
74enum virtio_device_endian {
75 VIRTIO_DEVICE_ENDIAN_UNKNOWN,
76 VIRTIO_DEVICE_ENDIAN_LITTLE,
77 VIRTIO_DEVICE_ENDIAN_BIG,
78};
79
80struct VirtIODevice
81{
82 DeviceState parent_obj;
83 const char *name;
84 uint8_t status;
85 uint8_t isr;
86 uint16_t queue_sel;
87 uint64_t guest_features;
88 uint64_t host_features;
89 uint64_t backend_features;
90 size_t config_len;
91 void *config;
92 uint16_t config_vector;
93 uint32_t generation;
94 int nvectors;
95 VirtQueue *vq;
96 MemoryListener listener;
97 uint16_t device_id;
98 bool vm_running;
99 bool broken;
100 bool use_disabled_flag;
101 bool disabled;
102 bool use_started;
103 bool started;
104 bool start_on_kick;
105 bool disable_legacy_check;
106 bool vhost_started;
107 VMChangeStateEntry *vmstate;
108 char *bus_name;
109 uint8_t device_endian;
110 bool use_guest_notifier_mask;
111 AddressSpace *dma_as;
112 QLIST_HEAD(, VirtQueue) *vector_queues;
113};
114
115struct VirtioDeviceClass {
116
117 DeviceClass parent;
118
119
120
121 DeviceRealize realize;
122 DeviceUnrealize unrealize;
123 uint64_t (*get_features)(VirtIODevice *vdev,
124 uint64_t requested_features,
125 Error **errp);
126 uint64_t (*bad_features)(VirtIODevice *vdev);
127 void (*set_features)(VirtIODevice *vdev, uint64_t val);
128 int (*validate_features)(VirtIODevice *vdev);
129 void (*get_config)(VirtIODevice *vdev, uint8_t *config);
130 void (*set_config)(VirtIODevice *vdev, const uint8_t *config);
131 void (*reset)(VirtIODevice *vdev);
132 void (*set_status)(VirtIODevice *vdev, uint8_t val);
133
134
135
136
137 uint64_t legacy_features;
138
139
140
141
142
143 bool (*guest_notifier_pending)(VirtIODevice *vdev, int n);
144
145
146
147
148
149 void (*guest_notifier_mask)(VirtIODevice *vdev, int n, bool mask);
150 int (*start_ioeventfd)(VirtIODevice *vdev);
151 void (*stop_ioeventfd)(VirtIODevice *vdev);
152
153
154
155 void (*save)(VirtIODevice *vdev, QEMUFile *f);
156 int (*load)(VirtIODevice *vdev, QEMUFile *f, int version_id);
157
158
159
160
161
162 int (*post_load)(VirtIODevice *vdev);
163 const VMStateDescription *vmsd;
164 bool (*primary_unplug_pending)(void *opaque);
165 struct vhost_dev *(*get_vhost)(VirtIODevice *vdev);
166};
167
168void virtio_instance_init_common(Object *proxy_obj, void *data,
169 size_t vdev_size, const char *vdev_name);
170
171void virtio_init(VirtIODevice *vdev, uint16_t device_id, size_t config_size);
172
173void virtio_cleanup(VirtIODevice *vdev);
174
175void virtio_error(VirtIODevice *vdev, const char *fmt, ...) G_GNUC_PRINTF(2, 3);
176
177
178void virtio_device_set_child_bus_name(VirtIODevice *vdev, char *bus_name);
179
180typedef void (*VirtIOHandleOutput)(VirtIODevice *, VirtQueue *);
181
182VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
183 VirtIOHandleOutput handle_output);
184
185void virtio_del_queue(VirtIODevice *vdev, int n);
186
187void virtio_delete_queue(VirtQueue *vq);
188
189void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
190 unsigned int len);
191void virtqueue_flush(VirtQueue *vq, unsigned int count);
192void virtqueue_detach_element(VirtQueue *vq, const VirtQueueElement *elem,
193 unsigned int len);
194void virtqueue_unpop(VirtQueue *vq, const VirtQueueElement *elem,
195 unsigned int len);
196bool virtqueue_rewind(VirtQueue *vq, unsigned int num);
197void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
198 unsigned int len, unsigned int idx);
199
200void virtqueue_map(VirtIODevice *vdev, VirtQueueElement *elem);
201void *virtqueue_pop(VirtQueue *vq, size_t sz);
202unsigned int virtqueue_drop_all(VirtQueue *vq);
203void *qemu_get_virtqueue_element(VirtIODevice *vdev, QEMUFile *f, size_t sz);
204void qemu_put_virtqueue_element(VirtIODevice *vdev, QEMUFile *f,
205 VirtQueueElement *elem);
206int virtqueue_avail_bytes(VirtQueue *vq, unsigned int in_bytes,
207 unsigned int out_bytes);
208void virtqueue_get_avail_bytes(VirtQueue *vq, unsigned int *in_bytes,
209 unsigned int *out_bytes,
210 unsigned max_in_bytes, unsigned max_out_bytes);
211
212void virtio_notify_irqfd(VirtIODevice *vdev, VirtQueue *vq);
213void virtio_notify(VirtIODevice *vdev, VirtQueue *vq);
214
215int virtio_save(VirtIODevice *vdev, QEMUFile *f);
216
217extern const VMStateInfo virtio_vmstate_info;
218
219#define VMSTATE_VIRTIO_DEVICE \
220 { \
221 .name = "virtio", \
222 .info = &virtio_vmstate_info, \
223 .flags = VMS_SINGLE, \
224 }
225
226int virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id);
227
228void virtio_notify_config(VirtIODevice *vdev);
229
230bool virtio_queue_get_notification(VirtQueue *vq);
231void virtio_queue_set_notification(VirtQueue *vq, int enable);
232
233int virtio_queue_ready(VirtQueue *vq);
234
235int virtio_queue_empty(VirtQueue *vq);
236
237
238
239uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr);
240uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr);
241uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr);
242void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data);
243void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data);
244void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data);
245uint32_t virtio_config_modern_readb(VirtIODevice *vdev, uint32_t addr);
246uint32_t virtio_config_modern_readw(VirtIODevice *vdev, uint32_t addr);
247uint32_t virtio_config_modern_readl(VirtIODevice *vdev, uint32_t addr);
248void virtio_config_modern_writeb(VirtIODevice *vdev,
249 uint32_t addr, uint32_t data);
250void virtio_config_modern_writew(VirtIODevice *vdev,
251 uint32_t addr, uint32_t data);
252void virtio_config_modern_writel(VirtIODevice *vdev,
253 uint32_t addr, uint32_t data);
254void virtio_queue_set_addr(VirtIODevice *vdev, int n, hwaddr addr);
255hwaddr virtio_queue_get_addr(VirtIODevice *vdev, int n);
256void virtio_queue_set_num(VirtIODevice *vdev, int n, int num);
257int virtio_queue_get_num(VirtIODevice *vdev, int n);
258int virtio_queue_get_max_num(VirtIODevice *vdev, int n);
259int virtio_get_num_queues(VirtIODevice *vdev);
260void virtio_queue_set_rings(VirtIODevice *vdev, int n, hwaddr desc,
261 hwaddr avail, hwaddr used);
262void virtio_queue_update_rings(VirtIODevice *vdev, int n);
263void virtio_queue_set_align(VirtIODevice *vdev, int n, int align);
264void virtio_queue_notify(VirtIODevice *vdev, int n);
265uint16_t virtio_queue_vector(VirtIODevice *vdev, int n);
266void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector);
267int virtio_queue_set_host_notifier_mr(VirtIODevice *vdev, int n,
268 MemoryRegion *mr, bool assign);
269int virtio_set_status(VirtIODevice *vdev, uint8_t val);
270void virtio_reset(void *opaque);
271void virtio_update_irq(VirtIODevice *vdev);
272int virtio_set_features(VirtIODevice *vdev, uint64_t val);
273
274
275typedef struct VirtIOBlkConf VirtIOBlkConf;
276struct virtio_net_conf;
277typedef struct virtio_serial_conf virtio_serial_conf;
278typedef struct virtio_input_conf virtio_input_conf;
279typedef struct VirtIOSCSIConf VirtIOSCSIConf;
280typedef struct VirtIORNGConf VirtIORNGConf;
281
282#define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
283 DEFINE_PROP_BIT64("indirect_desc", _state, _field, \
284 VIRTIO_RING_F_INDIRECT_DESC, true), \
285 DEFINE_PROP_BIT64("event_idx", _state, _field, \
286 VIRTIO_RING_F_EVENT_IDX, true), \
287 DEFINE_PROP_BIT64("notify_on_empty", _state, _field, \
288 VIRTIO_F_NOTIFY_ON_EMPTY, true), \
289 DEFINE_PROP_BIT64("any_layout", _state, _field, \
290 VIRTIO_F_ANY_LAYOUT, true), \
291 DEFINE_PROP_BIT64("iommu_platform", _state, _field, \
292 VIRTIO_F_IOMMU_PLATFORM, false), \
293 DEFINE_PROP_BIT64("packed", _state, _field, \
294 VIRTIO_F_RING_PACKED, false)
295
296hwaddr virtio_queue_get_desc_addr(VirtIODevice *vdev, int n);
297bool virtio_queue_enabled_legacy(VirtIODevice *vdev, int n);
298bool virtio_queue_enabled(VirtIODevice *vdev, int n);
299hwaddr virtio_queue_get_avail_addr(VirtIODevice *vdev, int n);
300hwaddr virtio_queue_get_used_addr(VirtIODevice *vdev, int n);
301hwaddr virtio_queue_get_desc_size(VirtIODevice *vdev, int n);
302hwaddr virtio_queue_get_avail_size(VirtIODevice *vdev, int n);
303hwaddr virtio_queue_get_used_size(VirtIODevice *vdev, int n);
304unsigned int virtio_queue_get_last_avail_idx(VirtIODevice *vdev, int n);
305void virtio_queue_set_last_avail_idx(VirtIODevice *vdev, int n,
306 unsigned int idx);
307void virtio_queue_restore_last_avail_idx(VirtIODevice *vdev, int n);
308void virtio_queue_invalidate_signalled_used(VirtIODevice *vdev, int n);
309void virtio_queue_update_used_idx(VirtIODevice *vdev, int n);
310VirtQueue *virtio_get_queue(VirtIODevice *vdev, int n);
311uint16_t virtio_get_queue_index(VirtQueue *vq);
312EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq);
313void virtio_queue_set_guest_notifier_fd_handler(VirtQueue *vq, bool assign,
314 bool with_irqfd);
315int virtio_device_start_ioeventfd(VirtIODevice *vdev);
316int virtio_device_grab_ioeventfd(VirtIODevice *vdev);
317void virtio_device_release_ioeventfd(VirtIODevice *vdev);
318bool virtio_device_ioeventfd_enabled(VirtIODevice *vdev);
319EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
320void virtio_queue_set_host_notifier_enabled(VirtQueue *vq, bool enabled);
321void virtio_queue_host_notifier_read(EventNotifier *n);
322void virtio_queue_aio_attach_host_notifier(VirtQueue *vq, AioContext *ctx);
323void virtio_queue_aio_attach_host_notifier_no_poll(VirtQueue *vq, AioContext *ctx);
324void virtio_queue_aio_detach_host_notifier(VirtQueue *vq, AioContext *ctx);
325VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector);
326VirtQueue *virtio_vector_next_queue(VirtQueue *vq);
327
328static inline void virtio_add_feature(uint64_t *features, unsigned int fbit)
329{
330 assert(fbit < 64);
331 *features |= (1ULL << fbit);
332}
333
334static inline void virtio_clear_feature(uint64_t *features, unsigned int fbit)
335{
336 assert(fbit < 64);
337 *features &= ~(1ULL << fbit);
338}
339
340static inline bool virtio_has_feature(uint64_t features, unsigned int fbit)
341{
342 assert(fbit < 64);
343 return !!(features & (1ULL << fbit));
344}
345
346static inline bool virtio_vdev_has_feature(VirtIODevice *vdev,
347 unsigned int fbit)
348{
349 return virtio_has_feature(vdev->guest_features, fbit);
350}
351
352static inline bool virtio_host_has_feature(VirtIODevice *vdev,
353 unsigned int fbit)
354{
355 return virtio_has_feature(vdev->host_features, fbit);
356}
357
358static inline bool virtio_is_big_endian(VirtIODevice *vdev)
359{
360 if (!virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
361 assert(vdev->device_endian != VIRTIO_DEVICE_ENDIAN_UNKNOWN);
362 return vdev->device_endian == VIRTIO_DEVICE_ENDIAN_BIG;
363 }
364
365 return false;
366}
367
368static inline bool virtio_device_started(VirtIODevice *vdev, uint8_t status)
369{
370 if (vdev->use_started) {
371 return vdev->started;
372 }
373
374 return status & VIRTIO_CONFIG_S_DRIVER_OK;
375}
376
377static inline void virtio_set_started(VirtIODevice *vdev, bool started)
378{
379 if (started) {
380 vdev->start_on_kick = false;
381 }
382
383 if (vdev->use_started) {
384 vdev->started = started;
385 }
386}
387
388static inline void virtio_set_disabled(VirtIODevice *vdev, bool disable)
389{
390 if (vdev->use_disabled_flag) {
391 vdev->disabled = disable;
392 }
393}
394
395static inline bool virtio_device_disabled(VirtIODevice *vdev)
396{
397 return unlikely(vdev->disabled || vdev->broken);
398}
399
400bool virtio_legacy_allowed(VirtIODevice *vdev);
401bool virtio_legacy_check_disabled(VirtIODevice *vdev);
402
403#endif
404