1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2014 Intel Corporation 3 */ 4 5 #ifndef _VIRTIO_RING_H_ 6 #define _VIRTIO_RING_H_ 7 8 #include <stdint.h> 9 10 #include <rte_common.h> 11 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 18 /* This flag means the descriptor was made available by the driver */ 19 #define VRING_DESC_F_AVAIL(b) ((uint16_t)(b) << 7) 20 /* This flag means the descriptor was used by the device */ 21 #define VRING_DESC_F_USED(b) ((uint16_t)(b) << 15) 22 23 /* The Host uses this in used->flags to advise the Guest: don't kick me 24 * when you add a buffer. It's unreliable, so it's simply an 25 * optimization. Guest will still kick if it's out of buffers. */ 26 #define VRING_USED_F_NO_NOTIFY 1 27 /* The Guest uses this in avail->flags to advise the Host: don't 28 * interrupt me when you consume a buffer. It's unreliable, so it's 29 * simply an optimization. */ 30 #define VRING_AVAIL_F_NO_INTERRUPT 1 31 32 /* VirtIO ring descriptors: 16 bytes. 33 * These can chain together via "next". */ 34 struct vring_desc { 35 uint64_t addr; /* Address (guest-physical). */ 36 uint32_t len; /* Length. */ 37 uint16_t flags; /* The flags as indicated above. */ 38 uint16_t next; /* We chain unused descriptors via this. */ 39 }; 40 41 struct vring_avail { 42 uint16_t flags; 43 uint16_t idx; 44 uint16_t ring[0]; 45 }; 46 47 /* id is a 16bit index. uint32_t is used here for ids for padding reasons. */ 48 struct vring_used_elem { 49 /* Index of start of used descriptor chain. */ 50 uint32_t id; 51 /* Total length of the descriptor chain which was written to. */ 52 uint32_t len; 53 }; 54 55 struct vring_used { 56 uint16_t flags; 57 volatile uint16_t idx; 58 struct vring_used_elem ring[0]; 59 }; 60 61 /* For support of packed virtqueues in Virtio 1.1 the format of descriptors 62 * looks like this. 63 */ 64 struct vring_packed_desc { 65 uint64_t addr; 66 uint32_t len; 67 uint16_t id; 68 uint16_t flags; 69 }; 70 71 #define RING_EVENT_FLAGS_ENABLE 0x0 72 #define RING_EVENT_FLAGS_DISABLE 0x1 73 #define RING_EVENT_FLAGS_DESC 0x2 74 struct vring_packed_desc_event { 75 uint16_t desc_event_off_wrap; 76 uint16_t desc_event_flags; 77 }; 78 79 struct vring_packed { 80 unsigned int num; 81 struct vring_packed_desc *desc; 82 struct vring_packed_desc_event *driver; 83 struct vring_packed_desc_event *device; 84 }; 85 86 struct vring { 87 unsigned int num; 88 struct vring_desc *desc; 89 struct vring_avail *avail; 90 struct vring_used *used; 91 }; 92 93 /* The standard layout for the ring is a continuous chunk of memory which 94 * looks like this. We assume num is a power of 2. 95 * 96 * struct vring { 97 * // The actual descriptors (16 bytes each) 98 * struct vring_desc desc[num]; 99 * 100 * // A ring of available descriptor heads with free-running index. 101 * __u16 avail_flags; 102 * __u16 avail_idx; 103 * __u16 available[num]; 104 * __u16 used_event_idx; 105 * 106 * // Padding to the next align boundary. 107 * char pad[]; 108 * 109 * // A ring of used descriptor heads with free-running index. 110 * __u16 used_flags; 111 * __u16 used_idx; 112 * struct vring_used_elem used[num]; 113 * __u16 avail_event_idx; 114 * }; 115 * 116 * NOTE: for VirtIO PCI, align is 4096. 117 */ 118 119 /* 120 * We publish the used event index at the end of the available ring, and vice 121 * versa. They are at the end for backwards compatibility. 122 */ 123 #define vring_used_event(vr) ((vr)->avail->ring[(vr)->num]) 124 #define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num]) 125 126 static inline size_t 127 vring_size(struct virtio_hw *hw, unsigned int num, unsigned long align) 128 { 129 size_t size; 130 131 if (vtpci_packed_queue(hw)) { 132 size = num * sizeof(struct vring_packed_desc); 133 size += sizeof(struct vring_packed_desc_event); 134 size = RTE_ALIGN_CEIL(size, align); 135 size += sizeof(struct vring_packed_desc_event); 136 return size; 137 } 138 139 size = num * sizeof(struct vring_desc); 140 size += sizeof(struct vring_avail) + (num * sizeof(uint16_t)); 141 size = RTE_ALIGN_CEIL(size, align); 142 size += sizeof(struct vring_used) + 143 (num * sizeof(struct vring_used_elem)); 144 return size; 145 } 146 static inline void 147 vring_init_split(struct vring *vr, uint8_t *p, unsigned long align, 148 unsigned int num) 149 { 150 vr->num = num; 151 vr->desc = (struct vring_desc *) p; 152 vr->avail = (struct vring_avail *) (p + 153 num * sizeof(struct vring_desc)); 154 vr->used = (void *) 155 RTE_ALIGN_CEIL((uintptr_t)(&vr->avail->ring[num]), align); 156 } 157 158 static inline void 159 vring_init_packed(struct vring_packed *vr, uint8_t *p, unsigned long align, 160 unsigned int num) 161 { 162 vr->num = num; 163 vr->desc = (struct vring_packed_desc *)p; 164 vr->driver = (struct vring_packed_desc_event *)(p + 165 vr->num * sizeof(struct vring_packed_desc)); 166 vr->device = (struct vring_packed_desc_event *) 167 RTE_ALIGN_CEIL(((uintptr_t)vr->driver + 168 sizeof(struct vring_packed_desc_event)), align); 169 } 170 171 /* 172 * The following is used with VIRTIO_RING_F_EVENT_IDX. 173 * Assuming a given event_idx value from the other size, if we have 174 * just incremented index from old to new_idx, should we trigger an 175 * event? 176 */ 177 static inline int 178 vring_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old) 179 { 180 return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old); 181 } 182 183 #endif /* _VIRTIO_RING_H_ */ 184