Update fio io engine version
[fio.git] / engines / posixaio.c
CommitLineData
2866c82d 1/*
da751ca9
JA
2 * posixaio engine
3 *
4 * IO engine that uses the posix defined aio interface.
2866c82d
JA
5 *
6 */
7#include <stdio.h>
8#include <stdlib.h>
9#include <unistd.h>
10#include <errno.h>
11#include <assert.h>
5f350952
JA
12
13#include "../fio.h"
14#include "../os.h"
2866c82d 15
34cfcdaf
JA
16#ifdef FIO_HAVE_POSIXAIO
17
2866c82d
JA
18struct posixaio_data {
19 struct io_u **aio_events;
20};
21
22static int fill_timespec(struct timespec *ts)
23{
24#ifdef _POSIX_TIMERS
25 if (!clock_gettime(CLOCK_MONOTONIC, ts))
26 return 0;
27
28 perror("clock_gettime");
29#endif
30 return 1;
31}
32
33static unsigned long long ts_utime_since_now(struct timespec *t)
34{
35 long long sec, nsec;
36 struct timespec now;
37
38 if (fill_timespec(&now))
39 return 0;
40
41 sec = now.tv_sec - t->tv_sec;
42 nsec = now.tv_nsec - t->tv_nsec;
43 if (sec > 0 && nsec < 0) {
44 sec--;
45 nsec += 1000000000;
46 }
47
48 sec *= 1000000;
49 nsec /= 1000;
50 return sec + nsec;
51}
52
7a16dd02
JA
53static int fio_posixaio_cancel(struct thread_data fio_unused *td,
54 struct io_u *io_u)
2866c82d 55{
53cdc686
JA
56 struct fio_file *f = io_u->file;
57 int r = aio_cancel(f->fd, &io_u->aiocb);
2866c82d
JA
58
59 if (r == 1 || r == AIO_CANCELED)
60 return 0;
61
62 return 1;
63}
64
7a16dd02
JA
65static int fio_posixaio_prep(struct thread_data fio_unused *td,
66 struct io_u *io_u)
2866c82d
JA
67{
68 struct aiocb *aiocb = &io_u->aiocb;
53cdc686 69 struct fio_file *f = io_u->file;
2866c82d 70
53cdc686 71 aiocb->aio_fildes = f->fd;
cec6b55d
JA
72 aiocb->aio_buf = io_u->xfer_buf;
73 aiocb->aio_nbytes = io_u->xfer_buflen;
2866c82d
JA
74 aiocb->aio_offset = io_u->offset;
75
76 io_u->seen = 0;
77 return 0;
78}
79
80static int fio_posixaio_getevents(struct thread_data *td, int min, int max,
81 struct timespec *t)
82{
83 struct posixaio_data *pd = td->io_ops->data;
84 struct list_head *entry;
85 struct timespec start;
86 int r, have_timeout = 0;
87
88 if (t && !fill_timespec(&start))
89 have_timeout = 1;
90
91 r = 0;
92restart:
93 list_for_each(entry, &td->io_u_busylist) {
94 struct io_u *io_u = list_entry(entry, struct io_u, list);
95 int err;
96
97 if (io_u->seen)
98 continue;
99
100 err = aio_error(&io_u->aiocb);
3f344316
JA
101 if (err == EINPROGRESS)
102 continue;
103
104 io_u->seen = 1;
105 pd->aio_events[r++] = io_u;
106
107 if (err == ECANCELED)
108 io_u->resid = io_u->xfer_buflen;
109 else if (!err) {
110 ssize_t retval = aio_return(&io_u->aiocb);
111
112 io_u->resid = io_u->xfer_buflen - retval;
113 } else
114 io_u->error = err;
2866c82d
JA
115
116 if (r >= max)
117 break;
118 }
119
120 if (r >= min)
121 return r;
122
123 if (have_timeout) {
124 unsigned long long usec;
125
126 usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
127 if (ts_utime_since_now(&start) > usec)
128 return r;
129 }
130
131 /*
132 * hrmpf, we need to wait for more. we should use aio_suspend, for
133 * now just sleep a little and recheck status of busy-and-not-seen
134 */
135 usleep(1000);
136 goto restart;
137}
138
139static struct io_u *fio_posixaio_event(struct thread_data *td, int event)
140{
141 struct posixaio_data *pd = td->io_ops->data;
142
143 return pd->aio_events[event];
144}
145
146static int fio_posixaio_queue(struct thread_data fio_unused *td,
147 struct io_u *io_u)
148{
149 struct aiocb *aiocb = &io_u->aiocb;
150 int ret;
151
152 if (io_u->ddir == DDIR_READ)
153 ret = aio_read(aiocb);
87dc1ab1 154 else if (io_u->ddir == DDIR_WRITE)
2866c82d 155 ret = aio_write(aiocb);
87dc1ab1
JA
156 else
157 ret = aio_fsync(O_SYNC, aiocb);
2866c82d 158
95bcd815 159 if (ret) {
2866c82d 160 io_u->error = errno;
e1161c32 161 td_verror(td, io_u->error, "xfer");
36167d82 162 return FIO_Q_COMPLETED;
95bcd815 163 }
36167d82
JA
164
165 return FIO_Q_QUEUED;
2866c82d
JA
166}
167
168static void fio_posixaio_cleanup(struct thread_data *td)
169{
170 struct posixaio_data *pd = td->io_ops->data;
171
172 if (pd) {
173 free(pd->aio_events);
174 free(pd);
175 td->io_ops->data = NULL;
176 }
177}
178
179static int fio_posixaio_init(struct thread_data *td)
180{
181 struct posixaio_data *pd = malloc(sizeof(*pd));
182
cb781c75 183 memset(pd, 0, sizeof(*pd));
2dc1bbeb
JA
184 pd->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *));
185 memset(pd->aio_events, 0, td->o.iodepth * sizeof(struct io_u *));
2866c82d
JA
186
187 td->io_ops->data = pd;
188 return 0;
189}
190
5f350952 191static struct ioengine_ops ioengine = {
2866c82d
JA
192 .name = "posixaio",
193 .version = FIO_IOOPS_VERSION,
194 .init = fio_posixaio_init,
195 .prep = fio_posixaio_prep,
196 .queue = fio_posixaio_queue,
197 .cancel = fio_posixaio_cancel,
198 .getevents = fio_posixaio_getevents,
199 .event = fio_posixaio_event,
200 .cleanup = fio_posixaio_cleanup,
b5af8293
JA
201 .open_file = generic_open_file,
202 .close_file = generic_close_file,
2866c82d 203};
34cfcdaf
JA
204
205#else /* FIO_HAVE_POSIXAIO */
206
207/*
208 * When we have a proper configure system in place, we simply wont build
209 * and install this io engine. For now install a crippled version that
210 * just complains and fails to load.
211 */
212static int fio_posixaio_init(struct thread_data fio_unused *td)
213{
214 fprintf(stderr, "fio: posixaio not available\n");
215 return 1;
216}
217
5f350952 218static struct ioengine_ops ioengine = {
34cfcdaf
JA
219 .name = "posixaio",
220 .version = FIO_IOOPS_VERSION,
221 .init = fio_posixaio_init,
222};
223
224#endif
5f350952
JA
225
226static void fio_init fio_posixaio_register(void)
227{
228 register_ioengine(&ioengine);
229}
230
231static void fio_exit fio_posixaio_unregister(void)
232{
233 unregister_ioengine(&ioengine);
234}