7c44927a3b8b5a3ac39b37b4eb43ed6760582d87
[fio.git] / engines / libaio.c
1 /*
2  * libaio engine
3  *
4  * IO engine using the Linux native 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_LIBAIO
17
18 #define ev_to_iou(ev)   (struct io_u *) ((unsigned long) (ev)->obj)
19
20 struct libaio_data {
21         io_context_t aio_ctx;
22         struct io_event *aio_events;
23         struct iocb **iocbs;
24         struct io_u **io_us;
25         int iocbs_nr;
26 };
27
28 static int fio_libaio_prep(struct thread_data fio_unused *td, struct io_u *io_u)
29 {
30         struct fio_file *f = io_u->file;
31
32         if (io_u->ddir == DDIR_READ)
33                 io_prep_pread(&io_u->iocb, f->fd, io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
34         else if (io_u->ddir == DDIR_WRITE)
35                 io_prep_pwrite(&io_u->iocb, f->fd, io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
36         else if (io_u->ddir == DDIR_SYNC)
37                 io_prep_fsync(&io_u->iocb, f->fd);
38         else
39                 return 1;
40
41         return 0;
42 }
43
44 static struct io_u *fio_libaio_event(struct thread_data *td, int event)
45 {
46         struct libaio_data *ld = td->io_ops->data;
47         struct io_event *ev;
48         struct io_u *io_u;
49
50         ev = ld->aio_events + event;
51         io_u = ev_to_iou(ev);
52
53         if (ev->res != io_u->xfer_buflen) {
54                 if (ev->res > io_u->xfer_buflen)
55                         io_u->error = -ev->res;
56                 else
57                         io_u->resid = io_u->xfer_buflen - ev->res;
58         } else
59                 io_u->error = 0;
60
61         return io_u;
62 }
63
64 static int fio_libaio_getevents(struct thread_data *td, int min, int max,
65                                 struct timespec *t)
66 {
67         struct libaio_data *ld = td->io_ops->data;
68         long r;
69
70         do {
71                 r = io_getevents(ld->aio_ctx, min, max, ld->aio_events, t);
72                 if (r >= min)
73                         break;
74                 else if (r == -EAGAIN) {
75                         usleep(100);
76                         continue;
77                 } else if (r == -EINTR)
78                         continue;
79                 else if (r != 0)
80                         break;
81         } while (1);
82
83         return r;
84 }
85
86 static int fio_libaio_queue(struct thread_data *td, struct io_u *io_u)
87 {
88         struct libaio_data *ld = td->io_ops->data;
89
90         if (ld->iocbs_nr == (int) td->o.iodepth)
91                 return FIO_Q_BUSY;
92
93         /*
94          * fsync is tricky, since it can fail and we need to do it
95          * serialized with other io. the reason is that linux doesn't
96          * support aio fsync yet. So return busy for the case where we
97          * have pending io, to let fio complete those first.
98          */
99         if (io_u->ddir == DDIR_SYNC) {
100                 if (ld->iocbs_nr)
101                         return FIO_Q_BUSY;
102                 if (fsync(io_u->file->fd) < 0)
103                         io_u->error = errno;
104
105                 return FIO_Q_COMPLETED;
106         }
107
108         ld->iocbs[ld->iocbs_nr] = &io_u->iocb;
109         ld->io_us[ld->iocbs_nr] = io_u;
110         ld->iocbs_nr++;
111         return FIO_Q_QUEUED;
112 }
113
114 static void fio_libaio_queued(struct thread_data *td, struct io_u **io_us,
115                               unsigned int nr)
116 {
117         struct timeval now;
118         unsigned int i;
119
120         fio_gettime(&now, NULL);
121
122         for (i = 0; i < nr; i++) {
123                 struct io_u *io_u = io_us[i];
124
125                 memcpy(&io_u->issue_time, &now, sizeof(now));
126                 io_u_queued(td, io_u);
127         }
128 }
129
130 static int fio_libaio_commit(struct thread_data *td)
131 {
132         struct libaio_data *ld = td->io_ops->data;
133         struct iocb **iocbs;
134         struct io_u **io_us;
135         int ret, iocbs_nr;
136
137         if (!ld->iocbs_nr)
138                 return 0;
139
140         iocbs_nr = ld->iocbs_nr;
141         io_us = ld->io_us;
142         iocbs = ld->iocbs;
143         do {
144                 ret = io_submit(ld->aio_ctx, iocbs_nr, iocbs);
145                 if (ret == iocbs_nr) {
146                         fio_libaio_queued(td, io_us, ret);
147                         ret = 0;
148                         break;
149                 } else if (ret > 0) {
150                         fio_libaio_queued(td, io_us, ret);
151                         io_us += ret;
152                         iocbs += ret;
153                         iocbs_nr -= ret;
154                         continue;
155                 } else if (ret == -EAGAIN || !ret)
156                         usleep(100);
157                 else if (ret == -EINTR)
158                         continue;
159                 else
160                         break;
161         } while (1);
162
163         if (!ret)
164                 ld->iocbs_nr = 0;
165
166         return ret;
167 }
168
169 static int fio_libaio_cancel(struct thread_data *td, struct io_u *io_u)
170 {
171         struct libaio_data *ld = td->io_ops->data;
172
173         return io_cancel(ld->aio_ctx, &io_u->iocb, ld->aio_events);
174 }
175
176 static void fio_libaio_cleanup(struct thread_data *td)
177 {
178         struct libaio_data *ld = td->io_ops->data;
179
180         if (ld) {
181                 io_destroy(ld->aio_ctx);
182                 free(ld->aio_events);
183                 free(ld->iocbs);
184                 free(ld->io_us);
185                 free(ld);
186                 td->io_ops->data = NULL;
187         }
188 }
189
190 static int fio_libaio_init(struct thread_data *td)
191 {
192         struct libaio_data *ld = malloc(sizeof(*ld));
193         int err;
194
195         memset(ld, 0, sizeof(*ld));
196
197         err = io_queue_init(td->o.iodepth, &ld->aio_ctx);
198         if (err) {
199                 td_verror(td, -err, "io_queue_init");
200                 free(ld);
201                 return 1;
202         }
203
204         ld->aio_events = malloc(td->o.iodepth * sizeof(struct io_event));
205         memset(ld->aio_events, 0, td->o.iodepth * sizeof(struct io_event));
206         ld->iocbs = malloc(td->o.iodepth * sizeof(struct iocb *));
207         memset(ld->iocbs, 0, sizeof(struct iocb *));
208         ld->io_us = malloc(td->o.iodepth * sizeof(struct io_u *));
209         memset(ld->io_us, 0, td->o.iodepth * sizeof(struct io_u *));
210         ld->iocbs_nr = 0;
211
212         td->io_ops->data = ld;
213         return 0;
214 }
215
216 static struct ioengine_ops ioengine = {
217         .name           = "libaio",
218         .version        = FIO_IOOPS_VERSION,
219         .init           = fio_libaio_init,
220         .prep           = fio_libaio_prep,
221         .queue          = fio_libaio_queue,
222         .commit         = fio_libaio_commit,
223         .cancel         = fio_libaio_cancel,
224         .getevents      = fio_libaio_getevents,
225         .event          = fio_libaio_event,
226         .cleanup        = fio_libaio_cleanup,
227         .open_file      = generic_open_file,
228         .close_file     = generic_close_file,
229 };
230
231 #else /* FIO_HAVE_LIBAIO */
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_libaio_init(struct thread_data fio_unused *td)
239 {
240         fprintf(stderr, "fio: libaio not available\n");
241         return 1;
242 }
243
244 static struct ioengine_ops ioengine = {
245         .name           = "libaio",
246         .version        = FIO_IOOPS_VERSION,
247         .init           = fio_libaio_init,
248 };
249
250 #endif
251
252 static void fio_init fio_libaio_register(void)
253 {
254         register_ioengine(&ioengine);
255 }
256
257 static void fio_exit fio_libaio_unregister(void)
258 {
259         unregister_ioengine(&ioengine);
260 }