Duplicate name checks in ioengines.c
[fio.git] / engines / syslet-rw.c
CommitLineData
a4f4fdd7
JA
1/*
2 * read/write() engine that uses syslet to be async
3 *
4 */
5#include <stdio.h>
6#include <stdlib.h>
7#include <unistd.h>
8#include <errno.h>
9#include <assert.h>
10
11#include "../fio.h"
12#include "../os.h"
13
14#ifdef FIO_HAVE_SYSLET
15
16struct syslet_data {
17 struct io_u **events;
18 unsigned int nr_events;
19
bf0dc8fa 20 struct async_head_user ahu;
a4f4fdd7 21 struct syslet_uatom **ring;
9ff9de69
JA
22
23 struct syslet_uatom *head, *tail;
a4f4fdd7
JA
24};
25
9ff9de69
JA
26static void fio_syslet_complete_atom(struct thread_data *td,
27 struct syslet_uatom *atom)
28{
29 struct syslet_data *sd = td->io_ops->data;
5b38ee84 30 struct syslet_uatom *last;
9ff9de69 31 struct io_u *io_u;
9ff9de69
JA
32
33 /*
5b38ee84
JA
34 * complete from the beginning of the sequence up to (and
35 * including) this atom
9ff9de69 36 */
5b38ee84
JA
37 last = atom;
38 io_u = atom->private;
39 atom = io_u->req.head;
9ff9de69
JA
40
41 /*
42 * now complete in right order
43 */
5b38ee84 44 do {
9ff9de69
JA
45 long ret;
46
9ff9de69
JA
47 io_u = atom->private;
48 ret = *atom->ret_ptr;
49 if (ret > 0)
50 io_u->resid = io_u->xfer_buflen - ret;
51 else if (ret < 0)
52 io_u->error = ret;
53
54 assert(sd->nr_events < td->iodepth);
55 sd->events[sd->nr_events++] = io_u;
9ff9de69 56
5b38ee84
JA
57 if (atom == last)
58 break;
9ff9de69 59
5b38ee84
JA
60 atom = atom->next;
61 } while (1);
62
63 assert(!last->next);
9ff9de69
JA
64}
65
a4f4fdd7
JA
66/*
67 * Inspect the ring to see if we have completed events
68 */
69static void fio_syslet_complete(struct thread_data *td)
70{
71 struct syslet_data *sd = td->io_ops->data;
72
73 do {
74 struct syslet_uatom *atom;
a4f4fdd7 75
bf0dc8fa 76 atom = sd->ring[sd->ahu.user_ring_idx];
a4f4fdd7
JA
77 if (!atom)
78 break;
79
bf0dc8fa
IM
80 sd->ring[sd->ahu.user_ring_idx] = NULL;
81 if (++sd->ahu.user_ring_idx == td->iodepth)
82 sd->ahu.user_ring_idx = 0;
a4f4fdd7 83
9ff9de69 84 fio_syslet_complete_atom(td, atom);
a4f4fdd7
JA
85 } while (1);
86}
87
88static int fio_syslet_getevents(struct thread_data *td, int min,
89 int fio_unused max,
90 struct timespec fio_unused *t)
91{
92 struct syslet_data *sd = td->io_ops->data;
a4f4fdd7
JA
93 long ret;
94
95 do {
96 fio_syslet_complete(td);
97
98 /*
99 * do we have enough immediate completions?
100 */
101 if (sd->nr_events >= (unsigned int) min)
102 break;
103
104 /*
105 * OK, we need to wait for some events...
106 */
9ff9de69 107 ret = async_wait(1, sd->ahu.user_ring_idx, &sd->ahu);
a4f4fdd7 108 if (ret < 0)
e49499f8 109 return -errno;
a4f4fdd7
JA
110 } while (1);
111
112 ret = sd->nr_events;
113 sd->nr_events = 0;
114 return ret;
115}
116
117static struct io_u *fio_syslet_event(struct thread_data *td, int event)
118{
119 struct syslet_data *sd = td->io_ops->data;
120
121 return sd->events[event];
122}
123
124static void init_atom(struct syslet_uatom *atom, int nr, void *arg0,
a2e1b08a
JA
125 void *arg1, void *arg2, void *arg3, void *ret_ptr,
126 unsigned long flags, void *priv)
a4f4fdd7
JA
127{
128 atom->flags = flags;
129 atom->nr = nr;
130 atom->ret_ptr = ret_ptr;
a2e1b08a 131 atom->next = NULL;
a4f4fdd7
JA
132 atom->arg_ptr[0] = arg0;
133 atom->arg_ptr[1] = arg1;
134 atom->arg_ptr[2] = arg2;
a2e1b08a
JA
135 atom->arg_ptr[3] = arg3;
136 atom->arg_ptr[4] = atom->arg_ptr[5] = NULL;
a4f4fdd7
JA
137 atom->private = priv;
138}
139
140/*
141 * Use seek atom for sync
142 */
143static void fio_syslet_prep_sync(struct io_u *io_u, struct fio_file *f)
144{
a2e1b08a 145 init_atom(&io_u->req.atom, __NR_fsync, &f->fd, NULL, NULL, NULL,
7d44a745 146 &io_u->req.ret, 0, io_u);
a4f4fdd7
JA
147}
148
149static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f)
150{
151 int nr;
152
a4f4fdd7
JA
153 /*
154 * prepare rw
155 */
156 if (io_u->ddir == DDIR_READ)
a2e1b08a 157 nr = __NR_pread64;
a4f4fdd7 158 else
a2e1b08a 159 nr = __NR_pwrite64;
a4f4fdd7 160
a2e1b08a 161 init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf,
7d44a745 162 &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u);
a4f4fdd7
JA
163}
164
165static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u)
166{
167 struct fio_file *f = io_u->file;
168
169 if (io_u->ddir == DDIR_SYNC)
170 fio_syslet_prep_sync(io_u, f);
171 else
172 fio_syslet_prep_rw(io_u, f);
173
174 return 0;
175}
176
bf0dc8fa
IM
177static void cachemiss_thread_start(void)
178{
179 while (1)
7756b0d0 180 async_thread(NULL, NULL);
bf0dc8fa
IM
181}
182
183#define THREAD_STACK_SIZE (16384)
184
185static unsigned long thread_stack_alloc()
186{
5b38ee84 187 return (unsigned long) malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE;
bf0dc8fa
IM
188}
189
a0a930ef
JA
190static void fio_syslet_queued(struct thread_data *td, struct syslet_data *sd)
191{
192 struct syslet_uatom *atom;
193 struct timeval now;
194
195 fio_gettime(&now, NULL);
196
197 atom = sd->head;
198 while (atom) {
199 struct io_u *io_u = atom->private;
200
201 memcpy(&io_u->issue_time, &now, sizeof(now));
202 io_u_queued(td, io_u);
203 atom = atom->next;
204 }
205}
206
9ff9de69 207static int fio_syslet_commit(struct thread_data *td)
a4f4fdd7
JA
208{
209 struct syslet_data *sd = td->io_ops->data;
bf0dc8fa 210 struct syslet_uatom *done;
9ff9de69
JA
211
212 if (!sd->head)
213 return 0;
a4f4fdd7 214
5b38ee84
JA
215 assert(!sd->tail->next);
216
bf0dc8fa
IM
217 if (!sd->ahu.new_thread_stack)
218 sd->ahu.new_thread_stack = thread_stack_alloc();
219
a0a930ef
JA
220 fio_syslet_queued(td, sd);
221
7d44a745
JA
222 /*
223 * On sync completion, the atom is returned. So on NULL return
224 * it's queued asynchronously.
225 */
9ff9de69 226 done = async_exec(sd->head, &sd->ahu);
bf0dc8fa 227
9ff9de69 228 sd->head = sd->tail = NULL;
a4f4fdd7 229
9ff9de69
JA
230 if (done)
231 fio_syslet_complete_atom(td, done);
a4f4fdd7 232
9ff9de69
JA
233 return 0;
234}
235
236static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u)
237{
238 struct syslet_data *sd = td->io_ops->data;
bf0dc8fa 239
9ff9de69
JA
240 if (sd->tail) {
241 sd->tail->next = &io_u->req.atom;
242 sd->tail = &io_u->req.atom;
243 } else
244 sd->head = sd->tail = &io_u->req.atom;
a4f4fdd7 245
5b38ee84 246 io_u->req.head = sd->head;
9ff9de69 247 return FIO_Q_QUEUED;
a4f4fdd7
JA
248}
249
db64e9bc 250static int async_head_init(struct syslet_data *sd, unsigned int depth)
a4f4fdd7 251{
a4f4fdd7
JA
252 unsigned long ring_size;
253
bf0dc8fa 254 memset(&sd->ahu, 0, sizeof(struct async_head_user));
2ca50be4 255
a4f4fdd7
JA
256 ring_size = sizeof(struct syslet_uatom *) * depth;
257 sd->ring = malloc(ring_size);
258 memset(sd->ring, 0, ring_size);
259
bf0dc8fa
IM
260 sd->ahu.user_ring_idx = 0;
261 sd->ahu.completion_ring = sd->ring;
262 sd->ahu.ring_size_bytes = ring_size;
263 sd->ahu.head_stack = thread_stack_alloc();
5b38ee84
JA
264 sd->ahu.head_eip = (unsigned long) cachemiss_thread_start;
265 sd->ahu.new_thread_eip = (unsigned long) cachemiss_thread_start;
db64e9bc
JA
266
267 return 0;
a4f4fdd7
JA
268}
269
2ca50be4 270static void async_head_exit(struct syslet_data *sd)
a4f4fdd7 271{
7f059a76 272 free(sd->ring);
a4f4fdd7
JA
273}
274
275static void fio_syslet_cleanup(struct thread_data *td)
276{
277 struct syslet_data *sd = td->io_ops->data;
278
279 if (sd) {
2ca50be4 280 async_head_exit(sd);
a4f4fdd7
JA
281 free(sd->events);
282 free(sd);
283 td->io_ops->data = NULL;
284 }
285}
286
287static int fio_syslet_init(struct thread_data *td)
288{
289 struct syslet_data *sd;
290
db64e9bc 291
a4f4fdd7
JA
292 sd = malloc(sizeof(*sd));
293 memset(sd, 0, sizeof(*sd));
294 sd->events = malloc(sizeof(struct io_u *) * td->iodepth);
295 memset(sd->events, 0, sizeof(struct io_u *) * td->iodepth);
db64e9bc
JA
296
297 /*
298 * This will handily fail for kernels where syslet isn't available
299 */
300 if (async_head_init(sd, td->iodepth)) {
301 free(sd->events);
302 free(sd);
303 return 1;
304 }
305
a4f4fdd7 306 td->io_ops->data = sd;
a4f4fdd7
JA
307 return 0;
308}
309
310static struct ioengine_ops ioengine = {
311 .name = "syslet-rw",
312 .version = FIO_IOOPS_VERSION,
313 .init = fio_syslet_init,
314 .prep = fio_syslet_prep,
315 .queue = fio_syslet_queue,
9ff9de69 316 .commit = fio_syslet_commit,
a4f4fdd7
JA
317 .getevents = fio_syslet_getevents,
318 .event = fio_syslet_event,
319 .cleanup = fio_syslet_cleanup,
320};
321
322#else /* FIO_HAVE_SYSLET */
323
324/*
325 * When we have a proper configure system in place, we simply wont build
326 * and install this io engine. For now install a crippled version that
327 * just complains and fails to load.
328 */
329static int fio_syslet_init(struct thread_data fio_unused *td)
330{
331 fprintf(stderr, "fio: syslet not available\n");
332 return 1;
333}
334
335static struct ioengine_ops ioengine = {
336 .name = "syslet-rw",
337 .version = FIO_IOOPS_VERSION,
338 .init = fio_syslet_init,
339};
340
341#endif /* FIO_HAVE_SYSLET */
342
343static void fio_init fio_syslet_register(void)
344{
345 register_ioengine(&ioengine);
346}
347
348static void fio_exit fio_syslet_unregister(void)
349{
350 unregister_ioengine(&ioengine);
351}