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