Issue time fixup for guasi/libaio
[fio.git] / engines / posixaio.c
1 /*
2  * posixaio engine
3  *
4  * IO engine that uses the posix defined aio interface.
5  *
6  */
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <unistd.h>
10 #include <errno.h>
11 #include <fcntl.h>
12
13 #include "../fio.h"
14
15 #ifdef FIO_HAVE_POSIXAIO
16
17 struct posixaio_data {
18         struct io_u **aio_events;
19         unsigned int queued;
20 };
21
22 static 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
33 static 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
53 static int fio_posixaio_cancel(struct thread_data fio_unused *td,
54                                struct io_u *io_u)
55 {
56         struct fio_file *f = io_u->file;
57         int r = aio_cancel(f->fd, &io_u->aiocb);
58
59         if (r == 1 || r == AIO_CANCELED)
60                 return 0;
61
62         return 1;
63 }
64
65 static int fio_posixaio_prep(struct thread_data fio_unused *td,
66                              struct io_u *io_u)
67 {
68         struct aiocb *aiocb = &io_u->aiocb;
69         struct fio_file *f = io_u->file;
70
71         aiocb->aio_fildes = f->fd;
72         aiocb->aio_buf = io_u->xfer_buf;
73         aiocb->aio_nbytes = io_u->xfer_buflen;
74         aiocb->aio_offset = io_u->offset;
75
76         io_u->seen = 0;
77         return 0;
78 }
79
80 #define SUSPEND_ENTRIES 8
81
82 static int fio_posixaio_getevents(struct thread_data *td, unsigned int min,
83                                   unsigned int max, struct timespec *t)
84 {
85         struct posixaio_data *pd = td->io_ops->data;
86         struct aiocb *suspend_list[SUSPEND_ENTRIES];
87         struct flist_head *entry;
88         struct timespec start;
89         int have_timeout = 0;
90         int suspend_entries = 0;
91         unsigned int r;
92
93         if (t && !fill_timespec(&start))
94                 have_timeout = 1;
95
96         r = 0;
97         memset(suspend_list, 0, sizeof(*suspend_list));
98 restart:
99         flist_for_each(entry, &td->io_u_busylist) {
100                 struct io_u *io_u = flist_entry(entry, struct io_u, list);
101                 int err;
102
103                 if (io_u->seen)
104                         continue;
105
106                 err = aio_error(&io_u->aiocb);
107                 if (err == EINPROGRESS) {
108                         if (suspend_entries < SUSPEND_ENTRIES) {
109                                 suspend_list[suspend_entries] = &io_u->aiocb;
110                                 suspend_entries++;
111                         }
112                         continue;
113                 }
114
115                 io_u->seen = 1;
116                 pd->queued--;
117                 pd->aio_events[r++] = io_u;
118
119                 if (err == ECANCELED)
120                         io_u->resid = io_u->xfer_buflen;
121                 else if (!err) {
122                         ssize_t retval = aio_return(&io_u->aiocb);
123
124                         io_u->resid = io_u->xfer_buflen - retval;
125                 } else
126                         io_u->error = err;
127
128                 if (r >= max)
129                         break;
130         }
131
132         if (r >= min)
133                 return r;
134
135         if (have_timeout) {
136                 unsigned long long usec;
137
138                 usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
139                 if (ts_utime_since_now(&start) > usec)
140                         return r;
141         }
142
143         /*
144          * must have some in-flight, wait for at least one
145          */
146         aio_suspend((const struct aiocb * const *)suspend_list,
147                                                         suspend_entries, t);
148         goto restart;
149 }
150
151 static struct io_u *fio_posixaio_event(struct thread_data *td, int event)
152 {
153         struct posixaio_data *pd = td->io_ops->data;
154
155         return pd->aio_events[event];
156 }
157
158 static int fio_posixaio_queue(struct thread_data fio_unused *td,
159                               struct io_u *io_u)
160 {
161         struct posixaio_data *pd = td->io_ops->data;
162         struct aiocb *aiocb = &io_u->aiocb;
163         int ret;
164
165         fio_ro_check(td, io_u);
166
167         if (io_u->ddir == DDIR_READ)
168                 ret = aio_read(aiocb);
169         else if (io_u->ddir == DDIR_WRITE)
170                 ret = aio_write(aiocb);
171         else {
172 #ifdef FIO_HAVE_POSIXAIO_FSYNC
173                 ret = aio_fsync(O_SYNC, aiocb);
174 #else
175                 if (pd->queued)
176                         return FIO_Q_BUSY;
177
178                 if (fsync(io_u->file->fd) < 0)
179                         io_u->error = errno;
180
181                 return FIO_Q_COMPLETED;
182 #endif
183         }
184                 
185         if (ret) {
186                 io_u->error = errno;
187                 td_verror(td, io_u->error, "xfer");
188                 return FIO_Q_COMPLETED;
189         }
190
191         pd->queued++;
192         return FIO_Q_QUEUED;
193 }
194
195 static void fio_posixaio_cleanup(struct thread_data *td)
196 {
197         struct posixaio_data *pd = td->io_ops->data;
198
199         if (pd) {
200                 free(pd->aio_events);
201                 free(pd);
202         }
203 }
204
205 static int fio_posixaio_init(struct thread_data *td)
206 {
207         struct posixaio_data *pd = malloc(sizeof(*pd));
208
209         memset(pd, 0, sizeof(*pd));
210         pd->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *));
211         memset(pd->aio_events, 0, td->o.iodepth * sizeof(struct io_u *));
212
213         td->io_ops->data = pd;
214         return 0;
215 }
216
217 static struct ioengine_ops ioengine = {
218         .name           = "posixaio",
219         .version        = FIO_IOOPS_VERSION,
220         .init           = fio_posixaio_init,
221         .prep           = fio_posixaio_prep,
222         .queue          = fio_posixaio_queue,
223         .cancel         = fio_posixaio_cancel,
224         .getevents      = fio_posixaio_getevents,
225         .event          = fio_posixaio_event,
226         .cleanup        = fio_posixaio_cleanup,
227         .open_file      = generic_open_file,
228         .close_file     = generic_close_file,
229 };
230
231 #else /* FIO_HAVE_POSIXAIO */
232
233 /*
234  * When we have a proper configure system in place, we simply wont build
235  * and install this io engine. For now install a crippled version that
236  * just complains and fails to load.
237  */
238 static int fio_posixaio_init(struct thread_data fio_unused *td)
239 {
240         fprintf(stderr, "fio: posixaio not available\n");
241         return 1;
242 }
243
244 static struct ioengine_ops ioengine = {
245         .name           = "posixaio",
246         .version        = FIO_IOOPS_VERSION,
247         .init           = fio_posixaio_init,
248 };
249
250 #endif
251
252 static void fio_init fio_posixaio_register(void)
253 {
254         register_ioengine(&ioengine);
255 }
256
257 static void fio_exit fio_posixaio_unregister(void)
258 {
259         unregister_ioengine(&ioengine);
260 }