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