[PATCH Various fixes
[fio.git] / engines / fio-engine-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 #include "fio.h"
12 #include "os.h"
13
14 struct sgio_cmd {
15         unsigned char cdb[10];
16         int nr;
17 };
18
19 struct sgio_data {
20         struct sgio_cmd *cmds;
21         struct io_u **events;
22         unsigned int bs;
23 };
24
25 static void sgio_hdr_init(struct sgio_data *sd, struct sg_io_hdr *hdr,
26                           struct io_u *io_u, int fs)
27 {
28         struct sgio_cmd *sc = &sd->cmds[io_u->index];
29
30         memset(hdr, 0, sizeof(*hdr));
31         memset(sc->cdb, 0, sizeof(sc->cdb));
32
33         hdr->interface_id = 'S';
34         hdr->cmdp = sc->cdb;
35         hdr->cmd_len = sizeof(sc->cdb);
36         hdr->pack_id = io_u->index;
37         hdr->usr_ptr = io_u;
38
39         if (fs) {
40                 hdr->dxferp = io_u->buf;
41                 hdr->dxfer_len = io_u->buflen;
42         }
43 }
44
45 static int fio_sgio_ioctl_getevents(struct thread_data *td, int fio_unused min,
46                                     int max, struct timespec fio_unused *t)
47 {
48         assert(max <= 1);
49
50         /*
51          * we can only have one finished io_u for sync io, since the depth
52          * is always 1
53          */
54         if (list_empty(&td->io_u_busylist))
55                 return 0;
56
57         return 1;
58 }
59
60
61 static int fio_sgio_getevents(struct thread_data *td, int min, int max,
62                               struct timespec fio_unused *t)
63 {
64         struct fio_file *f = &td->files[0];
65         struct sgio_data *sd = td->io_ops->data;
66         struct pollfd pfd = { .fd = f->fd, .events = POLLIN };
67         void *buf = malloc(max * sizeof(struct sg_io_hdr));
68         int left = max, ret, events, i, r = 0, fl = 0;
69
70         /*
71          * don't block for !events
72          */
73         if (!min) {
74                 fl = fcntl(f->fd, F_GETFL);
75                 fcntl(f->fd, F_SETFL, fl | O_NONBLOCK);
76         }
77
78         while (left) {
79                 do {
80                         if (!min)
81                                 break;
82                         poll(&pfd, 1, -1);
83                         if (pfd.revents & POLLIN)
84                                 break;
85                 } while (1);
86
87                 ret = read(f->fd, buf, left * sizeof(struct sg_io_hdr));
88                 if (ret < 0) {
89                         if (errno == EAGAIN)
90                                 break;
91                         td_verror(td, errno);
92                         r = -1;
93                         break;
94                 } else if (!ret)
95                         break;
96
97                 events = ret / sizeof(struct sg_io_hdr);
98                 left -= events;
99                 r += events;
100
101                 for (i = 0; i < events; i++) {
102                         struct sg_io_hdr *hdr = (struct sg_io_hdr *) buf + i;
103
104                         sd->events[i] = hdr->usr_ptr;
105                 }
106         }
107
108         if (!min)
109                 fcntl(f->fd, F_SETFL, fl);
110
111         free(buf);
112         return r;
113 }
114
115 static int fio_sgio_ioctl_doio(struct thread_data *td, struct fio_file *f,
116                                struct io_u *io_u)
117 {
118         struct sgio_data *sd = td->io_ops->data;
119         struct sg_io_hdr *hdr = &io_u->hdr;
120
121         sd->events[0] = io_u;
122
123         return ioctl(f->fd, SG_IO, hdr);
124 }
125
126 static int fio_sgio_rw_doio(struct thread_data *td, struct fio_file *f,
127                             struct io_u *io_u, int sync)
128 {
129         struct sg_io_hdr *hdr = &io_u->hdr;
130         int ret;
131
132         ret = write(f->fd, hdr, sizeof(*hdr));
133         if (ret < 0)
134                 return errno;
135
136         if (sync) {
137                 ret = read(f->fd, hdr, sizeof(*hdr));
138                 if (ret < 0)
139                         return errno;
140         }
141
142         return 0;
143 }
144
145 static int fio_sgio_doio(struct thread_data *td, struct io_u *io_u, int sync)
146 {
147         struct fio_file *f = io_u->file;
148
149         if (td->filetype == FIO_TYPE_BD)
150                 return fio_sgio_ioctl_doio(td, f, io_u);
151
152         return fio_sgio_rw_doio(td, f, io_u, sync);
153 }
154
155 static int fio_sgio_sync(struct thread_data *td, struct fio_file *f)
156 {
157         struct sgio_data *sd = td->io_ops->data;
158         struct sg_io_hdr *hdr;
159         struct io_u *io_u;
160         int ret;
161
162         io_u = __get_io_u(td);
163         if (!io_u)
164                 return ENOMEM;
165
166         hdr = &io_u->hdr;
167         sgio_hdr_init(sd, hdr, io_u, 0);
168         hdr->dxfer_direction = SG_DXFER_NONE;
169
170         hdr->cmdp[0] = 0x35;
171
172         ret = fio_sgio_doio(td, io_u, 1);
173         put_io_u(td, io_u);
174         return ret;
175 }
176
177 static int fio_sgio_prep(struct thread_data *td, struct io_u *io_u)
178 {
179         struct sg_io_hdr *hdr = &io_u->hdr;
180         struct sgio_data *sd = td->io_ops->data;
181         int nr_blocks, lba;
182
183         if (io_u->buflen & (sd->bs - 1)) {
184                 log_err("read/write not sector aligned\n");
185                 return EINVAL;
186         }
187
188         sgio_hdr_init(sd, hdr, io_u, 1);
189
190         if (io_u->ddir == DDIR_READ) {
191                 hdr->dxfer_direction = SG_DXFER_FROM_DEV;
192                 hdr->cmdp[0] = 0x28;
193         } else {
194                 hdr->dxfer_direction = SG_DXFER_TO_DEV;
195                 hdr->cmdp[0] = 0x2a;
196         }
197
198         nr_blocks = io_u->buflen / sd->bs;
199         lba = io_u->offset / sd->bs;
200         hdr->cmdp[2] = (lba >> 24) & 0xff;
201         hdr->cmdp[3] = (lba >> 16) & 0xff;
202         hdr->cmdp[4] = (lba >>  8) & 0xff;
203         hdr->cmdp[5] = lba & 0xff;
204         hdr->cmdp[7] = (nr_blocks >> 8) & 0xff;
205         hdr->cmdp[8] = nr_blocks & 0xff;
206         return 0;
207 }
208
209 static int fio_sgio_queue(struct thread_data *td, struct io_u *io_u)
210 {
211         struct sg_io_hdr *hdr = &io_u->hdr;
212         int ret;
213
214         ret = fio_sgio_doio(td, io_u, 0);
215
216         if (ret < 0)
217                 io_u->error = errno;
218         else if (hdr->status) {
219                 io_u->resid = hdr->resid;
220                 io_u->error = EIO;
221         }
222
223         return io_u->error;
224 }
225
226 static struct io_u *fio_sgio_event(struct thread_data *td, int event)
227 {
228         struct sgio_data *sd = td->io_ops->data;
229
230         return sd->events[event];
231 }
232
233 static int fio_sgio_get_bs(struct thread_data *td, unsigned int *bs)
234 {
235         struct sgio_data *sd = td->io_ops->data;
236         struct io_u *io_u;
237         struct sg_io_hdr *hdr;
238         unsigned char buf[8];
239         int ret;
240
241         io_u = __get_io_u(td);
242         assert(io_u);
243
244         hdr = &io_u->hdr;
245         sgio_hdr_init(sd, hdr, io_u, 0);
246         memset(buf, 0, sizeof(buf));
247
248         hdr->cmdp[0] = 0x25;
249         hdr->dxfer_direction = SG_DXFER_FROM_DEV;
250         hdr->dxferp = buf;
251         hdr->dxfer_len = sizeof(buf);
252
253         ret = fio_sgio_doio(td, io_u, 1);
254         if (ret) {
255                 put_io_u(td, io_u);
256                 return ret;
257         }
258
259         *bs = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
260         put_io_u(td, io_u);
261         return 0;
262 }
263
264 static void fio_sgio_cleanup(struct thread_data *td)
265 {
266         if (td->io_ops->data) {
267                 free(td->io_ops->data);
268                 td->io_ops->data = NULL;
269         }
270 }
271
272 static int fio_sgio_init(struct thread_data *td)
273 {
274         struct fio_file *f = &td->files[0];
275         struct sgio_data *sd;
276         unsigned int bs;
277         int ret;
278
279         sd = malloc(sizeof(*sd));
280         sd->cmds = malloc(td->iodepth * sizeof(struct sgio_cmd));
281         sd->events = malloc(td->iodepth * sizeof(struct io_u *));
282         td->io_ops->data = sd;
283
284         if (td->filetype == FIO_TYPE_BD) {
285                 if (ioctl(f->fd, BLKSSZGET, &bs) < 0) {
286                         td_verror(td, errno);
287                         return 1;
288                 }
289         } else if (td->filetype == FIO_TYPE_CHAR) {
290                 int version;
291
292                 if (ioctl(f->fd, SG_GET_VERSION_NUM, &version) < 0) {
293                         td_verror(td, errno);
294                         return 1;
295                 }
296
297                 ret = fio_sgio_get_bs(td, &bs);
298                 if (ret)
299                         return ret;
300         } else {
301                 log_err("ioengine sgio only works on block devices\n");
302                 return 1;
303         }
304
305         sd->bs = bs;
306
307         if (td->filetype == FIO_TYPE_BD)
308                 td->io_ops->getevents = fio_sgio_ioctl_getevents;
309         else
310                 td->io_ops->getevents = fio_sgio_getevents;
311
312         /*
313          * we want to do it, regardless of whether odirect is set or not
314          */
315         td->override_sync = 1;
316         return 0;
317 }
318
319 struct ioengine_ops ioengine = {
320         .name           = "sg",
321         .version        = FIO_IOOPS_VERSION,
322         .init           = fio_sgio_init,
323         .prep           = fio_sgio_prep,
324         .queue          = fio_sgio_queue,
325         .getevents      = fio_sgio_getevents,
326         .event          = fio_sgio_event,
327         .cleanup        = fio_sgio_cleanup,
328         .sync           = fio_sgio_sync,
329         .flags          = FIO_SYNCIO | FIO_RAWIO,
330 };