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