7d9aaaf18314bffe3ea30fe211918d69e89b8095
[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 <assert.h>
12
13 #include "../fio.h"
14 #include "../os.h"
15
16 #ifdef FIO_HAVE_POSIXAIO
17
18 struct posixaio_data {
19         struct io_u **aio_events;
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 static 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;
92 restart:
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);
101                 switch (err) {
102                         default:
103                                 io_u->error = err;
104                         case ECANCELED:
105                                 io_u->resid = io_u->xfer_buflen;
106                         case 0:
107                                 pd->aio_events[r++] = io_u;
108                                 io_u->seen = 1;
109                                 break;
110                         case EINPROGRESS:
111                                 break;
112                 }
113
114                 if (r >= max)
115                         break;
116         }
117
118         if (r >= min)
119                 return r;
120
121         if (have_timeout) {
122                 unsigned long long usec;
123
124                 usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
125                 if (ts_utime_since_now(&start) > usec)
126                         return r;
127         }
128
129         /*
130          * hrmpf, we need to wait for more. we should use aio_suspend, for
131          * now just sleep a little and recheck status of busy-and-not-seen
132          */
133         usleep(1000);
134         goto restart;
135 }
136
137 static struct io_u *fio_posixaio_event(struct thread_data *td, int event)
138 {
139         struct posixaio_data *pd = td->io_ops->data;
140
141         return pd->aio_events[event];
142 }
143
144 static int fio_posixaio_queue(struct thread_data fio_unused *td,
145                               struct io_u *io_u)
146 {
147         struct aiocb *aiocb = &io_u->aiocb;
148         int ret;
149
150         if (io_u->ddir == DDIR_READ)
151                 ret = aio_read(aiocb);
152         else if (io_u->ddir == DDIR_WRITE)
153                 ret = aio_write(aiocb);
154         else
155                 ret = aio_fsync(O_SYNC, aiocb);
156
157         if (ret) {
158                 io_u->error = errno;
159                 td_verror(td, io_u->error, "xfer");
160                 return FIO_Q_COMPLETED;
161         }
162
163         return FIO_Q_QUEUED;
164 }
165
166 static void fio_posixaio_cleanup(struct thread_data *td)
167 {
168         struct posixaio_data *pd = td->io_ops->data;
169
170         if (pd) {
171                 free(pd->aio_events);
172                 free(pd);
173                 td->io_ops->data = NULL;
174         }
175 }
176
177 static int fio_posixaio_init(struct thread_data *td)
178 {
179         struct posixaio_data *pd = malloc(sizeof(*pd));
180
181         memset(pd, 0, sizeof(*pd));
182         pd->aio_events = malloc(td->iodepth * sizeof(struct io_u *));
183         memset(pd->aio_events, 0, td->iodepth * sizeof(struct io_u *));
184
185         td->io_ops->data = pd;
186         return 0;
187 }
188
189 static struct ioengine_ops ioengine = {
190         .name           = "posixaio",
191         .version        = FIO_IOOPS_VERSION,
192         .init           = fio_posixaio_init,
193         .prep           = fio_posixaio_prep,
194         .queue          = fio_posixaio_queue,
195         .cancel         = fio_posixaio_cancel,
196         .getevents      = fio_posixaio_getevents,
197         .event          = fio_posixaio_event,
198         .cleanup        = fio_posixaio_cleanup,
199         .open_file      = generic_open_file,
200         .close_file     = generic_close_file,
201 };
202
203 #else /* FIO_HAVE_POSIXAIO */
204
205 /*
206  * When we have a proper configure system in place, we simply wont build
207  * and install this io engine. For now install a crippled version that
208  * just complains and fails to load.
209  */
210 static int fio_posixaio_init(struct thread_data fio_unused *td)
211 {
212         fprintf(stderr, "fio: posixaio not available\n");
213         return 1;
214 }
215
216 static struct ioengine_ops ioengine = {
217         .name           = "posixaio",
218         .version        = FIO_IOOPS_VERSION,
219         .init           = fio_posixaio_init,
220 };
221
222 #endif
223
224 static void fio_init fio_posixaio_register(void)
225 {
226         register_ioengine(&ioengine);
227 }
228
229 static void fio_exit fio_posixaio_unregister(void)
230 {
231         unregister_ioengine(&ioengine);
232 }