tools/virtio/ringtest/ptr_ring.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #define _GNU_SOURCE
   3 #include "main.h"
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <pthread.h>
   8 #include <malloc.h>
   9 #include <assert.h>
  10 #include <errno.h>
  11 #include <limits.h>
  12
  13 #define SMP_CACHE_BYTES 64
  14 #define cache_line_size() SMP_CACHE_BYTES
  15 #define ____cacheline_aligned_in_smp __attribute__ ((aligned (SMP_CACHE_BYTES)))
  16 #define unlikely(x)    (__builtin_expect(!!(x), 0))
  17 #define likely(x)    (__builtin_expect(!!(x), 1))
  18 #define ALIGN(x, a) (((x) + (a) - 1) / (a) * (a))
  19 #define SIZE_MAX        (~(size_t)0)
  20
  21 typedef pthread_spinlock_t  spinlock_t;
  22
  23 typedef int gfp_t;
  24 #define __GFP_ZERO 0x1
  25
  26 static void *kmalloc(unsigned size, gfp_t gfp)
  27 {
  28         void *p = memalign(64, size);
  29         if (!p)
  30                 return p;
  31
  32         if (gfp & __GFP_ZERO)
  33                 memset(p, 0, size);
  34         return p;
  35 }
  36
  37 static inline void *kzalloc(unsigned size, gfp_t flags)
  38 {
  39         return kmalloc(size, flags | __GFP_ZERO);
  40 }
  41
  42 static inline void *kmalloc_array(size_t n, size_t size, gfp_t flags)
  43 {
  44         if (size != 0 && n > SIZE_MAX / size)
  45                 return NULL;
  46         return kmalloc(n * size, flags);
  47 }
  48
  49 static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
  50 {
  51         return kmalloc_array(n, size, flags | __GFP_ZERO);
  52 }
  53
  54 static void kfree(void *p)
  55 {
  56         if (p)
  57                 free(p);
  58 }
  59
  60 static void spin_lock_init(spinlock_t *lock)
  61 {
  62         int r = pthread_spin_init(lock, 0);
  63         assert(!r);
  64 }
  65
  66 static void spin_lock(spinlock_t *lock)
  67 {
  68         int ret = pthread_spin_lock(lock);
  69         assert(!ret);
  70 }
  71
  72 static void spin_unlock(spinlock_t *lock)
  73 {
  74         int ret = pthread_spin_unlock(lock);
  75         assert(!ret);
  76 }
  77
  78 static void spin_lock_bh(spinlock_t *lock)
  79 {
  80         spin_lock(lock);
  81 }
  82
  83 static void spin_unlock_bh(spinlock_t *lock)
  84 {
  85         spin_unlock(lock);
  86 }
  87
  88 static void spin_lock_irq(spinlock_t *lock)
  89 {
  90         spin_lock(lock);
  91 }
  92
  93 static void spin_unlock_irq(spinlock_t *lock)
  94 {
  95         spin_unlock(lock);
  96 }
  97
  98 static void spin_lock_irqsave(spinlock_t *lock, unsigned long f)
  99 {
 100         spin_lock(lock);
 101 }
 102
 103 static void spin_unlock_irqrestore(spinlock_t *lock, unsigned long f)
 104 {
 105         spin_unlock(lock);
 106 }
 107
 108 #include "../../../include/linux/ptr_ring.h"
 109
 110 static unsigned long long headcnt, tailcnt;
 111 static struct ptr_ring array ____cacheline_aligned_in_smp;
 112
 113 /* implemented by ring */
 114 void alloc_ring(void)
 115 {
 116         int ret = ptr_ring_init(&array, ring_size, 0);
 117         assert(!ret);
 118         /* Hacky way to poke at ring internals. Useful for testing though. */
 119         if (param)
 120                 array.batch = param;
 121 }
 122
 123 /* guest side */
 124 int add_inbuf(unsigned len, void *buf, void *datap)
 125 {
 126         int ret;
 127
 128         ret = __ptr_ring_produce(&array, buf);
 129         if (ret >= 0) {
 130                 ret = 0;
 131                 headcnt++;
 132         }
 133
 134         return ret;
 135 }
 136
 137 /*
 138  * ptr_ring API provides no way for producer to find out whether a given
 139  * buffer was consumed.  Our tests merely require that a successful get_buf
 140  * implies that add_inbuf succeed in the past, and that add_inbuf will succeed,
 141  * fake it accordingly.
 142  */
 143 void *get_buf(unsigned *lenp, void **bufp)
 144 {
 145         void *datap;
 146
 147         if (tailcnt == headcnt || __ptr_ring_full(&array))
 148                 datap = NULL;
 149         else {
 150                 datap = "Buffer\n";
 151                 ++tailcnt;
 152         }
 153
 154         return datap;
 155 }
 156
 157 bool used_empty()
 158 {
 159         return (tailcnt == headcnt || __ptr_ring_full(&array));
 160 }
 161
 162 void disable_call()
 163 {
 164         assert(0);
 165 }
 166
 167 bool enable_call()
 168 {
 169         assert(0);
 170 }
 171
 172 void kick_available(void)
 173 {
 174         assert(0);
 175 }
 176
 177 /* host side */
 178 void disable_kick()
 179 {
 180         assert(0);
 181 }
 182
 183 bool enable_kick()
 184 {
 185         assert(0);
 186 }
 187
 188 bool avail_empty()
 189 {
 190         return __ptr_ring_empty(&array);
 191 }
 192
 193 bool use_buf(unsigned *lenp, void **bufp)
 194 {
 195         void *ptr;
 196
 197         ptr = __ptr_ring_consume(&array);
 198
 199         return ptr;
 200 }
 201
 202 void call_used(void)
 203 {
 204         assert(0);
 205 }