drivers/net/virtio/virtio_ring.h

   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_ */