pre_read fixes
[fio.git] / engines / guasi.c
1 /*
2  * guasi engine
3  *
4  * IO engine using the GUASI library.
5  *
6  * This is currently disabled. To enable it, execute:
7  *
8  * $ export EXTFLAGS="-DFIO_HAVE_GUASI"
9  * $ export EXTLIBS="-lguasi"
10  *
11  * before running make. You'll need the GUASI lib as well:
12  *
13  * http://www.xmailserver.org/guasi-lib.html
14  *
15  */
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <errno.h>
20 #include <assert.h>
21
22 #include "../fio.h"
23
24 #ifdef FIO_HAVE_GUASI
25
26 #define GFIO_MIN_THREADS 32
27 #ifndef GFIO_MAX_THREADS
28 #define GFIO_MAX_THREADS 2000
29 #endif
30
31 #include <guasi.h>
32 #include <guasi_syscalls.h>
33
34 #ifdef GFIO_DEBUG
35 #define GDBG_PRINT(a) printf a
36 #else
37 #define GDBG_PRINT(a) (void) 0
38 #endif
39
40 struct guasi_data {
41         guasi_t hctx;
42         int max_reqs;
43         guasi_req_t *reqs;
44         struct io_u **io_us;
45         int queued_nr;
46         int reqs_nr;
47 };
48
49 static int fio_guasi_prep(struct thread_data fio_unused *td, struct io_u *io_u)
50 {
51
52         GDBG_PRINT(("fio_guasi_prep(%p)\n", io_u));
53         io_u->greq = NULL;
54
55         return 0;
56 }
57
58 static struct io_u *fio_guasi_event(struct thread_data *td, int event)
59 {
60         struct guasi_data *ld = td->io_ops->data;
61         struct io_u *io_u;
62         struct guasi_reqinfo rinf;
63
64         GDBG_PRINT(("fio_guasi_event(%d)\n", event));
65         if (guasi_req_info(ld->reqs[event], &rinf) < 0) {
66                 log_err("guasi_req_info(%d) FAILED!\n", event);
67                 return NULL;
68         }
69         io_u = rinf.asid;
70         io_u->error = EINPROGRESS;
71         GDBG_PRINT(("fio_guasi_event(%d) -> %p\n", event, io_u));
72         if (rinf.status == GUASI_STATUS_COMPLETE) {
73                 io_u->error = rinf.result;
74                 if (io_u->ddir == DDIR_READ ||
75                     io_u->ddir == DDIR_WRITE) {
76                         io_u->error = 0;
77                         if (rinf.result != (long) io_u->xfer_buflen) {
78                                 if (rinf.result >= 0)
79                                         io_u->resid = io_u->xfer_buflen - rinf.result;
80                                 else
81                                         io_u->error = rinf.error;
82                         }
83                 }
84         }
85
86         return io_u;
87 }
88
89 static int fio_guasi_getevents(struct thread_data *td, unsigned int min,
90                                unsigned int max, struct timespec *t)
91 {
92         struct guasi_data *ld = td->io_ops->data;
93         int n, r;
94         long timeo = -1;
95
96         GDBG_PRINT(("fio_guasi_getevents(%d, %d)\n", min, max));
97         if (min > ld->max_reqs)
98                 min = ld->max_reqs;
99         if (max > ld->max_reqs)
100                 max = ld->max_reqs;
101         if (t)
102                 timeo = t->tv_sec * 1000L + t->tv_nsec / 1000000L;
103         for (n = 0; n < ld->reqs_nr; n++)
104                 guasi_req_free(ld->reqs[n]);
105         n = 0;
106         do {
107                 r = guasi_fetch(ld->hctx, ld->reqs + n, min - n,
108                                 max - n, timeo);
109                 if (r < 0) {
110                         log_err("guasi_fetch() FAILED! (%d)\n", r);
111                         break;
112                 }
113                 n += r;
114                 if (n >= min)
115                         break;
116         } while (1);
117         ld->reqs_nr = n;
118         GDBG_PRINT(("fio_guasi_getevents() -> %d\n", n));
119
120         return n;
121 }
122
123 static int fio_guasi_queue(struct thread_data *td, struct io_u *io_u)
124 {
125         struct guasi_data *ld = td->io_ops->data;
126
127         fio_ro_check(td, io_u);
128
129         GDBG_PRINT(("fio_guasi_queue(%p)\n", io_u));
130         if (ld->queued_nr == (int) td->o.iodepth)
131                 return FIO_Q_BUSY;
132
133         ld->io_us[ld->queued_nr] = io_u;
134         ld->queued_nr++;
135         return FIO_Q_QUEUED;
136 }
137
138 static void fio_guasi_queued(struct thread_data *td, struct io_u **io_us, int nr)
139 {
140         int i;
141         struct io_u *io_u;
142         struct timeval now;
143
144         if (!fio_fill_issue_time(td))
145                 return;
146
147         io_u_mark_submit(td, nr);
148         fio_gettime(&now, NULL);
149         for (i = 0; i < nr; i++) {
150                 io_u = io_us[i];
151                 memcpy(&io_u->issue_time, &now, sizeof(now));
152                 io_u_queued(td, io_u);
153         }
154 }
155
156 static int fio_guasi_commit(struct thread_data *td)
157 {
158         struct guasi_data *ld = td->io_ops->data;
159         int i;
160         struct io_u *io_u;
161         struct fio_file *f;
162
163         GDBG_PRINT(("fio_guasi_commit(%d)\n", ld->queued_nr));
164         for (i = 0; i < ld->queued_nr; i++) {
165                 io_u = ld->io_us[i];
166                 GDBG_PRINT(("fio_guasi_commit(%d) --> %p\n", i, io_u));
167                 f = io_u->file;
168                 io_u->greq = NULL;
169                 if (io_u->ddir == DDIR_READ)
170                         io_u->greq = guasi__pread(ld->hctx, ld, io_u, 0,
171                                                   f->fd, io_u->xfer_buf, io_u->xfer_buflen,
172                                                   io_u->offset);
173                 else if (io_u->ddir == DDIR_WRITE)
174                         io_u->greq = guasi__pwrite(ld->hctx, ld, io_u, 0,
175                                                    f->fd, io_u->xfer_buf, io_u->xfer_buflen,
176                                                    io_u->offset);
177                 else if (io_u->ddir == DDIR_SYNC)
178                         io_u->greq = guasi__fsync(ld->hctx, ld, io_u, 0, f->fd);
179                 else {
180                         log_err("fio_guasi_commit() FAILED: unknow request %d\n",
181                                 io_u->ddir);
182                 }
183                 if (io_u->greq == NULL) {
184                         log_err("fio_guasi_commit() FAILED: submit failed (%s)\n",
185                                 strerror(errno));
186                         return -1;
187                 }
188         }
189         fio_guasi_queued(td, ld->io_us, i);
190         ld->queued_nr = 0;
191         GDBG_PRINT(("fio_guasi_commit() -> %d\n", i));
192
193         return 0;
194 }
195
196 static int fio_guasi_cancel(struct thread_data fio_unused *td,
197                             struct io_u *io_u)
198 {
199         GDBG_PRINT(("fio_guasi_cancel(%p) req=%p\n", io_u, io_u->greq));
200         if (io_u->greq != NULL)
201                 guasi_req_cancel(io_u->greq);
202
203         return 0;
204 }
205
206 static void fio_guasi_cleanup(struct thread_data *td)
207 {
208         struct guasi_data *ld = td->io_ops->data;
209         int n;
210
211         GDBG_PRINT(("fio_guasi_cleanup(%p)\n", ld));
212         if (ld) {
213                 for (n = 0; n < ld->reqs_nr; n++)
214                         guasi_req_free(ld->reqs[n]);
215                 guasi_free(ld->hctx);
216                 free(ld->reqs);
217                 free(ld->io_us);
218                 free(ld);
219         }
220         GDBG_PRINT(("fio_guasi_cleanup(%p) DONE\n", ld));
221 }
222
223 static int fio_guasi_init(struct thread_data *td)
224 {
225         int maxthr;
226         struct guasi_data *ld = malloc(sizeof(*ld));
227
228         GDBG_PRINT(("fio_guasi_init(): depth=%d\n", td->o.iodepth));
229         memset(ld, 0, sizeof(*ld));
230         maxthr = td->o.iodepth > GFIO_MIN_THREADS ? td->o.iodepth: GFIO_MIN_THREADS;
231         if (maxthr > GFIO_MAX_THREADS)
232                 maxthr = GFIO_MAX_THREADS;
233         if ((ld->hctx = guasi_create(GFIO_MIN_THREADS, maxthr, 1)) == NULL) {
234                 td_verror(td, errno, "guasi_create");
235                 free(ld);
236                 return 1;
237         }
238         ld->max_reqs = td->o.iodepth;
239         ld->reqs = malloc(ld->max_reqs * sizeof(guasi_req_t));
240         ld->io_us = malloc(ld->max_reqs * sizeof(struct io_u *));
241         memset(ld->io_us, 0, ld->max_reqs * sizeof(struct io_u *));
242         ld->queued_nr = 0;
243         ld->reqs_nr = 0;
244
245         td->io_ops->data = ld;
246         GDBG_PRINT(("fio_guasi_init(): depth=%d -> %p\n", td->o.iodepth, ld));
247
248         return 0;
249 }
250
251 static struct ioengine_ops ioengine = {
252         .name           = "guasi",
253         .version        = FIO_IOOPS_VERSION,
254         .init           = fio_guasi_init,
255         .prep           = fio_guasi_prep,
256         .queue          = fio_guasi_queue,
257         .commit         = fio_guasi_commit,
258         .cancel         = fio_guasi_cancel,
259         .getevents      = fio_guasi_getevents,
260         .event          = fio_guasi_event,
261         .cleanup        = fio_guasi_cleanup,
262         .open_file      = generic_open_file,
263         .close_file     = generic_close_file,
264         .get_file_size  = generic_get_file_size,
265 };
266
267 #else /* FIO_HAVE_GUASI */
268
269 /*
270  * When we have a proper configure system in place, we simply wont build
271  * and install this io engine. For now install a crippled version that
272  * just complains and fails to load.
273  */
274 static int fio_guasi_init(struct thread_data fio_unused *td)
275 {
276         fprintf(stderr, "fio: guasi not available\n");
277         return 1;
278 }
279
280 static struct ioengine_ops ioengine = {
281         .name           = "guasi",
282         .version        = FIO_IOOPS_VERSION,
283         .init           = fio_guasi_init,
284 };
285
286 #endif
287
288 static void fio_init fio_guasi_register(void)
289 {
290         register_ioengine(&ioengine);
291 }
292
293 static void fio_exit fio_guasi_unregister(void)
294 {
295         unregister_ioengine(&ioengine);
296 }
297