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