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
  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
  27
  28 /* VirtIO ring descriptors: 16 bytes.
  29  * These can chain together via "next". */
  30 struct vring_desc {
  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. */
  35 };
  36
  37 struct vring_avail {
  38         uint16_t flags;
  39         uint16_t idx;
  40         uint16_t ring[0];
  41 };
  42
  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. */
  46         uint32_t id;
  47         /* Total length of the descriptor chain which was written to. */
  48         uint32_t len;
  49 };
  50
  51 struct vring_used {
  52         uint16_t flags;
  53         volatile uint16_t idx;
  54         struct vring_used_elem ring[0];
  55 };
  56
  57 struct vring {
  58         unsigned int num;
  59         struct vring_desc  *desc;
  60         struct vring_avail *avail;
  61         struct vring_used  *used;
  62 };
  63
  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.
  66  *
  67  * struct vring {
  68  *      // The actual descriptors (16 bytes each)
  69  *      struct vring_desc desc[num];
  70  *
  71  *      // A ring of available descriptor heads with free-running index.
  72  *      __u16 avail_flags;
  73  *      __u16 avail_idx;
  74  *      __u16 available[num];
  75  *      __u16 used_event_idx;
  76  *
  77  *      // Padding to the next align boundary.
  78  *      char pad[];
  79  *
  80  *      // A ring of used descriptor heads with free-running index.
  81  *      __u16 used_flags;
  82  *      __u16 used_idx;
  83  *      struct vring_used_elem used[num];
  84  *      __u16 avail_event_idx;
  85  * };
  86  *
  87  * NOTE: for VirtIO PCI, align is 4096.
  88  */
  89
  90 /*
  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.
  93  */
  94 #define vring_used_event(vr)  ((vr)->avail->ring[(vr)->num])
  95 #define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num])
  96
  97 static inline size_t
  98 vring_size(unsigned int num, unsigned long align)
  99 {
 100         size_t size;
 101
 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));
 107         return size;
 108 }
 109
 110 static inline void
 111 vring_init(struct vring *vr, unsigned int num, uint8_t *p,
 112         unsigned long align)
 113 {
 114         vr->num = num;
 115         vr->desc = (struct vring_desc *) p;
 116         vr->avail = (struct vring_avail *) (p +
 117                 num * sizeof(struct vring_desc));
 118         vr->used = (void *)
 119                 RTE_ALIGN_CEIL((uintptr_t)(&vr->avail->ring[num]), align);
 120 }
 121
 122 /*
 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
 126  * event?
 127  */
 128 static inline int
 129 vring_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old)
 130 {
 131         return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old);
 132 }
 133
 134 #endif /* _VIRTIO_RING_H_ */