Merge tags 'cris-for-4.16' and 'cris-for-4.16-urgent' of git://git.kernel.org/pub...
[muen/linux.git] / tools / virtio / ringtest / ring.c
1 /*
2  * Copyright (C) 2016 Red Hat, Inc.
3  * Author: Michael S. Tsirkin <mst@redhat.com>
4  * This work is licensed under the terms of the GNU GPL, version 2.
5  *
6  * Simple descriptor-based ring. virtio 0.9 compatible event index is used for
7  * signalling, unconditionally.
8  */
9 #define _GNU_SOURCE
10 #include "main.h"
11 #include <stdlib.h>
12 #include <stdio.h>
13 #include <string.h>
14
15 /* Next - Where next entry will be written.
16  * Prev - "Next" value when event triggered previously.
17  * Event - Peer requested event after writing this entry.
18  */
19 static inline bool need_event(unsigned short event,
20                               unsigned short next,
21                               unsigned short prev)
22 {
23         return (unsigned short)(next - event - 1) < (unsigned short)(next - prev);
24 }
25
26 /* Design:
27  * Guest adds descriptors with unique index values and DESC_HW in flags.
28  * Host overwrites used descriptors with correct len, index, and DESC_HW clear.
29  * Flags are always set last.
30  */
31 #define DESC_HW 0x1
32
33 struct desc {
34         unsigned short flags;
35         unsigned short index;
36         unsigned len;
37         unsigned long long addr;
38 };
39
40 /* how much padding is needed to avoid false cache sharing */
41 #define HOST_GUEST_PADDING 0x80
42
43 /* Mostly read */
44 struct event {
45         unsigned short kick_index;
46         unsigned char reserved0[HOST_GUEST_PADDING - 2];
47         unsigned short call_index;
48         unsigned char reserved1[HOST_GUEST_PADDING - 2];
49 };
50
51 struct data {
52         void *buf; /* descriptor is writeable, we can't get buf from there */
53         void *data;
54 } *data;
55
56 struct desc *ring;
57 struct event *event;
58
59 struct guest {
60         unsigned avail_idx;
61         unsigned last_used_idx;
62         unsigned num_free;
63         unsigned kicked_avail_idx;
64         unsigned char reserved[HOST_GUEST_PADDING - 12];
65 } guest;
66
67 struct host {
68         /* we do not need to track last avail index
69          * unless we have more than one in flight.
70          */
71         unsigned used_idx;
72         unsigned called_used_idx;
73         unsigned char reserved[HOST_GUEST_PADDING - 4];
74 } host;
75
76 /* implemented by ring */
77 void alloc_ring(void)
78 {
79         int ret;
80         int i;
81
82         ret = posix_memalign((void **)&ring, 0x1000, ring_size * sizeof *ring);
83         if (ret) {
84                 perror("Unable to allocate ring buffer.\n");
85                 exit(3);
86         }
87         event = malloc(sizeof *event);
88         if (!event) {
89                 perror("Unable to allocate event buffer.\n");
90                 exit(3);
91         }
92         memset(event, 0, sizeof *event);
93         guest.avail_idx = 0;
94         guest.kicked_avail_idx = -1;
95         guest.last_used_idx = 0;
96         host.used_idx = 0;
97         host.called_used_idx = -1;
98         for (i = 0; i < ring_size; ++i) {
99                 struct desc desc = {
100                         .index = i,
101                 };
102                 ring[i] = desc;
103         }
104         guest.num_free = ring_size;
105         data = malloc(ring_size * sizeof *data);
106         if (!data) {
107                 perror("Unable to allocate data buffer.\n");
108                 exit(3);
109         }
110         memset(data, 0, ring_size * sizeof *data);
111 }
112
113 /* guest side */
114 int add_inbuf(unsigned len, void *buf, void *datap)
115 {
116         unsigned head, index;
117
118         if (!guest.num_free)
119                 return -1;
120
121         guest.num_free--;
122         head = (ring_size - 1) & (guest.avail_idx++);
123
124         /* Start with a write. On MESI architectures this helps
125          * avoid a shared state with consumer that is polling this descriptor.
126          */
127         ring[head].addr = (unsigned long)(void*)buf;
128         ring[head].len = len;
129         /* read below might bypass write above. That is OK because it's just an
130          * optimization. If this happens, we will get the cache line in a
131          * shared state which is unfortunate, but probably not worth it to
132          * add an explicit full barrier to avoid this.
133          */
134         barrier();
135         index = ring[head].index;
136         data[index].buf = buf;
137         data[index].data = datap;
138         /* Barrier A (for pairing) */
139         smp_release();
140         ring[head].flags = DESC_HW;
141
142         return 0;
143 }
144
145 void *get_buf(unsigned *lenp, void **bufp)
146 {
147         unsigned head = (ring_size - 1) & guest.last_used_idx;
148         unsigned index;
149         void *datap;
150
151         if (ring[head].flags & DESC_HW)
152                 return NULL;
153         /* Barrier B (for pairing) */
154         smp_acquire();
155         *lenp = ring[head].len;
156         index = ring[head].index & (ring_size - 1);
157         datap = data[index].data;
158         *bufp = data[index].buf;
159         data[index].buf = NULL;
160         data[index].data = NULL;
161         guest.num_free++;
162         guest.last_used_idx++;
163         return datap;
164 }
165
166 bool used_empty()
167 {
168         unsigned head = (ring_size - 1) & guest.last_used_idx;
169
170         return (ring[head].flags & DESC_HW);
171 }
172
173 void disable_call()
174 {
175         /* Doing nothing to disable calls might cause
176          * extra interrupts, but reduces the number of cache misses.
177          */
178 }
179
180 bool enable_call()
181 {
182         event->call_index = guest.last_used_idx;
183         /* Flush call index write */
184         /* Barrier D (for pairing) */
185         smp_mb();
186         return used_empty();
187 }
188
189 void kick_available(void)
190 {
191         /* Flush in previous flags write */
192         /* Barrier C (for pairing) */
193         smp_mb();
194         if (!need_event(event->kick_index,
195                         guest.avail_idx,
196                         guest.kicked_avail_idx))
197                 return;
198
199         guest.kicked_avail_idx = guest.avail_idx;
200         kick();
201 }
202
203 /* host side */
204 void disable_kick()
205 {
206         /* Doing nothing to disable kicks might cause
207          * extra interrupts, but reduces the number of cache misses.
208          */
209 }
210
211 bool enable_kick()
212 {
213         event->kick_index = host.used_idx;
214         /* Barrier C (for pairing) */
215         smp_mb();
216         return avail_empty();
217 }
218
219 bool avail_empty()
220 {
221         unsigned head = (ring_size - 1) & host.used_idx;
222
223         return !(ring[head].flags & DESC_HW);
224 }
225
226 bool use_buf(unsigned *lenp, void **bufp)
227 {
228         unsigned head = (ring_size - 1) & host.used_idx;
229
230         if (!(ring[head].flags & DESC_HW))
231                 return false;
232
233         /* make sure length read below is not speculated */
234         /* Barrier A (for pairing) */
235         smp_acquire();
236
237         /* simple in-order completion: we don't need
238          * to touch index at all. This also means we
239          * can just modify the descriptor in-place.
240          */
241         ring[head].len--;
242         /* Make sure len is valid before flags.
243          * Note: alternative is to write len and flags in one access -
244          * possible on 64 bit architectures but wmb is free on Intel anyway
245          * so I have no way to test whether it's a gain.
246          */
247         /* Barrier B (for pairing) */
248         smp_release();
249         ring[head].flags = 0;
250         host.used_idx++;
251         return true;
252 }
253
254 void call_used(void)
255 {
256         /* Flush in previous flags write */
257         /* Barrier D (for pairing) */
258         smp_mb();
259         if (!need_event(event->call_index,
260                         host.used_idx,
261                         host.called_used_idx))
262                 return;
263
264         host.called_used_idx = host.used_idx;
265         call();
266 }