engines/sg.c

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