With its existing sg engine the fio utility supports many block
devices (e.g. like /dev/sdb) and SCSI Generic (sg) character
devices (e.g. like /dev/sg2). In both cases it uses the sg
version 3 interface based on interface structure: sg_io_hdr. The
sg engine cannot use bsg devices (e.g. like /dev/bsg/0:0:0:2)
because bsg uses the sg version 4 (sgv4) interface based on
interface structure: sg_io_v4 .
This patch adds a new "sgv4" engine that can be used with bsg
device nodes. Additionally a patchset has been sent to the linux
scsi list titled "sg: add v4 interface" on 20190616. With that
patchset (or a later one) applied the sg driver will accept the
v4 interface (both sync and async).
This patch includes a minor clean-up of the existing sg engine
to make it a bit more widely applicable. A variable is renamed
to stress that it is using the sg v3 interface.
Signed-off-by: Douglas Gilbert <dgilbert@xxxxxxxxxxxx>
---
The sgv4 engine is a copy of the sg engine with the interface
structure changed from struct sg_io_hdr to sg_io_v4 . The
write()/read() async interface is replaced by ioctl(SG_IOSUBMIT)
and ioctl(SG_IORECEIVE) calls. No capabilities have been added
or removed. At the current time the bsg driver no longer supports
an async interface (it was previousy based on write()/read() but
that code has been removed).
Makefile | 2 +-
engines/sg.c | 22 +-
engines/sgv4.c | 1316 ++++++++++++++++++++++++++++++++++++++++++++++++
io_u.h | 5 +-
os/os-linux.h | 2 +
5 files changed, 1335 insertions(+), 12 deletions(-)
create mode 100644 engines/sgv4.c
diff --git a/Makefile b/Makefile
index d7e5fca7..8c7756fe 100644
--- a/Makefile
+++ b/Makefile
@@ -157,7 +157,7 @@ endif
ifeq ($(CONFIG_TARGET_OS), Linux)
SOURCE += diskutil.c fifo.c blktrace.c cgroup.c trim.c engines/sg.c \
- oslib/linux-dev-lookup.c engines/io_uring.c
+ engines/sgv4.c oslib/linux-dev-lookup.c engines/io_uring.c
LIBS += -lpthread -ldl
LDFLAGS += -rdynamic
endif
diff --git a/engines/sg.c b/engines/sg.c
index c46b9aba..3029c74e 100644
--- a/engines/sg.c
+++ b/engines/sg.c
@@ -359,7 +359,7 @@ re_read:
if (hdr->info & SG_INFO_CHECK) {
/* record if an io error occurred, ignore resid */
- memcpy(&io_u->hdr, hdr, sizeof(struct sg_io_hdr));
+ memcpy(&io_u->hdr3, hdr, sizeof(struct sg_io_hdr));
sd->events[i + trims]->error = EIO;
}
@@ -380,7 +380,7 @@ re_read:
#endif
if (hdr->info & SG_INFO_CHECK) {
/* record if an io error occurred, ignore resid */
- memcpy(&st->trim_io_us[j]->hdr, hdr, sizeof(struct sg_io_hdr));
+ memcpy(&st->trim_io_us[j]->hdr3, hdr, sizeof(struct sg_io_hdr));
sd->events[i + trims]->error = EIO;
}
}
@@ -408,7 +408,7 @@ static enum fio_q_status fio_sgio_ioctl_doio(struct thread_data *td,
struct io_u *io_u)
{
struct sgio_data *sd = td->io_ops_data;
- struct sg_io_hdr *hdr = &io_u->hdr;
+ struct sg_io_hdr *hdr = &io_u->hdr3;
int ret;
sd->events[0] = io_u;
@@ -428,7 +428,7 @@ static enum fio_q_status fio_sgio_rw_doio(struct thread_data *td,
struct fio_file *f,
struct io_u *io_u, int do_sync)
{
- struct sg_io_hdr *hdr = &io_u->hdr;
+ struct sg_io_hdr *hdr = &io_u->hdr3;
int ret;
ret = write(f->fd, hdr, sizeof(*hdr));
@@ -504,7 +504,7 @@ static void fio_sgio_rw_lba(struct sg_io_hdr *hdr, unsigned long long lba,
static int fio_sgio_prep(struct thread_data *td, struct io_u *io_u)
{
- struct sg_io_hdr *hdr = &io_u->hdr;
+ struct sg_io_hdr *hdr = &io_u->hdr3;
struct sg_options *o = td->eo;
struct sgio_data *sd = td->io_ops_data;
unsigned long long nr_blocks, lba;
@@ -623,7 +623,7 @@ static void fio_sgio_unmap_setup(struct sg_io_hdr *hdr, struct sgio_trim *st)
static enum fio_q_status fio_sgio_queue(struct thread_data *td,
struct io_u *io_u)
{
- struct sg_io_hdr *hdr = &io_u->hdr;
+ struct sg_io_hdr *hdr = &io_u->hdr3;
struct sgio_data *sd = td->io_ops_data;
int ret, do_sync = 0;
@@ -642,7 +642,7 @@ static enum fio_q_status fio_sgio_queue(struct thread_data *td,
assert(st->unmap_range_count == 1);
assert(io_u == st->trim_io_us[0]);
#endif
- hdr = &io_u->hdr;
+ hdr = &io_u->hdr3;
fio_sgio_unmap_setup(hdr, st);
@@ -693,7 +693,7 @@ static int fio_sgio_commit(struct thread_data *td)
st = sd->trim_queues[sd->current_queue];
io_u = st->trim_io_us[0];
- hdr = &io_u->hdr;
+ hdr = &io_u->hdr3;
fio_sgio_unmap_setup(hdr, st);
@@ -865,6 +865,7 @@ static int fio_sgio_init(struct thread_data *td)
{
struct sgio_data *sd;
struct sgio_trim *st;
+ struct sg_io_hdr *h3p;
int i;
sd = calloc(1, sizeof(*sd));
@@ -880,12 +881,13 @@ static int fio_sgio_init(struct thread_data *td)
#ifdef FIO_SGIO_DEBUG
sd->trim_queue_map = calloc(td->o.iodepth, sizeof(int));
#endif
- for (i = 0; i < td->o.iodepth; i++) {
+ for (i = 0, h3p = sd->sgbuf; i < td->o.iodepth; i++, ++h3p) {
sd->trim_queues[i] = calloc(1, sizeof(struct sgio_trim));
st = sd->trim_queues[i];
st->unmap_param = calloc(td->o.iodepth + 1, sizeof(char[16]));
st->unmap_range_count = 0;
st->trim_io_us = calloc(td->o.iodepth, sizeof(struct io_u *));
+ h3p->interface_id = 'S';
}
td->io_ops_data = sd;
@@ -974,7 +976,7 @@ static int fio_sgio_open(struct thread_data *td, struct fio_file *f)
*/
static char *fio_sgio_errdetails(struct io_u *io_u)
{
- struct sg_io_hdr *hdr = &io_u->hdr;
+ struct sg_io_hdr *hdr = &io_u->hdr3;
#define MAXERRDETAIL 1024
#define MAXMSGCHUNK 128
char *msg, msgchunk[MAXMSGCHUNK];
diff --git a/engines/sgv4.c b/engines/sgv4.c
new file mode 100644
index 00000000..59360444
--- /dev/null
+++ b/engines/sgv4.c
@@ -0,0 +1,1316 @@
+/*
+ * sgv4 engine
+ *
+ * IO engine that uses the Linux SG v4 interface to talk to SCSI devices.
+ * Can only talk to /dev/sgY or /dev/bsg/<htcl> device nodes
+ *
+ * This ioengine can operate in two modes:
+ * sync with character devices (/dev/sgY and /dev/bsg/<hctl> )
+ * and with sync=1
+ * async with sg v4 driver devices with direct=0 and sync=0
+ *
+ * What value does queue() return for the different cases?
+ * queue() return value
+ * In sync mode:
+ * /dev/sgY RWT FIO_Q_COMPLETED
+ * /dev/bsg/<h:c:t:l> RWT FIO_Q_COMPLETED
+ * with sync=1
+ *
+ * In async mode:
+ * /dev/sgY RWT FIO_Q_QUEUED
+ * direct=0 and sync=0
+ *
+ * Because FIO_SYNCIO is set for this ioengine td_io_queue() will fill in
+ * issue_time *before* each IO is sent to queue()
+ *
+ *
+ * Note that only sg devices using the sg v4 driver are accepted. A
+ * patchset titled "sg: add v4 interface" was sent to the linux-scsi
+ * list on 20190616. There will be later patchsets.
+ *
+ * Note that the colons withing a bsg node name need to be escaped with
+ * a leading backslash when given to "filename=". For example:
+ * filename=/dev/bsg/0\:0\:0\:2
+ * for the /dev/bsg/0:0:0:2 device node.
+ *
+ * Where are the IO counting functions called for the different cases?
+ *
+ * In sync mode:
+ *
+ * /dev/sgY with direct=1 or sync=1 (commit does nothing)
+ * RWT
+ * io_u_mark_depth() called in td_io_queue()
+ * io_u_mark_submit/complete() called in queue()
+ * issue_time set in td_io_queue()
+ *
+ * In async mode:
+ * /dev/sgY with direct=0 and sync=0
+ * RW: read and write operations are submitted in queue()
+ * io_u_mark_depth() called in td_io_commit()
+ * io_u_mark_submit() called in queue()
+ * issue_time set in td_io_queue()
+ * T: trim operations are queued in queue() and submitted in commit()
+ * io_u_mark_depth() called in td_io_commit()
+ * io_u_mark_submit() called in commit()
+ * issue_time set in commit()
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <poll.h>
+
+#include "../fio.h"
+#include "../optgroup.h"
+
+#ifndef SG_IOCTL_MAGIC_NUM
+#define SG_IOCTL_MAGIC_NUM 0x22
+#endif
+#ifndef SG_IOSUBMIT
+#define SG_IOSUBMIT _IOWR(SG_IOCTL_MAGIC_NUM, 0x41, struct sg_io_v4)
+#endif
+#ifndef SG_IORECEIVE
+#define SG_IORECEIVE _IOWR(SG_IOCTL_MAGIC_NUM, 0x42, struct sg_io_v4)
+#endif
+
+#ifdef FIO_HAVE_SGV4IO
+
+enum {
+ FIO_SGV4_WRITE = 1,
+ FIO_SGV4_WRITE_VERIFY = 2,
+ FIO_SGV4_WRITE_SAME = 3
+};
+
+struct sgv4_options {
+ void *pad;
+ unsigned int readfua;
+ unsigned int writefua;
+ unsigned int write_mode;
+};
+
+static struct fio_option options[] = {
+ {
+ .name = "readfua",
+ .lname = "sgv4 engine read fua flag support",
+ .type = FIO_OPT_BOOL,
+ .off1 = offsetof(struct sgv4_options, readfua),
+ .help = "Set FUA flag (force unit access) for all Read operations",
+ .def = "0",
+ .category = FIO_OPT_C_ENGINE,
+ .group = FIO_OPT_G_SG,
+ },
+ {
+ .name = "writefua",
+ .lname = "sgv4 engine write fua flag support",
+ .type = FIO_OPT_BOOL,
+ .off1 = offsetof(struct sgv4_options, writefua),
+ .help = "Set FUA flag (force unit access) for all Write operations",
+ .def = "0",
+ .category = FIO_OPT_C_ENGINE,
+ .group = FIO_OPT_G_SG,
+ },
+ {
+ .name = "sg_write_mode",
+ .lname = "specify sgv4 write mode",
+ .type = FIO_OPT_STR,
+ .off1 = offsetof(struct sgv4_options, write_mode),
+ .help = "Specify SCSI WRITE mode",
+ .def = "write",
+ .posval = {
+ { .ival = "write",
+ .oval = FIO_SGV4_WRITE,
+ .help = "Issue standard SCSI WRITE commands",
+ },
+ { .ival = "verify",
+ .oval = FIO_SGV4_WRITE_VERIFY,
+ .help = "Issue SCSI WRITE AND VERIFY commands",
+ },
+ { .ival = "same",
+ .oval = FIO_SGV4_WRITE_SAME,
+ .help = "Issue SCSI WRITE SAME commands",
+ },
+ },
+ .category = FIO_OPT_C_ENGINE,
+ .group = FIO_OPT_G_SG,
+ },
+ {
+ .name = NULL,
+ },
+};
+
+#define MAX_10B_LBA 0xFFFFFFFFULL
+#define SCSI_TIMEOUT_MS 30000 // 30 second timeout; currently no method to override
+#define MAX_SB 64 // sense block maximum return size
+// /*
+#define FIO_SGV4IO_DEBUG
+// */
+
+struct sgv4io_cmd {
+ unsigned char cdb[16]; // enhanced from 10 to support 16 byte commands
+ unsigned char sb[MAX_SB]; // add sense block to commands
+ int nr;
+};
+
+struct sgv4io_trim {
+ uint8_t *unmap_param;
+ unsigned int unmap_range_count;
+ struct io_u **trim_io_us;
+};
+
+struct sgv4io_data {
+ struct sgv4io_cmd *cmds;
+ struct io_u **events;
+ struct pollfd *pfds;
+ int *fd_flags;
+ void *sgbuf;
+ unsigned int bs;
+ int type_checked;
+ bool bsg_dev;
+ struct sgv4io_trim **trim_queues;
+ int current_queue;
+#ifdef FIO_SGV4IO_DEBUG
+ unsigned int *trim_queue_map;
+#endif
+};
+
+static inline uint32_t sgio_get_be32(uint8_t *buf)
+{
+ return be32_to_cpu(*((uint32_t *) buf));
+}
+
+static inline uint64_t sgio_get_be64(uint8_t *buf)
+{
+ return be64_to_cpu(*((uint64_t *) buf));
+}
+
+static inline void sgio_set_be16(uint16_t val, uint8_t *buf)
+{
+ uint16_t t = cpu_to_be16(val);
+
+ memcpy(buf, &t, sizeof(uint16_t));
+}
+
+static inline void sgio_set_be32(uint32_t val, uint8_t *buf)
+{
+ uint32_t t = cpu_to_be32(val);
+
+ memcpy(buf, &t, sizeof(uint32_t));
+}
+
+static inline void sgio_set_be64(uint64_t val, uint8_t *buf)
+{
+ uint64_t t = cpu_to_be64(val);
+
+ memcpy(buf, &t, sizeof(uint64_t));
+}
+
+static inline bool sgio_unbuffered(struct thread_data *td)
+{
+ return (td->o.odirect || td->o.sync_io);
+}
+
+static void sgv4io_hdr_init(struct sgv4io_data *sd, struct sg_io_v4 *hdr,
+ struct io_u *io_u, bool mv_data)
+{
+ struct sgv4io_cmd *sc = &sd->cmds[io_u->index];
+
+ memset(hdr, 0, sizeof(*hdr));
+ memset(sc->cdb, 0, sizeof(sc->cdb));
+
+ hdr->guard = 'Q'; /* ->protocol and ->subprotocol both 0 */
+ hdr->request = (uint64_t)(uintptr_t)sc->cdb;
+ hdr->request_len = sizeof(sc->cdb);
+ hdr->response = (uint64_t)(uintptr_t)sc->sb;
+ hdr->max_response_len = sizeof(sc->sb);
+ hdr->request_extra = io_u->index;
+ hdr->usr_ptr = (uint64_t)(uintptr_t)io_u;
+ hdr->timeout = SCSI_TIMEOUT_MS;
+
+ if (mv_data) { /* setup for READ, needs adjustment for WRITE */
+ hdr->din_xferp = (uint64_t)(uintptr_t)io_u->xfer_buf;
+ hdr->din_xfer_len = io_u->xfer_buflen;
+ }
+}
+
+static int pollin_events(struct pollfd *pfds, int fds)
+{
+ int i;
+
+ for (i = 0; i < fds; i++)
+ if (pfds[i].revents & POLLIN)
+ return 1;
+
+ return 0;
+}
+
+static int sgv4_fd_read(int fd, struct sg_io_v4 *h4p)
+{
+ int err = 0;
+ ssize_t ret;
+
+ while (true) {
+// fprintf(stderr, "%s: guard=%d, din_xferp=%p, dout_xferp=%p\n", __func__, h4p->guard, (void *)h4p->din_xferp, (void *)h4p->dout_xferp);
+assert(h4p->guard == 0x51);
+ ret = ioctl(fd, SG_IORECEIVE, h4p);
+ if (ret < 0) {
+// fprintf(stderr, "%s: ioctl(SG_IORECEIVE) errno=%d\n", __func__, errno);
+ if (errno == EAGAIN || errno == EINTR)
+ continue;
+ err = errno;
+ } else
+ err = 0;
+ break;
+ }
+ return -err;
+}
+
+static int fio_sgv4io_getevents(struct thread_data *td, unsigned int min,
+ unsigned int max,
+ const struct timespec fio_unused *t)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ int left = max, eventNum, ret, r = 0, trims = 0;
+ void *buf = sd->sgbuf;
+ unsigned int i, j, events;
+ struct fio_file *f;
+ struct io_u *io_u;
+
+ /*
+ * Fill in the file descriptors
+ */
+ for_each_file(td, f, i) {
+ /*
+ * don't block for min events == 0
+ */
+ if (!min)
+ sd->fd_flags[i] = fio_set_fd_nonblocking(f->fd, "sgv4");
+ else
+ sd->fd_flags[i] = -1;
+
+ sd->pfds[i].fd = f->fd;
+ sd->pfds[i].events = POLLIN;
+ }
+
+ /*
+ ** There are two counters here:
+ ** - number of SCSI commands completed
+ ** - number of io_us completed
+ **
+ ** These are the same with reads and writes, but
+ ** could differ with trim/unmap commands because
+ ** a single unmap can include multiple io_us
+ */
+
+ while (left > 0) {
+ struct sg_io_v4 *h4p;
+
+ dprint(FD_IO, "sgv4io_getevents: sd %p: min=%d, max=%d, left=%d\n", sd, min, max, left);
+
+ do {
+ if (!min)
+ break;
+
+ ret = poll(sd->pfds, td->o.nr_files, -1);
+ if (ret < 0) {
+ if (!r)
+ r = -errno;
+ td_verror(td, errno, "poll");
+ break;
+ } else if (!ret)
+ continue;
+
+ if (pollin_events(sd->pfds, td->o.nr_files))
+ break;
+ } while (1);
+
+ if (r < 0)
+ break;
+
+re_read:
+ h4p = buf;
+ events = 0;
+ for_each_file(td, f, i) {
+ for (eventNum = 0; eventNum < left; eventNum++) {
+ ret = sgv4_fd_read(f->fd, h4p);
+ dprint(FD_IO, "sgv4io_getevents: sgv4_fd_read ret: %d\n", ret);
+ if (ret) {
+ r = -ret;
+ td_verror(td, r, "sgv4_read");
+ break;
+ }
+ io_u = (struct io_u *)(h4p->usr_ptr);
+ if (io_u->ddir == DDIR_TRIM) {
+ events += sd->trim_queues[io_u->index]->unmap_range_count;
+ eventNum += sd->trim_queues[io_u->index]->unmap_range_count - 1;
+ } else
+ events++;
+
+ ++h4p;
+ dprint(FD_IO, "sgv4io_getevents: events: %d, eventNum: %d, left: %d\n", events, eventNum, left);
+ }
+ }
+
+ if (r < 0 && !events)
+ break;
+ if (!events) {
+ usleep(1000);
+ goto re_read;
+ }
+
+ left -= events;
+ r += events;
+
+ for (i = 0; i < events; i++) {
+ struct sg_io_v4 *hdr = (struct sg_io_v4 *) buf + i;
+ io_u = (struct io_u *)(hdr->usr_ptr);
+ sd->events[i + trims] = io_u;
+
+ if (hdr->info & SG_INFO_CHECK) {
+ /* record if an io error occurred, ignore resid */
+ memcpy(&io_u->hdr4, hdr, sizeof(struct sg_io_v4));
+ sd->events[i + trims]->error = EIO;
+ }
+
+ if (io_u->ddir == DDIR_TRIM) {
+ struct sgv4io_trim *st = sd->trim_queues[io_u->index];
+#ifdef FIO_SGV4IO_DEBUG
+ assert(st->trim_io_us[0] == io_u);
+ assert(sd->trim_queue_map[io_u->index] == io_u->index);
+ dprint(FD_IO, "sgv4io_getevents: reaping %d io_us from trim queue %d\n", st->unmap_range_count, io_u->index);
+ dprint(FD_IO, "sgv4io_getevents: reaped io_u %d and stored in events[%d]\n", io_u->index, i+trims);
+#endif
+ for (j = 1; j < st->unmap_range_count; j++) {
+ ++trims;
+ sd->events[i + trims] = st->trim_io_us[j];
+#ifdef FIO_SGV4IO_DEBUG
+ dprint(FD_IO, "sgv4io_getevents: reaped io_u %d and stored in events[%d]\n", st->trim_io_us[j]->index, i+trims);
+ assert(sd->trim_queue_map[st->trim_io_us[j]->index] == io_u->index);
+#endif
+ if (hdr->info & SG_INFO_CHECK) {
+ /* record if an io error occurred, ignore resid */
+ memcpy(&st->trim_io_us[j]->hdr4, hdr, sizeof(struct sg_io_v4));
+ sd->events[i + trims]->error = EIO;
+ }
+ }
+ events -= st->unmap_range_count - 1;
+ st->unmap_range_count = 0;
+ }
+ }
+ }
+
+ if (!min) {
+ for_each_file(td, f, i) {
+ if (sd->fd_flags[i] == -1)
+ continue;
+
+ if (fcntl(f->fd, F_SETFL, sd->fd_flags[i]) < 0)
+ log_err("fio: sgv4 failed to restore fcntl flags: %s\n", strerror(errno));
+ }
+ }
+
+ return r;
+}
+
+static enum fio_q_status fio_sgv4io_ioctl_doio(struct thread_data *td,
+ struct fio_file *f,
+ struct io_u *io_u)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ struct sg_io_v4 *hdr = &io_u->hdr4;
+ int ret;
+
+ sd->events[0] = io_u;
+
+ ret = ioctl(f->fd, SG_IO, hdr);
+ if (ret < 0)
+ return ret;
+
+ /* record if an io error occurred */
+ if (hdr->info & SG_INFO_CHECK)
+ io_u->error = EIO;
+
+ return FIO_Q_COMPLETED;
+}
+
+static enum fio_q_status fio_sgv4io_rw_doio(struct thread_data *td,
+ struct fio_file *f,
+ struct io_u *io_u, bool do_sync)
+{
+ struct sg_io_v4 *hdr = &io_u->hdr4;
+ int ret;
+
+ ret = ioctl(f->fd, SG_IOSUBMIT, hdr);
+ if (ret < 0)
+ return ret;
+
+ if (do_sync) {
+ /*
+ * We can't just read back the first command that completes
+ * and assume it's the one we need, it could be any command
+ * that is inflight.
+ */
+ do {
+ struct io_u *__io_u;
+
+ ret = ioctl(f->fd, SG_IORECEIVE, hdr);
+ if (ret < 0) {
+// fprintf(stderr, "%s: ioctl(SG_IORECEIVE) errno=%d\n", __func__, errno);
+ return ret;
+}
+
+ __io_u = (void *)hdr->usr_ptr;
+
+ /* record if an io error occurred */
+ if (hdr->info & SG_INFO_CHECK)
+ __io_u->error = EIO;
+
+ if (__io_u == io_u)
+ break;
+
+ if (io_u_sync_complete(td, __io_u)) {
+ ret = -1;
+ break;
+ }
+ } while (1);
+
+ return FIO_Q_COMPLETED;
+ }
+
+ return FIO_Q_QUEUED;
+}
+
+static enum fio_q_status fio_sgv4io_doio(struct thread_data *td,
+ struct io_u *io_u, bool do_sync)
+{
+ struct fio_file *f = io_u->file;
+ struct sgv4io_data *sd = td->io_ops_data;
+ enum fio_q_status ret;
+
+ if (f->filetype == FIO_TYPE_BLOCK || (sd && sd->bsg_dev)) {
+ ret = fio_sgv4io_ioctl_doio(td, f, io_u);
+ if (io_u->error)
+ td_verror(td, io_u->error, __func__);
+ } else {
+ ret = fio_sgv4io_rw_doio(td, f, io_u, do_sync);
+ if (io_u->error && do_sync)
+ td_verror(td, io_u->error, __func__);
+ }
+
+ return ret;
+}
+
+#define SGV4_HDR_CMD(u64asp) (uint8_t *)(u64asp)
+
+static void fio_sgv4io_rw_lba(struct sg_io_v4 *hdr, unsigned long long lba,
+ unsigned long long nr_blocks)
+{
+ uint8_t *cmdreq = SGV4_HDR_CMD(hdr->request);
+
+ if (lba < MAX_10B_LBA) {
+ sgio_set_be32((uint32_t) lba, cmdreq + 2);
+ sgio_set_be16((uint16_t) nr_blocks, cmdreq + 7);
+ } else {
+ sgio_set_be64(lba, cmdreq + 2);
+ sgio_set_be32((uint32_t) nr_blocks, cmdreq + 10);
+ }
+
+ return;
+}
+
+
+static int fio_sgv4io_prep(struct thread_data *td, struct io_u *io_u)
+{
+ struct sg_io_v4 *hdr = &io_u->hdr4;
+ struct sgv4_options *o = td->eo;
+ struct sgv4io_data *sd = td->io_ops_data;
+ uint8_t *cmdreq;
+ unsigned long long nr_blocks, lba;
+ int offset;
+
+ if (io_u->xfer_buflen & (sd->bs - 1)) {
+ log_err("read/write not sector aligned\n");
+ return EINVAL;
+ }
+
+ nr_blocks = io_u->xfer_buflen / sd->bs;
+ lba = io_u->offset / sd->bs;
+
+ if (io_u->ddir == DDIR_READ) {
+ sgv4io_hdr_init(sd, hdr, io_u, true);
+
+ cmdreq = SGV4_HDR_CMD(hdr->request);
+ if (lba < MAX_10B_LBA)
+ cmdreq[0] = 0x28; // read(10)
+ else
+ cmdreq[0] = 0x88; // read(16)
+
+ if (o->readfua)
+ cmdreq[1] |= 0x08;
+
+ fio_sgv4io_rw_lba(hdr, lba, nr_blocks);
+
+ } else if (io_u->ddir == DDIR_WRITE) {
+ sgv4io_hdr_init(sd, hdr, io_u, true);
+
+ cmdreq = SGV4_HDR_CMD(hdr->request);
+ hdr->dout_xferp = hdr->din_xferp;
+ hdr->dout_xfer_len = hdr->din_xfer_len;
+ hdr->din_xferp = 0;
+ hdr->din_xfer_len = 0;
+ switch(o->write_mode) {
+ case FIO_SGV4_WRITE:
+ if (lba < MAX_10B_LBA)
+ cmdreq[0] = 0x2a; // write(10)
+ else
+ cmdreq[0] = 0x8a; // write(16)
+ if (o->writefua)
+ cmdreq[1] |= 0x08;
+ break;
+ case FIO_SGV4_WRITE_VERIFY:
+ if (lba < MAX_10B_LBA)
+ cmdreq[0] = 0x2e; // write and verify(10)
+ else
+ cmdreq[0] = 0x8e; // write and verify(16)
+ break;
+ // BYTCHK is disabled by virtue of the memset in sgv4io_hdr_init
+ case FIO_SGV4_WRITE_SAME:
+ hdr->dout_xfer_len = sd->bs;
+ if (lba < MAX_10B_LBA)
+ cmdreq[0] = 0x41; // write same(10)
+ else
+ cmdreq[0] = 0x93; // write same(16)
+ break;
+ };
+
+ fio_sgv4io_rw_lba(hdr, lba, nr_blocks);
+
+ } else if (io_u->ddir == DDIR_TRIM) {
+ struct sgv4io_trim *st;
+
+ if (sd->current_queue == -1) {
+ sgv4io_hdr_init(sd, hdr, io_u, false);
+
+ cmdreq = SGV4_HDR_CMD(hdr->request);
+ hdr->request_len = 10;
+ cmdreq[0] = 0x42; // unmap
+ sd->current_queue = io_u->index;
+ st = sd->trim_queues[sd->current_queue];
+ hdr->dout_xferp = (uint64_t)(uintptr_t)st->unmap_param;
+#ifdef FIO_SGV4IO_DEBUG
+ assert(sd->trim_queues[io_u->index]->unmap_range_count == 0);
+ dprint(FD_IO, "sgv4: creating new queue based on io_u %d\n", io_u->index);
+#endif
+ }
+ else
+ st = sd->trim_queues[sd->current_queue];
+
+ dprint(FD_IO, "sgv4: adding io_u %d to trim queue %d\n", io_u->index, sd->current_queue);
+ st->trim_io_us[st->unmap_range_count] = io_u;
+#ifdef FIO_SGV4IO_DEBUG
+ sd->trim_queue_map[io_u->index] = sd->current_queue;
+#endif
+
+ offset = 8 + 16 * st->unmap_range_count;
+ sgio_set_be64(lba, &st->unmap_param[offset]);
+ sgio_set_be32((uint32_t) nr_blocks, &st->unmap_param[offset + 8]);
+
+ st->unmap_range_count++;
+
+ } else if (ddir_sync(io_u->ddir)) {
+ sgv4io_hdr_init(sd, hdr, io_u, false);
+ cmdreq = SGV4_HDR_CMD(hdr->request);
+ if (lba < MAX_10B_LBA)
+ cmdreq[0] = 0x35; // synccache(10)
+ else
+ cmdreq[0] = 0x91; // synccache(16)
+ } else
+ assert(0);
+
+ return 0;
+}
+
+static void fio_sgv4io_unmap_setup(struct sg_io_v4 *hdr,
+ struct sgv4io_trim *st)
+{
+ uint16_t cnt = st->unmap_range_count * 16;
+ uint8_t *cmdreq = SGV4_HDR_CMD(hdr->request);
+
+ hdr->dout_xfer_len = cnt + 8;
+ sgio_set_be16(cnt + 8, cmdreq + 7);
+ sgio_set_be16(cnt + 6, st->unmap_param);
+ sgio_set_be16(cnt, &st->unmap_param[2]);
+
+ return;
+}
+
+static enum fio_q_status fio_sgv4io_queue(struct thread_data *td,
+ struct io_u *io_u)
+{
+ struct sg_io_v4 *hdr = &io_u->hdr4;
+ struct sgv4io_data *sd = td->io_ops_data;
+ int ret;
+ bool do_sync = false;
+
+ fio_ro_check(td, io_u);
+
+ if (sgio_unbuffered(td) || ddir_sync(io_u->ddir))
+ do_sync = true;
+
+ if (io_u->ddir == DDIR_TRIM) {
+ if (do_sync || io_u->file->filetype == FIO_TYPE_BLOCK) {
+ struct sgv4io_trim *st = sd->trim_queues[sd->current_queue];
+
+ /* finish cdb setup for unmap because we are
+ ** doing unmap commands synchronously */
+#ifdef FIO_SGV4IO_DEBUG
+ assert(st->unmap_range_count == 1);
+ assert(io_u == st->trim_io_us[0]);
+#endif
+ hdr = &io_u->hdr4;
+
+ fio_sgv4io_unmap_setup(hdr, st);
+
+ st->unmap_range_count = 0;
+ sd->current_queue = -1;
+ } else
+ /* queue up trim ranges and submit in commit() */
+ return FIO_Q_QUEUED;
+ }
+
+ ret = fio_sgv4io_doio(td, io_u, do_sync);
+
+ if (ret < 0)
+ io_u->error = errno;
+ else if (hdr->device_status) {
+ io_u->resid = hdr->din_resid;
+ io_u->error = EIO;
+ } else if (td->io_ops->commit != NULL) {
+ if (do_sync && !ddir_sync(io_u->ddir)) {
+ io_u_mark_submit(td, 1);
+ io_u_mark_complete(td, 1);
+ } else if (io_u->ddir == DDIR_READ || io_u->ddir == DDIR_WRITE) {
+ io_u_mark_submit(td, 1);
+ io_u_queued(td, io_u);
+ }
+ }
+
+ if (io_u->error) {
+ td_verror(td, io_u->error, "xfer");
+ return FIO_Q_COMPLETED;
+ }
+
+ return ret;
+}
+
+static int fio_sgv4io_commit(struct thread_data *td)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ struct sgv4io_trim *st;
+ struct io_u *io_u;
+ struct sg_io_v4 *hdr;
+ struct timespec now;
+ unsigned int i;
+ int ret;
+
+ if (sd->current_queue == -1)
+ return 0;
+
+ st = sd->trim_queues[sd->current_queue];
+ io_u = st->trim_io_us[0];
+ hdr = &io_u->hdr4;
+
+ fio_sgv4io_unmap_setup(hdr, st);
+
+ sd->current_queue = -1;
+
+ ret = fio_sgv4io_rw_doio(td, io_u->file, io_u, false);
+
+ if (ret < 0 || hdr->device_status) {
+ int error;
+
+ if (ret < 0)
+ error = errno;
+ else {
+ error = EIO;
+ ret = -EIO;
+ }
+
+ for (i = 0; i < st->unmap_range_count; i++) {
+ st->trim_io_us[i]->error = error;
+ clear_io_u(td, st->trim_io_us[i]);
+ if (hdr->device_status)
+ st->trim_io_us[i]->resid = hdr->din_resid;
+ }
+
+ td_verror(td, error, "xfer");
+ return ret;
+ }
+
+ if (fio_fill_issue_time(td)) {
+ fio_gettime(&now, NULL);
+ for (i = 0; i < st->unmap_range_count; i++) {
+ memcpy(&st->trim_io_us[i]->issue_time, &now, sizeof(now));
+ io_u_queued(td, io_u);
+ }
+ }
+ io_u_mark_submit(td, st->unmap_range_count);
+
+ return 0;
+}
+
+static struct io_u *fio_sgv4io_event(struct thread_data *td, int event)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+
+ return sd->events[event];
+}
+
+static int fio_sgv4io_read_capacity(struct thread_data *td, unsigned int *bs,
+ unsigned long long *max_lba)
+{
+ /*
+ * need to do read capacity operation w/o benefit of sd or
+ * io_u structures, which are not initialized until later.
+ */
+ struct sg_io_v4 hdr;
+ unsigned long long hlba;
+ unsigned int blksz = 0;
+ unsigned char cmd[16];
+ unsigned char sb[64];
+ unsigned char buf[32]; // read capacity return
+ int ret;
+ int fd = -1;
+
+ struct fio_file *f = td->files[0];
+
+ /* open file independent of rest of application */
+ fd = open(f->file_name, O_RDONLY);
+ if (fd < 0)
+ return -errno;
+
+ memset(&hdr, 0, sizeof(hdr));
+ memset(cmd, 0, sizeof(cmd));
+ memset(sb, 0, sizeof(sb));
+ memset(buf, 0, sizeof(buf));
+
+ /* First let's try a 10 byte read capacity. */
+ hdr.guard = 'Q';
+ hdr.request = (uint64_t)(uintptr_t)cmd;
+ hdr.request_len = 10;
+ hdr.response = (uint64_t)(uintptr_t)sb;
+ hdr.max_response_len = sizeof(sb);
+ hdr.timeout = SCSI_TIMEOUT_MS;
+ cmd[0] = 0x25; // Read Capacity(10)
+ hdr.din_xferp = (uint64_t)(uintptr_t)buf;
+ hdr.din_xfer_len = sizeof(buf);
+
+ ret = ioctl(fd, SG_IO, &hdr);
+ if (ret < 0) {
+ close(fd);
+ return ret;
+ }
+
+ if (hdr.info & SG_INFO_CHECK) {
+ /* RCAP(10) might be unsupported by device. Force RCAP(16) */
+ hlba = MAX_10B_LBA;
+ } else {
+ blksz = sgio_get_be32(&buf[4]);
+ hlba = sgio_get_be32(buf);
+ }
+
+ /*
+ * If max lba masked by MAX_10B_LBA equals MAX_10B_LBA,
+ * then need to retry with 16 byte Read Capacity command.
+ */
+ if (hlba == MAX_10B_LBA) {
+ hdr.request_len = 16;
+ cmd[0] = 0x9e; // service action
+ cmd[1] = 0x10; // Read Capacity(16)
+ sgio_set_be32(sizeof(buf), cmd + 10);
+
+ hdr.din_xferp = (uint64_t)(uintptr_t)buf;
+ hdr.din_xfer_len = sizeof(buf);
+
+ ret = ioctl(fd, SG_IO, &hdr);
+ if (ret < 0) {
+ close(fd);
+ return ret;
+ }
+
+ /* record if an io error occurred */
+ if (hdr.info & SG_INFO_CHECK)
+ td_verror(td, EIO, "fio_sgv4io_read_capacity");
+
+ blksz = sgio_get_be32(&buf[8]);
+ hlba = sgio_get_be64(buf);
+ }
+
+ if (blksz) {
+ *bs = blksz;
+ *max_lba = hlba;
+ ret = 0;
+ } else {
+ ret = EIO;
+ }
+
+ close(fd);
+ return ret;
+}
+
+static void fio_sgv4io_cleanup(struct thread_data *td)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ int i;
+
+ if (sd) {
+ free(sd->events);
+ free(sd->cmds);
+ free(sd->fd_flags);
+ free(sd->pfds);
+ free(sd->sgbuf);
+#ifdef FIO_SGV4IO_DEBUG
+ free(sd->trim_queue_map);
+#endif
+
+ for (i = 0; i < td->o.iodepth; i++) {
+ free(sd->trim_queues[i]->unmap_param);
+ free(sd->trim_queues[i]->trim_io_us);
+ free(sd->trim_queues[i]);
+ }
+
+ free(sd->trim_queues);
+ free(sd);
+ }
+}
+
+static int fio_sgv4io_init(struct thread_data *td)
+{
+ struct sgv4io_data *sd;
+ struct sgv4io_trim *st;
+ struct sg_io_v4 *h4p;
+ int i;
+
+ sd = calloc(1, sizeof(*sd));
+ sd->cmds = calloc(td->o.iodepth, sizeof(struct sgv4io_cmd));
+ sd->sgbuf = calloc(td->o.iodepth, sizeof(struct sg_io_v4));
+ sd->events = calloc(td->o.iodepth, sizeof(struct io_u *));
+ sd->pfds = calloc(td->o.nr_files, sizeof(struct pollfd));
+ sd->fd_flags = calloc(td->o.nr_files, sizeof(int));
+ sd->type_checked = 0;
+
+ sd->trim_queues = calloc(td->o.iodepth, sizeof(struct sgv4io_trim *));
+ sd->current_queue = -1;
+#ifdef FIO_SGV4IO_DEBUG
+ sd->trim_queue_map = calloc(td->o.iodepth, sizeof(int));
+#endif
+ for (i = 0, h4p = sd->sgbuf; i < td->o.iodepth; i++, ++h4p) {
+ sd->trim_queues[i] = calloc(1, sizeof(struct sgv4io_trim));
+ st = sd->trim_queues[i];
+ st->unmap_param = calloc(td->o.iodepth + 1, sizeof(char[16]));
+ st->unmap_range_count = 0;
+ st->trim_io_us = calloc(td->o.iodepth, sizeof(struct io_u *));
+ h4p->guard = 'Q';
+ }
+
+ td->io_ops_data = sd;
+
+ /*
+ * we want to do it, regardless of whether odirect is set or not
+ */
+ td->o.override_sync = 1;
+ return 0;
+}
+
+static int fio_sgv4io_type_check(struct thread_data *td, struct fio_file *f)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ unsigned int bs = 0;
+ unsigned long long max_lba = 0;
+
+ if (f->filetype == FIO_TYPE_CHAR) {
+ int version, num, ret;
+
+ if (ioctl(f->fd, SG_GET_VERSION_NUM, &version) < 0) {
+ td_verror(td, errno, "ioctl");
+ return 1;
+ }
+ /* Supported by real sg device node, if not assume it's bsg */
+ if (ioctl(f->fd, SG_GET_NUM_WAITING, &num) < 0)
+ sd->bsg_dev = true;
+ else if (version < 40000) {
+ td_verror(td, EINVAL, "wrong sg driver version");
+ log_err("ioengine sgv4 needs sg v4 driver\n");
+ return 1;
+ } else
+ sd->bsg_dev = false;
+
+ ret = fio_sgv4io_read_capacity(td, &bs, &max_lba);
+ if (ret) {
+ td_verror(td, td->error, "fio_sgv4io_read_capacity");
+ log_err("ioengine sgv4 unable to read capacity successfully\n");
+ return 1;
+ }
+ } else {
+ td_verror(td, EINVAL, "wrong file type");
+ log_err("ioengine sgv4 only works on sg (>= 4) and bsg devices\n");
+ return 1;
+ }
+
+ sd->bs = bs;
+ // Determine size of commands needed based on max_lba
+ if (max_lba >= MAX_10B_LBA) {
+ dprint(FD_IO, "sgio_type_check: using 16 byte read/write "
+ "commands for lba above 0x%016llx/0x%016llx\n",
+ MAX_10B_LBA, max_lba);
+ }
+
+ if (f->filetype == FIO_TYPE_BLOCK) {
+ td->io_ops->getevents = NULL;
+ td->io_ops->event = NULL;
+ td->io_ops->commit = NULL;
+ /*
+ ** Setting these functions to null may cause problems
+ ** with filename=/dev/sda:/dev/sg0 since we are only
+ ** considering a single file
+ */
+ }
+ sd->type_checked = 1;
+
+ return 0;
+}
+
+static int fio_sgv4io_open(struct thread_data *td, struct fio_file *f)
+{
+ struct sgv4io_data *sd = td->io_ops_data;
+ int ret;
+
+ ret = generic_open_file(td, f);
+ if (ret)
+ return ret;
+
+ if (sd && !sd->type_checked && fio_sgv4io_type_check(td, f)) {
+ ret = generic_close_file(td, f);
+ return 1;
+ }
+
+ return 0;
+}
+
+/*
+ * Build an error string with details about the driver, host or scsi
+ * error contained in the sg header Caller will use as necessary.
+ */
+static char *fio_sgv4io_errdetails(struct io_u *io_u)
+{
+ struct sg_io_v4 *hdr = &io_u->hdr4;
+#define MAXERRDETAIL 1024
+#define MAXMSGCHUNK 128
+ uint8_t *cmdreq = SGV4_HDR_CMD(hdr->request);
+ uint8_t *sbp = SGV4_HDR_CMD(hdr->response);
+ char *msg, msgchunk[MAXMSGCHUNK];
+ int i;
+
+ msg = calloc(1, MAXERRDETAIL);
+ strcpy(msg, "");
+
+ /*
+ * can't seem to find sg_err.h, so I'll just echo the define values
+ * so others can search on internet to find clearer clues of meaning.
+ */
+ if (hdr->info & SG_INFO_CHECK) {
+ if (hdr->transport_status) {
+ snprintf(msgchunk, MAXMSGCHUNK, "SG Host Status: 0x%02x; ",
+ hdr->transport_status);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ switch (hdr->transport_status) {
+ case 0x01:
+ strlcat(msg, "SG_ERR_DID_NO_CONNECT", MAXERRDETAIL);
+ break;
+ case 0x02:
+ strlcat(msg, "SG_ERR_DID_BUS_BUSY", MAXERRDETAIL);
+ break;
+ case 0x03:
+ strlcat(msg, "SG_ERR_DID_TIME_OUT", MAXERRDETAIL);
+ break;
+ case 0x04:
+ strlcat(msg, "SG_ERR_DID_BAD_TARGET", MAXERRDETAIL);
+ break;
+ case 0x05:
+ strlcat(msg, "SG_ERR_DID_ABORT", MAXERRDETAIL);
+ break;
+ case 0x06:
+ strlcat(msg, "SG_ERR_DID_PARITY", MAXERRDETAIL);
+ break;
+ case 0x07:
+ strlcat(msg, "SG_ERR_DID_ERROR (internal error)", MAXERRDETAIL);
+ break;
+ case 0x08:
+ strlcat(msg, "SG_ERR_DID_RESET", MAXERRDETAIL);
+ break;
+ case 0x09:
+ strlcat(msg, "SG_ERR_DID_BAD_INTR (unexpected)", MAXERRDETAIL);
+ break;
+ case 0x0a:
+ strlcat(msg, "SG_ERR_DID_PASSTHROUGH", MAXERRDETAIL);
+ break;
+ case 0x0b:
+ strlcat(msg, "SG_ERR_DID_SOFT_ERROR (driver retry?)", MAXERRDETAIL);
+ break;
+ case 0x0c:
+ strlcat(msg, "SG_ERR_DID_IMM_RETRY", MAXERRDETAIL);
+ break;
+ case 0x0d:
+ strlcat(msg, "SG_ERR_DID_REQUEUE", MAXERRDETAIL);
+ break;
+ case 0x0e:
+ strlcat(msg, "SG_ERR_DID_TRANSPORT_DISRUPTED", MAXERRDETAIL);
+ break;
+ case 0x0f:
+ strlcat(msg, "SG_ERR_DID_TRANSPORT_FAILFAST", MAXERRDETAIL);
+ break;
+ case 0x10:
+ strlcat(msg, "SG_ERR_DID_TARGET_FAILURE", MAXERRDETAIL);
+ break;
+ case 0x11:
+ strlcat(msg, "SG_ERR_DID_NEXUS_FAILURE", MAXERRDETAIL);
+ break;
+ case 0x12:
+ strlcat(msg, "SG_ERR_DID_ALLOC_FAILURE", MAXERRDETAIL);
+ break;
+ case 0x13:
+ strlcat(msg, "SG_ERR_DID_MEDIUM_ERROR", MAXERRDETAIL);
+ break;
+ default:
+ strlcat(msg, "Unknown", MAXERRDETAIL);
+ break;
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ }
+ if (hdr->driver_status) {
+ snprintf(msgchunk, MAXMSGCHUNK, "SG Driver Status: 0x%02x; ", hdr->driver_status);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ switch (hdr->driver_status & 0x0F) {
+ case 0x01:
+ strlcat(msg, "SG_ERR_DRIVER_BUSY", MAXERRDETAIL);
+ break;
+ case 0x02:
+ strlcat(msg, "SG_ERR_DRIVER_SOFT", MAXERRDETAIL);
+ break;
+ case 0x03:
+ strlcat(msg, "SG_ERR_DRIVER_MEDIA", MAXERRDETAIL);
+ break;
+ case 0x04:
+ strlcat(msg, "SG_ERR_DRIVER_ERROR", MAXERRDETAIL);
+ break;
+ case 0x05:
+ strlcat(msg, "SG_ERR_DRIVER_INVALID", MAXERRDETAIL);
+ break;
+ case 0x06:
+ strlcat(msg, "SG_ERR_DRIVER_TIMEOUT", MAXERRDETAIL);
+ break;
+ case 0x07:
+ strlcat(msg, "SG_ERR_DRIVER_HARD", MAXERRDETAIL);
+ break;
+ case 0x08:
+ strlcat(msg, "SG_ERR_DRIVER_SENSE", MAXERRDETAIL);
+ break;
+ default:
+ strlcat(msg, "Unknown", MAXERRDETAIL);
+ break;
+ }
+ strlcat(msg, "; ", MAXERRDETAIL);
+ switch (hdr->driver_status & 0xF0) {
+ case 0x10:
+ strlcat(msg, "SG_ERR_SUGGEST_RETRY", MAXERRDETAIL);
+ break;
+ case 0x20:
+ strlcat(msg, "SG_ERR_SUGGEST_ABORT", MAXERRDETAIL);
+ break;
+ case 0x30:
+ strlcat(msg, "SG_ERR_SUGGEST_REMAP", MAXERRDETAIL);
+ break;
+ case 0x40:
+ strlcat(msg, "SG_ERR_SUGGEST_DIE", MAXERRDETAIL);
+ break;
+ case 0x80:
+ strlcat(msg, "SG_ERR_SUGGEST_SENSE", MAXERRDETAIL);
+ break;
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ }
+ if (hdr->device_status) {
+ snprintf(msgchunk, MAXMSGCHUNK, "SG SCSI Status: 0x%02x; ",
+ hdr->device_status);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ // SCSI 3 status codes
+ switch (hdr->device_status) {
+ case 0x02:
+ strlcat(msg, "CHECK_CONDITION", MAXERRDETAIL);
+ break;
+ case 0x04:
+ strlcat(msg, "CONDITION_MET", MAXERRDETAIL);
+ break;
+ case 0x08:
+ strlcat(msg, "BUSY", MAXERRDETAIL);
+ break;
+ case 0x10:
+ strlcat(msg, "INTERMEDIATE", MAXERRDETAIL);
+ break;
+ case 0x14:
+ strlcat(msg, "INTERMEDIATE_CONDITION_MET", MAXERRDETAIL);
+ break;
+ case 0x18:
+ strlcat(msg, "RESERVATION_CONFLICT", MAXERRDETAIL);
+ break;
+ case 0x22:
+ strlcat(msg, "COMMAND_TERMINATED", MAXERRDETAIL);
+ break;
+ case 0x28:
+ strlcat(msg, "TASK_SET_FULL", MAXERRDETAIL);
+ break;
+ case 0x30:
+ strlcat(msg, "ACA_ACTIVE", MAXERRDETAIL);
+ break;
+ case 0x40:
+ strlcat(msg, "TASK_ABORTED", MAXERRDETAIL);
+ break;
+ default:
+ strlcat(msg, "Unknown", MAXERRDETAIL);
+ break;
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ }
+ if (hdr->response_len) {
+ snprintf(msgchunk, MAXMSGCHUNK, "Sense Data (%d bytes):",
+ hdr->response_len);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ for (i = 0; i < hdr->response_len; i++) {
+ snprintf(msgchunk, MAXMSGCHUNK, " %02x", sbp[i]);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ }
+ if (hdr->din_resid != 0) {
+ snprintf(msgchunk, MAXMSGCHUNK, "SG Driver: %d bytes out of %d not "
+ "transferred. ", hdr->din_resid, hdr->din_xfer_len);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ }
+ if (cmdreq) {
+ strlcat(msg, "cdb:", MAXERRDETAIL);
+ for (i = 0; i < hdr->request_len; i++) {
+ snprintf(msgchunk, MAXMSGCHUNK, " %02x", cmdreq[i]);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ if (io_u->ddir == DDIR_TRIM) {
+ unsigned char *param_list = (void *)hdr->dout_xferp;
+ strlcat(msg, "dxferp:", MAXERRDETAIL);
+ for (i = 0; i < hdr->dout_xfer_len; i++) {
+ snprintf(msgchunk, MAXMSGCHUNK, " %02x", param_list[i]);
+ strlcat(msg, msgchunk, MAXERRDETAIL);
+ }
+ strlcat(msg, ". ", MAXERRDETAIL);
+ }
+ }
+ }
+
+ if (!(hdr->info & SG_INFO_CHECK) && !strlen(msg))
+ strncpy(msg, "SG Driver did not report a Host, Driver or Device check",
+ MAXERRDETAIL - 1);
+
+ return msg;
+}
+
+/*
+ * get max file size from read capacity.
+ */
+static int fio_sgv4io_get_file_size(struct thread_data *td, struct fio_file *f)
+{
+ /*
+ * get_file_size is being called even before sgio_init is
+ * called, so none of the sg_io structures are
+ * initialized in the thread_data yet. So we need to do the
+ * ReadCapacity without any of those helpers. One of the effects
+ * is that ReadCapacity may get called 4 times on each open:
+ * readcap(10) followed by readcap(16) if needed - just to get
+ * the file size after the init occurs - it will be called
+ * again when "type_check" is called during structure
+ * initialization I'm not sure how to prevent this little
+ * inefficiency.
+ */
+ unsigned int bs = 0;
+ unsigned long long max_lba = 0;
+ int ret;
+
+ if (fio_file_size_known(f))
+ return 0;
+
+ if (f->filetype != FIO_TYPE_CHAR) {
+ td_verror(td, EINVAL, "wrong file type");
+ log_err("ioengine sgv4 only works on sg_bsg character devices\n");
+ return 1;
+ }
+
+ ret = fio_sgv4io_read_capacity(td, &bs, &max_lba);
+ if (ret ) {
+ td_verror(td, td->error, "fio_sgv4io_read_capacity");
+ log_err("ioengine sgv4 unable to successfully execute read capacity to get block size and maximum lba\n");
+ return 1;
+ }
+
+ f->real_file_size = (max_lba + 1) * bs;
+ fio_file_set_size_known(f);
+ return 0;
+}
+
+
+static struct ioengine_ops ioengine = {
+ .name = "sgv4",
+ .version = FIO_IOOPS_VERSION,
+ .init = fio_sgv4io_init,
+ .prep = fio_sgv4io_prep,
+ .queue = fio_sgv4io_queue,
+ .commit = fio_sgv4io_commit,
+ .getevents = fio_sgv4io_getevents,
+ .errdetails = fio_sgv4io_errdetails,
+ .event = fio_sgv4io_event,
+ .cleanup = fio_sgv4io_cleanup,
+ .open_file = fio_sgv4io_open,
+ .close_file = generic_close_file,
+ .get_file_size = fio_sgv4io_get_file_size,
+ .flags = FIO_SYNCIO | FIO_RAWIO,
+ .options = options,
+ .option_struct_size = sizeof(struct sgv4_options)
+};
+
+#else /* FIO_HAVE_SGV4IO */
+
+/*
+ * When we have a proper configure system in place, we simply wont build
+ * and install this io engine. For now install a crippled version that
+ * just complains and fails to load.
+ */
+static int fio_sgv4io_init(struct thread_data fio_unused *td)
+{
+ log_err("fio: ioengine sgv4 not available\n");
+ return 1;
+}
+
+static struct ioengine_ops ioengine = {
+ .name = "sgv4",
+ .version = FIO_IOOPS_VERSION,
+ .init = fio_sgv4io_init,
+};
+
+#endif
+
+static void fio_init fio_sgv4io_register(void)
+{
+ register_ioengine(&ioengine);
+}
+
+static void fio_exit fio_sgv4io_unregister(void)
+{
+ unregister_ioengine(&ioengine);
+}
diff --git a/io_u.h b/io_u.h
index e75993bd..35a71b6f 100644
--- a/io_u.h
+++ b/io_u.h
@@ -122,7 +122,10 @@ struct io_u {
os_aiocb_t aiocb;
#endif
#ifdef FIO_HAVE_SGIO
- struct sg_io_hdr hdr;
+ struct sg_io_hdr hdr3;
+#endif
+#ifdef FIO_HAVE_SGV4IO
+ struct sg_io_v4 hdr4;
#endif
#ifdef CONFIG_GUASI
guasi_req_t greq;
diff --git a/os/os-linux.h b/os/os-linux.h
index 36339ef3..33eb5fff 100644
--- a/os/os-linux.h
+++ b/os/os-linux.h
@@ -17,6 +17,7 @@
#include <linux/raw.h>
#include <linux/major.h>
#include <linux/fs.h>
+#include <linux/bsg.h>
#include <scsi/sg.h>
#ifdef ARCH_HAVE_CRC_CRYPTO
@@ -36,6 +37,7 @@
#define FIO_HAVE_CPU_AFFINITY
#define FIO_HAVE_DISK_UTIL
#define FIO_HAVE_SGIO
+#define FIO_HAVE_SGV4IO
#define FIO_HAVE_IOPRIO
#define FIO_HAVE_IOPRIO_CLASS
#define FIO_HAVE_IOSCHED_SWITCH
--
2.17.1
