1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
5 #ifndef _VIRTIO_RING_H_
6 #define _VIRTIO_RING_H_
10 #include <rte_common.h>
12 /* This marks a buffer as continuing via the next field. */
13 #define VRING_DESC_F_NEXT 1
14 /* This marks a buffer as write-only (otherwise read-only). */
15 #define VRING_DESC_F_WRITE 2
16 /* This means the buffer contains a list of buffer descriptors. */
17 #define VRING_DESC_F_INDIRECT 4
19 /* The Host uses this in used->flags to advise the Guest: don't kick me
20 * when you add a buffer. It's unreliable, so it's simply an
21 * optimization. Guest will still kick if it's out of buffers. */
22 #define VRING_USED_F_NO_NOTIFY 1
23 /* The Guest uses this in avail->flags to advise the Host: don't
24 * interrupt me when you consume a buffer. It's unreliable, so it's
25 * simply an optimization. */
26 #define VRING_AVAIL_F_NO_INTERRUPT 1
28 /* VirtIO ring descriptors: 16 bytes.
29 * These can chain together via "next". */
31 uint64_t addr; /* Address (guest-physical). */
32 uint32_t len; /* Length. */
33 uint16_t flags; /* The flags as indicated above. */
34 uint16_t next; /* We chain unused descriptors via this. */
43 /* id is a 16bit index. uint32_t is used here for ids for padding reasons. */
44 struct vring_used_elem {
45 /* Index of start of used descriptor chain. */
47 /* Total length of the descriptor chain which was written to. */
53 volatile uint16_t idx;
54 struct vring_used_elem ring[0];
59 struct vring_desc *desc;
60 struct vring_avail *avail;
61 struct vring_used *used;
64 /* The standard layout for the ring is a continuous chunk of memory which
65 * looks like this. We assume num is a power of 2.
68 * // The actual descriptors (16 bytes each)
69 * struct vring_desc desc[num];
71 * // A ring of available descriptor heads with free-running index.
74 * __u16 available[num];
75 * __u16 used_event_idx;
77 * // Padding to the next align boundary.
80 * // A ring of used descriptor heads with free-running index.
83 * struct vring_used_elem used[num];
84 * __u16 avail_event_idx;
87 * NOTE: for VirtIO PCI, align is 4096.
91 * We publish the used event index at the end of the available ring, and vice
92 * versa. They are at the end for backwards compatibility.
94 #define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
95 #define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num])
98 vring_size(unsigned int num, unsigned long align)
102 size = num * sizeof(struct vring_desc);
103 size += sizeof(struct vring_avail) + (num * sizeof(uint16_t));
104 size = RTE_ALIGN_CEIL(size, align);
105 size += sizeof(struct vring_used) +
106 (num * sizeof(struct vring_used_elem));
111 vring_init(struct vring *vr, unsigned int num, uint8_t *p,
115 vr->desc = (struct vring_desc *) p;
116 vr->avail = (struct vring_avail *) (p +
117 num * sizeof(struct vring_desc));
119 RTE_ALIGN_CEIL((uintptr_t)(&vr->avail->ring[num]), align);
123 * The following is used with VIRTIO_RING_F_EVENT_IDX.
124 * Assuming a given event_idx value from the other size, if we have
125 * just incremented index from old to new_idx, should we trigger an
129 vring_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old)
131 return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old);
134 #endif /* _VIRTIO_RING_H_ */