[PATCH] One more round of random map fixes
[fio.git] / engines / libaio.c
1 /*
2  * native linux aio io engine
3  *
4  */
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <unistd.h>
8 #include <errno.h>
9 #include <assert.h>
10
11 #include "../fio.h"
12 #include "../os.h"
13
14 #ifdef FIO_HAVE_LIBAIO
15
16 #define ev_to_iou(ev)   (struct io_u *) ((unsigned long) (ev)->obj)
17
18 struct libaio_data {
19         io_context_t aio_ctx;
20         struct io_event *aio_events;
21         struct io_u *sync_io_u;
22 };
23
24 static int fio_libaio_prep(struct thread_data fio_unused *td, struct io_u *io_u)
25 {
26         struct fio_file *f = io_u->file;
27
28         if (io_u->ddir == DDIR_READ)
29                 io_prep_pread(&io_u->iocb, f->fd, io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
30         else if (io_u->ddir == DDIR_WRITE)
31                 io_prep_pwrite(&io_u->iocb, f->fd, io_u->xfer_buf, io_u->xfer_buflen, io_u->offset);
32         else if (io_u->ddir == DDIR_SYNC)
33                 io_prep_fsync(&io_u->iocb, f->fd);
34         else
35                 return 1;
36
37         return 0;
38 }
39
40 static struct io_u *fio_libaio_event(struct thread_data *td, int event)
41 {
42         struct libaio_data *ld = td->io_ops->data;
43
44         if (ld->sync_io_u) {
45                 struct io_u *ret = ld->sync_io_u;
46
47                 ld->sync_io_u = NULL;
48                 return ret;
49         }
50
51         return ev_to_iou(ld->aio_events + event);
52 }
53
54 static int fio_libaio_getevents(struct thread_data *td, int min, int max,
55                                 struct timespec *t)
56 {
57         struct libaio_data *ld = td->io_ops->data;
58         long r;
59
60         if (ld->sync_io_u)
61                 return 1;
62
63         do {
64                 r = io_getevents(ld->aio_ctx, min, max, ld->aio_events, t);
65                 if (r >= min)
66                         break;
67                 else if (r == -EAGAIN) {
68                         usleep(100);
69                         continue;
70                 } else if (r == -EINTR)
71                         continue;
72                 else if (r != 0)
73                         break;
74         } while (1);
75
76         if (r < 0)
77                 r = -r;
78
79         return (int) r;
80 }
81
82 static int fio_libaio_queue(struct thread_data *td, struct io_u *io_u)
83 {
84         struct libaio_data *ld = td->io_ops->data;
85         struct iocb *iocb = &io_u->iocb;
86         long ret;
87
88         do {
89                 ret = io_submit(ld->aio_ctx, 1, &iocb);
90                 if (ret == 1)
91                         break;
92                 else if (ret == -EAGAIN || !ret)
93                         usleep(100);
94                 else if (ret == -EINTR)
95                         continue;
96                 else if (ret == -EINVAL && io_u->ddir == DDIR_SYNC) {
97                         /*
98                          * the async fsync doesn't currently seem to be
99                          * supported, so just fsync if we fail with EINVAL
100                          * for a sync. since buffered io is also sync
101                          * with libaio (still), we don't have pending
102                          * requests to flush first.
103                          */
104                         if (fsync(io_u->file->fd) < 0)
105                                 ret = errno;
106                         else {
107                                 ret = 1;
108                                 ld->sync_io_u = io_u;
109                         }
110                         break;
111                 } else
112                         break;
113         } while (1);
114
115         if (ret <= 0) {
116                 io_u->resid = io_u->xfer_buflen;
117                 io_u->error = -ret;
118                 td_verror(td, io_u->error);
119                 return 1;
120         }
121
122         return 0;
123 }
124
125 static int fio_libaio_cancel(struct thread_data *td, struct io_u *io_u)
126 {
127         struct libaio_data *ld = td->io_ops->data;
128
129         return io_cancel(ld->aio_ctx, &io_u->iocb, ld->aio_events);
130 }
131
132 static void fio_libaio_cleanup(struct thread_data *td)
133 {
134         struct libaio_data *ld = td->io_ops->data;
135
136         if (ld) {
137                 io_destroy(ld->aio_ctx);
138                 if (ld->aio_events)
139                         free(ld->aio_events);
140
141                 free(ld);
142                 td->io_ops->data = NULL;
143         }
144 }
145
146 static int fio_libaio_init(struct thread_data *td)
147 {
148         struct libaio_data *ld = malloc(sizeof(*ld));
149
150         memset(ld, 0, sizeof(*ld));
151         if (io_queue_init(td->iodepth, &ld->aio_ctx)) {
152                 td_verror(td, errno);
153                 free(ld);
154                 return 1;
155         }
156
157         ld->aio_events = malloc(td->iodepth * sizeof(struct io_event));
158         memset(ld->aio_events, 0, td->iodepth * sizeof(struct io_event));
159         td->io_ops->data = ld;
160         return 0;
161 }
162
163 static struct ioengine_ops ioengine = {
164         .name           = "libaio",
165         .version        = FIO_IOOPS_VERSION,
166         .init           = fio_libaio_init,
167         .prep           = fio_libaio_prep,
168         .queue          = fio_libaio_queue,
169         .cancel         = fio_libaio_cancel,
170         .getevents      = fio_libaio_getevents,
171         .event          = fio_libaio_event,
172         .cleanup        = fio_libaio_cleanup,
173 };
174
175 #else /* FIO_HAVE_LIBAIO */
176
177 /*
178  * When we have a proper configure system in place, we simply wont build
179  * and install this io engine. For now install a crippled version that
180  * just complains and fails to load.
181  */
182 static int fio_libaio_init(struct thread_data fio_unused *td)
183 {
184         fprintf(stderr, "fio: libaio not available\n");
185         return 1;
186 }
187
188 static struct ioengine_ops ioengine = {
189         .name           = "libaio",
190         .version        = FIO_IOOPS_VERSION,
191         .init           = fio_libaio_init,
192 };
193
194 #endif
195
196 static void fio_init fio_libaio_register(void)
197 {
198         register_ioengine(&ioengine);
199 }
200
201 static void fio_exit fio_libaio_unregister(void)
202 {
203         unregister_ioengine(&ioengine);
204 }