[PATCH] syslet engine: use pread instead lseek+read
[fio.git] / engines / sg.c
1 /*
2  * scsi generic sg v3 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 #include <sys/poll.h>
11
12 #include "../fio.h"
13 #include "../os.h"
14
15 #ifdef FIO_HAVE_SGIO
16
17 struct sgio_cmd {
18         unsigned char cdb[10];
19         int nr;
20 };
21
22 struct sgio_data {
23         struct sgio_cmd *cmds;
24         struct io_u **events;
25         struct pollfd *pfds;
26         int *fd_flags;
27         void *sgbuf;
28         unsigned int bs;
29 };
30
31 static void sgio_hdr_init(struct sgio_data *sd, struct sg_io_hdr *hdr,
32                           struct io_u *io_u, int fs)
33 {
34         struct sgio_cmd *sc = &sd->cmds[io_u->index];
35
36         memset(hdr, 0, sizeof(*hdr));
37         memset(sc->cdb, 0, sizeof(sc->cdb));
38
39         hdr->interface_id = 'S';
40         hdr->cmdp = sc->cdb;
41         hdr->cmd_len = sizeof(sc->cdb);
42         hdr->pack_id = io_u->index;
43         hdr->usr_ptr = io_u;
44
45         if (fs) {
46                 hdr->dxferp = io_u->xfer_buf;
47                 hdr->dxfer_len = io_u->xfer_buflen;
48         }
49 }
50
51 static int fio_sgio_ioctl_getevents(struct thread_data *td, int fio_unused min,
52                                     int max, struct timespec fio_unused *t)
53 {
54         assert(max <= 1);
55
56         /*
57          * we can only have one finished io_u for sync io, since the depth
58          * is always 1
59          */
60         if (list_empty(&td->io_u_busylist))
61                 return 0;
62
63         return 1;
64 }
65
66 static int pollin_events(struct pollfd *pfds, int fds)
67 {
68         int i;
69
70         for (i = 0; i < fds; i++)
71                 if (pfds[i].revents & POLLIN)
72                         return 1;
73
74         return 0;
75 }
76
77 static int fio_sgio_getevents(struct thread_data *td, int min, int max,
78                               struct timespec fio_unused *t)
79 {
80         /*
81          * normally hard coding &td->files[0] is a bug that needs to be fixed,
82          * but it's ok here as all files should point to the same device.
83          */
84         struct fio_file *f = &td->files[0];
85         struct sgio_data *sd = td->io_ops->data;
86         int left = max, ret, events, i, r = 0;
87         void *buf = sd->sgbuf;
88
89         /*
90          * Fill in the file descriptors
91          */
92         for_each_file(td, f, i) {
93                 /*
94                  * don't block for min events == 0
95                  */
96                 if (!min) {
97                         sd->fd_flags[i] = fcntl(f->fd, F_GETFL);
98                         fcntl(f->fd, F_SETFL, sd->fd_flags[i] | O_NONBLOCK);
99                 }
100                 sd->pfds[i].fd = f->fd;
101                 sd->pfds[i].events = POLLIN;
102         }
103
104         while (left) {
105                 void *p;
106
107                 do {
108                         if (!min)
109                                 break;
110
111                         ret = poll(sd->pfds, td->nr_files, -1);
112                         if (ret < 0) {
113                                 td_verror(td, errno);
114                                 if (!r)
115                                         r = -1;
116                                 break;
117                         } else if (!ret)
118                                 continue;
119
120                         if (pollin_events(sd->pfds, td->nr_files))
121                                 break;
122                 } while (1);
123
124                 if (r < 0)
125                         break;
126
127 re_read:
128                 p = buf;
129                 events = 0;
130                 for_each_file(td, f, i) {
131                         ret = read(f->fd, p, left * sizeof(struct sg_io_hdr));
132                         if (ret < 0) {
133                                 if (errno == EAGAIN)
134                                         continue;
135                                 td_verror(td, errno);
136                                 r = -1;
137                                 break;
138                         } else if (ret) {
139                                 p += ret;
140                                 events += ret / sizeof(struct sg_io_hdr);
141                         }
142                 }
143
144                 if (r < 0)
145                         break;
146                 if (!events) {
147                         usleep(1000);
148                         goto re_read;
149                 }
150
151                 left -= events;
152                 r += events;
153
154                 for (i = 0; i < events; i++) {
155                         struct sg_io_hdr *hdr = (struct sg_io_hdr *) buf + i;
156
157                         sd->events[i] = hdr->usr_ptr;
158                 }
159         }
160
161         if (!min) {
162                 for_each_file(td, f, i)
163                         fcntl(f->fd, F_SETFL, sd->fd_flags[i]);
164         }
165
166         return r;
167 }
168
169 static int fio_sgio_ioctl_doio(struct thread_data *td,
170                                struct fio_file *f, struct io_u *io_u)
171 {
172         struct sgio_data *sd = td->io_ops->data;
173         struct sg_io_hdr *hdr = &io_u->hdr;
174
175         sd->events[0] = io_u;
176
177         return ioctl(f->fd, SG_IO, hdr);
178 }
179
180 static int fio_sgio_rw_doio(struct fio_file *f, struct io_u *io_u, int sync)
181 {
182         struct sg_io_hdr *hdr = &io_u->hdr;
183         int ret;
184
185         ret = write(f->fd, hdr, sizeof(*hdr));
186         if (ret < 0)
187                 return errno;
188
189         if (sync) {
190                 ret = read(f->fd, hdr, sizeof(*hdr));
191                 if (ret < 0)
192                         return errno;
193         }
194
195         return 0;
196 }
197
198 static int fio_sgio_doio(struct thread_data *td, struct io_u *io_u, int sync)
199 {
200         struct fio_file *f = io_u->file;
201
202         if (td->filetype == FIO_TYPE_BD)
203                 return fio_sgio_ioctl_doio(td, f, io_u);
204
205         return fio_sgio_rw_doio(f, io_u, sync);
206 }
207
208 static int fio_sgio_prep(struct thread_data *td, struct io_u *io_u)
209 {
210         struct sg_io_hdr *hdr = &io_u->hdr;
211         struct sgio_data *sd = td->io_ops->data;
212         int nr_blocks, lba;
213
214         if (io_u->xfer_buflen & (sd->bs - 1)) {
215                 log_err("read/write not sector aligned\n");
216                 return EINVAL;
217         }
218
219         if (io_u->ddir == DDIR_READ) {
220                 sgio_hdr_init(sd, hdr, io_u, 1);
221
222                 hdr->dxfer_direction = SG_DXFER_FROM_DEV;
223                 hdr->cmdp[0] = 0x28;
224         } else if (io_u->ddir == DDIR_WRITE) {
225                 sgio_hdr_init(sd, hdr, io_u, 1);
226
227                 hdr->dxfer_direction = SG_DXFER_TO_DEV;
228                 hdr->cmdp[0] = 0x2a;
229         } else {
230                 sgio_hdr_init(sd, hdr, io_u, 0);
231
232                 hdr->dxfer_direction = SG_DXFER_NONE;
233                 hdr->cmdp[0] = 0x35;
234         }
235
236         if (hdr->dxfer_direction != SG_DXFER_NONE) {
237                 nr_blocks = io_u->xfer_buflen / sd->bs;
238                 lba = io_u->offset / sd->bs;
239                 hdr->cmdp[2] = (unsigned char) ((lba >> 24) & 0xff);
240                 hdr->cmdp[3] = (unsigned char) ((lba >> 16) & 0xff);
241                 hdr->cmdp[4] = (unsigned char) ((lba >>  8) & 0xff);
242                 hdr->cmdp[5] = (unsigned char) (lba & 0xff);
243                 hdr->cmdp[7] = (unsigned char) ((nr_blocks >> 8) & 0xff);
244                 hdr->cmdp[8] = (unsigned char) (nr_blocks & 0xff);
245         }
246
247         return 0;
248 }
249
250 static int fio_sgio_queue(struct thread_data *td, struct io_u *io_u)
251 {
252         struct sg_io_hdr *hdr = &io_u->hdr;
253         int ret;
254
255         ret = fio_sgio_doio(td, io_u, io_u->ddir == DDIR_SYNC);
256
257         if (ret < 0)
258                 io_u->error = errno;
259         else if (hdr->status) {
260                 io_u->resid = hdr->resid;
261                 io_u->error = EIO;
262         }
263
264         if (io_u->error) {
265                 td_verror(td, io_u->error);
266                 return io_u->error;
267         }
268
269         return 0;
270 }
271
272 static struct io_u *fio_sgio_event(struct thread_data *td, int event)
273 {
274         struct sgio_data *sd = td->io_ops->data;
275
276         return sd->events[event];
277 }
278
279 static int fio_sgio_get_bs(struct thread_data *td, unsigned int *bs)
280 {
281         struct sgio_data *sd = td->io_ops->data;
282         struct io_u *io_u;
283         struct sg_io_hdr *hdr;
284         unsigned char buf[8];
285         int ret;
286
287         io_u = __get_io_u(td);
288         io_u->file = &td->files[0];
289         assert(io_u);
290
291         hdr = &io_u->hdr;
292         sgio_hdr_init(sd, hdr, io_u, 0);
293         memset(buf, 0, sizeof(buf));
294
295         hdr->cmdp[0] = 0x25;
296         hdr->dxfer_direction = SG_DXFER_FROM_DEV;
297         hdr->dxferp = buf;
298         hdr->dxfer_len = sizeof(buf);
299
300         ret = fio_sgio_doio(td, io_u, 1);
301         if (ret) {
302                 put_io_u(td, io_u);
303                 return ret;
304         }
305
306         *bs = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
307         put_io_u(td, io_u);
308         return 0;
309 }
310
311 static void fio_sgio_cleanup(struct thread_data *td)
312 {
313         struct sgio_data *sd = td->io_ops->data;
314
315         if (sd) {
316                 free(sd->events);
317                 free(sd->cmds);
318                 free(sd->fd_flags);
319                 free(sd->pfds);
320                 free(sd->sgbuf);
321                 free(sd);
322
323                 td->io_ops->data = NULL;
324         }
325 }
326
327 static int fio_sgio_init(struct thread_data *td)
328 {
329         struct fio_file *f = &td->files[0];
330         struct sgio_data *sd;
331         unsigned int bs;
332         int ret;
333
334         sd = malloc(sizeof(*sd));
335         memset(sd, 0, sizeof(*sd));
336         sd->cmds = malloc(td->iodepth * sizeof(struct sgio_cmd));
337         memset(sd->cmds, 0, td->iodepth * sizeof(struct sgio_cmd));
338         sd->events = malloc(td->iodepth * sizeof(struct io_u *));
339         memset(sd->events, 0, td->iodepth * sizeof(struct io_u *));
340         sd->pfds = malloc(sizeof(struct pollfd) * td->nr_files);
341         memset(sd->pfds, 0, sizeof(struct pollfd) * td->nr_files);
342         sd->fd_flags = malloc(sizeof(int) * td->nr_files);
343         memset(sd->fd_flags, 0, sizeof(int) * td->nr_files);
344         sd->sgbuf = malloc(sizeof(struct sg_io_hdr) * td->iodepth);
345         memset(sd->sgbuf, 0, sizeof(struct sg_io_hdr) * td->iodepth);
346
347         td->io_ops->data = sd;
348
349         if (td->filetype == FIO_TYPE_BD) {
350                 if (ioctl(f->fd, BLKSSZGET, &bs) < 0) {
351                         td_verror(td, errno);
352                         goto err;
353                 }
354         } else if (td->filetype == FIO_TYPE_CHAR) {
355                 int version;
356
357                 if (ioctl(f->fd, SG_GET_VERSION_NUM, &version) < 0) {
358                         td_verror(td, errno);
359                         goto err;
360                 }
361
362                 ret = fio_sgio_get_bs(td, &bs);
363                 if (ret)
364                         goto err;
365         } else {
366                 log_err("ioengine sgio only works on block devices\n");
367                 goto err;
368         }
369
370         sd->bs = bs;
371
372         if (td->filetype == FIO_TYPE_BD)
373                 td->io_ops->getevents = fio_sgio_ioctl_getevents;
374         else
375                 td->io_ops->getevents = fio_sgio_getevents;
376
377         /*
378          * we want to do it, regardless of whether odirect is set or not
379          */
380         td->override_sync = 1;
381         return 0;
382 err:
383         free(sd->events);
384         free(sd->cmds);
385         free(sd->fd_flags);
386         free(sd->pfds);
387         free(sd->sgbuf);
388         free(sd);
389         td->io_ops->data = NULL;
390         return 1;
391 }
392
393 static struct ioengine_ops ioengine = {
394         .name           = "sg",
395         .version        = FIO_IOOPS_VERSION,
396         .init           = fio_sgio_init,
397         .prep           = fio_sgio_prep,
398         .queue          = fio_sgio_queue,
399         .getevents      = fio_sgio_getevents,
400         .event          = fio_sgio_event,
401         .cleanup        = fio_sgio_cleanup,
402         .flags          = FIO_SYNCIO | FIO_RAWIO,
403 };
404
405 #else /* FIO_HAVE_SGIO */
406
407 /*
408  * When we have a proper configure system in place, we simply wont build
409  * and install this io engine. For now install a crippled version that
410  * just complains and fails to load.
411  */
412 static int fio_sgio_init(struct thread_data fio_unused *td)
413 {
414         fprintf(stderr, "fio: sgio not available\n");
415         return 1;
416 }
417
418 static struct ioengine_ops ioengine = {
419         .name           = "sgio",
420         .version        = FIO_IOOPS_VERSION,
421         .init           = fio_sgio_init,
422 };
423
424 #endif
425
426 static void fio_init fio_sgio_register(void)
427 {
428         register_ioengine(&ioengine);
429 }
430
431 static void fio_exit fio_sgio_unregister(void)
432 {
433         unregister_ioengine(&ioengine);
434 }