aboutsummaryrefslogtreecommitdiff
path: root/testing/sgs_dd.c
diff options
context:
space:
mode:
Diffstat (limited to 'testing/sgs_dd.c')
-rw-r--r--testing/sgs_dd.c1667
1 files changed, 1667 insertions, 0 deletions
diff --git a/testing/sgs_dd.c b/testing/sgs_dd.c
new file mode 100644
index 00000000..c139a178
--- /dev/null
+++ b/testing/sgs_dd.c
@@ -0,0 +1,1667 @@
+/*
+ * Test code for the extensions to the Linux OS SCSI generic ("sg")
+ * device driver.
+ * Copyright (C) 1999-2022 D. Gilbert and P. Allworth
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * This program is a specialization of the Unix "dd" command in which
+ * one or both of the given files is a scsi generic device. A block size
+ * ('bs') is assumed to be 512 if not given. This program complains if
+ * 'ibs' or 'obs' are given with some other value than 'bs'.
+ * If 'if' is not given or 'if=-' then stdin is assumed. If 'of' is
+ * not given of 'of=-' then stdout assumed. The multipliers "c, b, k, m"
+ * are recognized on numeric arguments.
+ *
+ * A non-standard argument "bpt" (blocks per transfer) is added to control
+ * the maximum number of blocks in each transfer. The default bpt value is
+ * (64 * 1024 * 1024 / bs) or 1 if the first expression is 0. That is an
+ * integer division (rounds toward 0). For example if "bs=512" and "bpt=32"
+ * are given then a maximum of 32 blocks (16KB in this case) are transferred
+ * to or from the sg device in a single SCSI command.
+ *
+ * BEWARE: If the 'of' file is a 'sg' device (eg a disk) then it _will_
+ * be written to, potentially destroying its previous contents.
+ *
+ * This version should compile with Linux sg drivers with version numbers
+ * >= 30000 . Also this version also allows SIGPOLL or a RT signal to be
+ * chosen. SIGIO is a synonym for SIGPOLL; SIGIO seems to be deprecated.
+ */
+
+/* We need F_SETSIG, (signal redirect), so following define */
+#define _GNU_SOURCE 1
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <poll.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h> /* for mmap() system call */
+#include <sys/eventfd.h>
+#include <sys/epoll.h>
+#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>
+
+#ifndef HAVE_LINUX_SG_V4_HDR
+/* Kernel uapi header contain __user decorations on user space pointers
+ * to indicate they are unsafe in the kernel space. However glibc takes
+ * all those __user decorations out from headers in /usr/include/linux .
+ * So to stop compile errors when directly importing include/uapi/scsi/sg.h
+ * undef __user before doing that include. */
+#define __user
+
+/* Want to block the original sg.h header from also being included. That
+ * causes lots of multiple definition errors. This will only work if this
+ * header is included _before_ the original sg.h header. */
+#define _SCSI_GENERIC_H /* original kernel header guard */
+#define _SCSI_SG_H /* glibc header guard */
+
+#include "uapi_sg.h" /* local copy of include/uapi/scsi/sg.h */
+
+#else
+#define __user
+#endif /* end of: ifndef HAVE_LINUX_SG_V4_HDR */
+
+#include "sg_lib.h"
+#include "sg_linux_inc.h"
+#include "sg_io_linux.h"
+#include "sg_pr2serr.h"
+#include "sg_unaligned.h"
+
+
+static const char * version_str = "4.24 20221020";
+static const char * my_name = "sgs_dd";
+
+#ifndef SGV4_FLAG_POLLED
+#define SGV4_FLAG_POLLED 0x800
+#endif
+
+#define DEF_BLOCK_SIZE 512
+#define DEF_BPT_TIMES_BS_SZ (64 * 1024) /* 64 KB */
+
+#define SENSE_BUFF_LEN 32 /* Arbitrary, could be larger */
+#define DEF_TIMEOUT 40000 /* 40,000 millisecs == 40 seconds */
+#define S_RW_LEN 10 /* Use SCSI READ(10) and WRITE(10) */
+#define SGQ_MAX_RD_AHEAD 32
+#define SGQ_MAX_WR_AHEAD 32
+#define SGQ_NUM_ELEMS (SGQ_MAX_RD_AHEAD + SGQ_MAX_WR_AHEAD + 1)
+#define MAX_BPT_VALUE (1 << 24) /* used for maximum bs as well */
+#define MAX_COUNT_SKIP_SEEK (1LL << 48) /* coverity wants upper bound */
+
+#define SGQ_FREE 0
+#define SGQ_IO_STARTED 1
+#define SGQ_IO_FINISHED 2
+#define SGQ_IO_ERR 3
+#define SGQ_IO_WAIT 4
+
+#define SGQ_CAN_DO_NOTHING 0 /* only temporarily in use */
+#define SGQ_CAN_READ 1
+#define SGQ_CAN_WRITE 2
+#define SGQ_TIMEOUT 4
+
+#define DEF_SIGTIMEDWAIT_USEC 100
+
+
+#define STR_SZ 1024
+#define INOUTF_SZ 900
+#define EBUFF_SZ 1024
+
+struct flags_t {
+ bool dio;
+ bool evfd;
+ bool excl;
+ bool immed;
+ bool mmap;
+ bool noxfer;
+ bool pack;
+ bool polled;
+ bool tag;
+ bool v3;
+ bool v4;
+ bool given_v3v4;
+};
+
+typedef struct request_element
+{
+ struct request_element * nextp;
+ bool stop_after_wr;
+ bool wr;
+ int state;
+ int blk;
+ int num_blks;
+ uint8_t * buffp;
+ uint8_t * free_buffp;
+ sg_io_hdr_t io_hdr;
+ struct sg_io_v4 io_v4;
+ struct flags_t * iflagp;
+ struct flags_t * oflagp;
+ uint8_t cmd[S_RW_LEN];
+ uint8_t sb[SENSE_BUFF_LEN];
+ int result;
+} Rq_elem;
+
+typedef struct request_collection
+{
+ bool in_is_sg;
+ bool out_is_sg;
+ bool no_sig;
+ bool use_rt_sig;
+ bool both_mmap;
+ int infd;
+ int in_evfd;
+ int in_blk; /* most recent read */
+ int in_count; /* most recent read */
+ int in_done_count; /* count of completed in blocks */
+ int in_partial;
+ int outfd;
+ int out_evfd;
+ int lowest_seek;
+ int out_blk; /* most recent write */
+ int out_count; /* most recent write */
+ int out_done_count; /* count of completed out blocks */
+ int out_partial;
+ int bs;
+ int bpt;
+ int dio_incomplete;
+ int sum_of_resids;
+ int poll_ms;
+ int pollerr_count;
+ int debug; /* also set with -v up to -vvvvv */
+ sigset_t blocked_sigs;
+ int sigs_waiting;
+ int sigs_rt_received;
+ int sigs_io_received;
+ int blk_poll_count;
+ Rq_elem * rd_posp;
+ Rq_elem * wr_posp;
+ uint8_t * in_mmapp;
+ uint8_t * out_mmapp;
+ struct flags_t iflag;
+ struct flags_t oflag;
+ Rq_elem elem[SGQ_NUM_ELEMS];
+} Rq_coll;
+
+static bool sgs_old_sg_driver = false; /* true if VERSION_NUM < 4.00.00 */
+static bool sgs_full_v4_sg_driver = false; /* set if VERSION_NUM >= 4.00.30 */
+static bool sgs_nanosec_unit = false;
+
+static int sgq_rd_ahead_lim = SGQ_MAX_RD_AHEAD;
+static int sgq_wr_ahead_lim = SGQ_MAX_WR_AHEAD;
+static int sgq_num_elems = (SGQ_MAX_RD_AHEAD + SGQ_MAX_WR_AHEAD + 1);
+
+
+static void
+usage(int pg_num)
+{
+ if (pg_num > 1)
+ goto second_page;
+ printf("Usage: "
+ "sgs_dd [bpt=BPT] [bs=BS] [count=NUM] [deb=DEB] [if=IFILE]\n"
+ " [iflag=FLAGS] [no_sig=0|1] [of=OFILE] "
+ "[oflag=FLAGS]\n"
+ " [poll_ms=MS] [rt_sig=0|1] [seek=SEEK] "
+ "[skip=SKIP]\n"
+ " [--help] [--version]\n"
+ "where:\n"
+ " bpt blocks_per_transfer (default: 65536/bs (or 128 for "
+ "bs=512))\n"
+ " bs must be the logical block size of device (def: 512)\n"
+ " deb debug: 0->no debug (def); > 0 -> more debug\n"
+ " -v (up to -vvvvv) sets deb value to number of 'v's\n"
+ " iflag comma separated list from: dio,evfd,excl,immed,mmap,"
+ "noxfer,\n"
+ " null,pack,polled,tag,v3,v4 bound to IFILE\n"
+ " no_sig 0-> use signals; 1-> no signals, hard polling "
+ "instead;\n"
+ " default 0, unless polled flag(s) given then it's 1\n"
+ " oflag same flags as iflag but bound to OFILE\n"
+ " poll_ms number of milliseconds to wait on poll (def: 0)\n"
+ " rt_sig 0->use SIGIO (def); 1->use RT sig (SIGRTMIN + 1)\n"
+ " <other operands> as per dd command\n\n");
+ printf("dd clone for testing Linux sg driver SIGPOLL and/or polling. "
+ "Either\nIFILE or OFILE must be a scsi generic device. If OFILE "
+ "not given then\n/dev/null assumed (rather than stdout like "
+ "dd). Use '-hh' for flag\ninformation.\n");
+ return;
+second_page:
+ printf("flag description:\n"
+ " dio this driver's version of O_DIRECT\n"
+ " evfd when poll() gives POLLIN, use eventfd to find "
+ "out how many\n"
+ " excl open IFILE or OFILE with O_EXCL\n"
+ " hipri same as 'polled'; name 'hipri' is deprecated\n"
+ " immed use SGV4_FLAG_IMMED flag on each request\n"
+ " mmap use mmap()-ed IO on IFILE or OFILE\n"
+ " noxfer no transfer between user space and kernel IO "
+ "buffers\n"
+ " null does nothing, placeholder\n"
+ " pack submit with rising pack_id, complete matching "
+ "each pack_id\n"
+ " polled set POLLED flag and use blk_poll() for completion\n"
+ " tag use tag (from block layer) rather than "
+ "pack_id\n"
+ " v3 use sg v3 interface (default)\n"
+ " v4 use sg vr interface (i.e. struct sg_io_v4)\n");
+}
+
+static int
+get_mmap_addr(int fd, int num, uint8_t ** mmpp)
+{
+ uint8_t * mmp;
+
+ if (! mmpp)
+ return -EINVAL;
+ mmp = (uint8_t *)mmap(NULL, num, PROT_READ | PROT_WRITE,
+ MAP_SHARED, fd, 0);
+ if (MAP_FAILED == mmp) {
+ int err = errno;
+
+ pr2serr("%s%s: sz=%d, fd=%d, mmap() failed: %s\n",
+ my_name, __func__, num, fd, strerror(err));
+ return -err;
+ }
+ *mmpp = mmp;
+ return 0;
+}
+
+/* Return of 0 -> success, -1 -> failure, 2 -> try again */
+static int
+read_capacity(int sg_fd, int * num_sect, int * sect_sz)
+{
+ int res;
+ uint8_t rcCmdBlk [10] = {0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ uint8_t rcBuff[64];
+ uint8_t sense_b[64];
+ sg_io_hdr_t io_hdr;
+
+ memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
+ io_hdr.interface_id = 'S';
+ io_hdr.cmd_len = sizeof(rcCmdBlk);
+ io_hdr.mx_sb_len = sizeof(sense_b);
+ io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
+ io_hdr.dxfer_len = sizeof(rcBuff);
+ io_hdr.dxferp = rcBuff;
+ io_hdr.cmdp = rcCmdBlk;
+ io_hdr.sbp = sense_b;
+ io_hdr.timeout = DEF_TIMEOUT;
+
+ if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
+ res = -errno;
+ perror("read_capacity (SG_IO) error");
+ return res;
+ }
+ res = sg_err_category3(&io_hdr);
+ if (SG_LIB_CAT_UNIT_ATTENTION == res)
+ return 2; /* probably have another go ... */
+ else if (SG_LIB_CAT_CLEAN != res) {
+ sg_chk_n_print3("read capacity", &io_hdr, true);
+ return -1;
+ }
+ *num_sect = sg_get_unaligned_be32(rcBuff + 0) + 1;
+ *sect_sz = sg_get_unaligned_be32(rcBuff + 4);
+ return 0;
+}
+
+/* -ve -> unrecoverable error, 0 -> successful, 1 -> recoverable (ENOMEM) */
+static int
+sg_start_io(Rq_coll * clp, Rq_elem * rep)
+{
+ bool is_wr = rep->wr;
+ int res;
+ int fd = is_wr ? clp->outfd : clp->infd;
+ int num_bytes = clp->bs * rep->num_blks;
+ struct flags_t * flagp = is_wr ? rep->oflagp : rep->iflagp;
+ sg_io_hdr_t * hp = &rep->io_hdr;
+ struct sg_io_v4 * h4p = &rep->io_v4;
+
+ if (clp->both_mmap && is_wr)
+ memcpy(clp->out_mmapp, clp->in_mmapp, num_bytes);
+ memset(rep->cmd, 0, sizeof(rep->cmd));
+ rep->cmd[0] = is_wr ? 0x2a : 0x28;
+ sg_put_unaligned_be32((uint32_t)rep->blk, rep->cmd + 2);
+ sg_put_unaligned_be16((uint16_t)rep->num_blks, rep->cmd + 7);
+ if (flagp->v4)
+ goto do_v4;
+
+ memset(hp, 0, sizeof(sg_io_hdr_t));
+ hp->interface_id = 'S';
+ hp->cmd_len = sizeof(rep->cmd);
+ hp->cmdp = rep->cmd;
+ hp->dxfer_direction = is_wr ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV;
+ hp->dxfer_len = num_bytes;
+ hp->mx_sb_len = sizeof(rep->sb);
+ hp->sbp = rep->sb;
+ hp->timeout = DEF_TIMEOUT;
+ hp->usr_ptr = rep;
+ hp->pack_id = rep->blk;
+ if (flagp->dio)
+ hp->flags |= SG_FLAG_DIRECT_IO;
+ if (flagp->noxfer)
+ hp->flags |= SG_FLAG_NO_DXFER;
+ if (flagp->immed)
+ hp->flags |= SGV4_FLAG_IMMED;
+ if (flagp->polled)
+ hp->flags |= SGV4_FLAG_POLLED;
+ if (flagp->mmap) {
+ hp->flags |= SG_FLAG_MMAP_IO;
+ hp->dxferp = is_wr ? clp->out_mmapp : clp->in_mmapp;
+ } else
+ hp->dxferp = rep->buffp;
+ if (flagp->evfd)
+ hp->flags |= SGV4_FLAG_EVENTFD;
+ if (clp->debug > 5) {
+ pr2serr("%s: SCSI %s, blk=%d num_blks=%d\n", __func__,
+ is_wr ? "WRITE" : "READ", rep->blk, rep->num_blks);
+ sg_print_command(hp->cmdp);
+ pr2serr("dir=%d, len=%d, dxfrp=%p, cmd_len=%d\n", hp->dxfer_direction,
+ hp->dxfer_len, hp->dxferp, hp->cmd_len);
+ }
+
+ while (((res = write(fd, hp, sizeof(sg_io_hdr_t))) < 0) &&
+ (EINTR == errno))
+ ;
+ if (res < 0) {
+ if (ENOMEM == errno)
+ return 1;
+ if ((EDOM == errno) || (EAGAIN == errno) || (EBUSY == errno)) {
+ rep->state = SGQ_IO_WAIT; /* busy so wait */
+ return 0;
+ }
+ pr2serr("%s: write(): %s [%d]\n", __func__, strerror(errno), errno);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ rep->state = SGQ_IO_STARTED;
+ if (! clp->no_sig)
+ clp->sigs_waiting++;
+ return 0;
+do_v4:
+ memset(h4p, 0, sizeof(struct sg_io_v4));
+ h4p->guard = 'Q';
+ h4p->request_len = sizeof(rep->cmd);
+ h4p->request = (uint64_t)(uintptr_t)rep->cmd;
+ if (is_wr)
+ h4p->dout_xfer_len = num_bytes;
+ else if (rep->num_blks > 0)
+ h4p->din_xfer_len = num_bytes;
+ h4p->max_response_len = sizeof(rep->sb);
+ h4p->response = (uint64_t)(uintptr_t)rep->sb;
+ h4p->timeout = DEF_TIMEOUT;
+ h4p->usr_ptr = (uint64_t)(uintptr_t)rep;
+ h4p->request_extra = rep->blk;/* N.B. blk --> pack_id --> request_extra */
+ if (flagp->dio)
+ h4p->flags |= SG_FLAG_DIRECT_IO;
+ if (flagp->noxfer)
+ h4p->flags |= SG_FLAG_NO_DXFER;
+ if (flagp->immed)
+ h4p->flags |= SGV4_FLAG_IMMED;
+ if (flagp->polled)
+ h4p->flags |= SGV4_FLAG_POLLED;
+ if (flagp->mmap) {
+ h4p->flags |= SG_FLAG_MMAP_IO;
+ hp->dxferp = is_wr ? clp->out_mmapp : clp->in_mmapp;
+ } else {
+ if (is_wr)
+ h4p->dout_xferp = (uint64_t)(uintptr_t)rep->buffp;
+ else if (rep->num_blks > 0)
+ h4p->din_xferp = (uint64_t)(uintptr_t)rep->buffp;
+ }
+ if (flagp->tag)
+ h4p->flags |= SGV4_FLAG_YIELD_TAG;
+ if (flagp->evfd)
+ h4p->flags |= SGV4_FLAG_EVENTFD;
+ if (! clp->no_sig)
+ h4p->flags |= SGV4_FLAG_SIGNAL;
+
+ while (((res = ioctl(fd, SG_IOSUBMIT, h4p)) < 0) && (EINTR == errno))
+ ;
+ if (res < 0) {
+ if (ENOMEM == errno)
+ return 1;
+ if ((EDOM == errno) || (EAGAIN == errno) || (EBUSY == errno)) {
+ rep->state = SGQ_IO_WAIT; /* busy so wait */
+ return 0;
+ }
+ pr2serr("%s: ioctl(SG_IOSUBMIT): %s [%d]\n", __func__,
+ strerror(errno), errno);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ rep->state = SGQ_IO_STARTED;
+ if (! clp->no_sig)
+ clp->sigs_waiting++;
+ if (clp->debug > 5) {
+ if (is_wr ? clp->oflag.tag : clp->iflag.tag)
+ pr2serr("%s: generated_tag=0x%" PRIx64 "\n", __func__,
+ (uint64_t)h4p->generated_tag);
+ }
+ return 0;
+}
+
+/* -1 -> unrecoverable error, 0 -> successful, 1 -> try again */
+static int
+sg_finish_io(Rq_coll * clp, bool wr, Rq_elem ** repp)
+{
+ struct flags_t *flagsp = wr ? &clp->oflag : &clp->iflag;
+ bool dio = false;
+ bool is_v4 = flagsp->v4;
+ bool use_pack = flagsp->pack;
+ bool use_tag = flagsp->tag;
+ int fd = wr ? clp->outfd : clp->infd;
+ int res, id, n;
+ sg_io_hdr_t io_hdr;
+ sg_io_hdr_t * hp;
+ struct sg_io_v4 io_v4;
+ struct sg_io_v4 * h4p;
+ Rq_elem * rep;
+
+ if (is_v4)
+ goto do_v4;
+ if (use_pack) {
+ while (true) {
+ if ( ((res = ioctl(fd, SG_GET_NUM_WAITING, &n))) < 0) {
+ res = -errno;
+ pr2serr("%s: ioctl(SG_GET_NUM_WAITING): %s [%d]\n",
+ __func__, strerror(errno), errno);
+ return res;
+ }
+ if (n > 0) {
+ if ( (ioctl(fd, SG_GET_PACK_ID, &id)) < 0) {
+ res = errno;
+ pr2serr("%s: ioctl(SG_GET_PACK_ID): %s [%d]\n",
+ __func__, strerror(res), res);
+ return -res;
+ }
+ /* got pack_id or tag of first waiting */
+ break;
+ }
+ }
+ }
+ memset(&io_hdr, 0 , sizeof(sg_io_hdr_t));
+ if (use_pack)
+ io_hdr.pack_id = id;
+ while (((res = read(fd, &io_hdr, sizeof(sg_io_hdr_t))) < 0) &&
+ ((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno)))
+ ;
+ rep = (Rq_elem *)io_hdr.usr_ptr;
+ if (rep) {
+ dio = flagsp->dio;
+ if (rep->io_hdr.flags & SGV4_FLAG_POLLED)
+ ++clp->blk_poll_count;
+ }
+ if (res < 0) {
+ res = -errno;
+ pr2serr("%s: read(): %s [%d]\n", __func__, strerror(errno), errno);
+ if (rep)
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ if (! (rep && (SGQ_IO_STARTED == rep->state))) {
+ pr2serr("%s: bad usr_ptr\n", __func__);
+ if (rep)
+ rep->state = SGQ_IO_ERR;
+ return -1;
+ }
+ memcpy(&rep->io_hdr, &io_hdr, sizeof(sg_io_hdr_t));
+ hp = &rep->io_hdr;
+ if (repp)
+ *repp = rep;
+
+ switch (sg_err_category3(hp)) {
+ case SG_LIB_CAT_CLEAN:
+ break;
+ case SG_LIB_CAT_RECOVERED:
+ pr2serr("Recovered error on block=%d, num=%d\n", rep->blk,
+ rep->num_blks);
+ break;
+ case SG_LIB_CAT_UNIT_ATTENTION:
+ return 1;
+ default:
+ sg_chk_n_print3(wr ? "writing": "reading", hp, true);
+ rep->state = SGQ_IO_ERR;
+ return -1;
+ }
+ if (dio && ((hp->info & SG_INFO_DIRECT_IO_MASK) != SG_INFO_DIRECT_IO))
+ ++clp->dio_incomplete; /* count dios done as indirect IO */
+ clp->sum_of_resids += hp->resid;
+ rep->state = SGQ_IO_FINISHED;
+ if (clp->debug > 5) {
+ pr2serr("%s: %s ", __func__, wr ? "writing" : "reading");
+ pr2serr(" SGQ_IO_FINISHED elem idx=%zd\n", rep - clp->elem);
+ }
+ return 0;
+do_v4:
+ id = -1;
+ if (use_pack || use_tag) {
+ while (true) {
+ if ( ((res = ioctl(fd, SG_GET_NUM_WAITING, &n))) < 0) {
+ res = -errno;
+ pr2serr("%s: ioctl(SG_GET_NUM_WAITING): %s [%d]\n",
+ __func__, strerror(errno), errno);
+ return res;
+ }
+ if (n > 0) {
+ if ( (ioctl(fd, SG_GET_PACK_ID, &id)) < 0) {
+ res = errno;
+ pr2serr("%s: ioctl(SG_GET_PACK_ID): %s [%d]\n",
+ __func__, strerror(res), res);
+ return -res;
+ }
+ /* got pack_id or tag of first waiting */
+ break;
+ }
+ }
+ }
+ memset(&io_v4, 0 , sizeof(io_v4));
+ io_v4.guard = 'Q';
+ if (use_tag)
+ io_v4.request_tag = id;
+ else if (use_pack)
+ io_v4.request_extra = id;
+ io_v4.flags |= SGV4_FLAG_IMMED;
+ if (flagsp->evfd)
+ io_v4.flags |= SGV4_FLAG_EVENTFD;
+ while (((res = ioctl(fd, SG_IORECEIVE, &io_v4)) < 0) &&
+ ((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno)))
+ ;
+ rep = (Rq_elem *)(unsigned long)io_v4.usr_ptr;
+ if (res < 0) {
+ res = -errno;
+ pr2serr("%s: ioctl(SG_IORECEIVE): %s [%d]\n", __func__,
+ strerror(errno), errno);
+ if (rep)
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ if (rep) {
+ if (rep->io_v4.flags & SGV4_FLAG_POLLED)
+ ++clp->blk_poll_count;
+ }
+ if (! (rep && (SGQ_IO_STARTED == rep->state))) {
+ pr2serr("%s: bad usr_ptr=0x%p\n", __func__, (void *)rep);
+ if (rep)
+ rep->state = SGQ_IO_ERR;
+ return -1;
+ }
+ memcpy(&rep->io_v4, &io_v4, sizeof(struct sg_io_v4));
+ h4p = &rep->io_v4;
+ if (repp)
+ *repp = rep;
+
+ res = sg_err_category_new(h4p->device_status, h4p->transport_status,
+ h4p->driver_status,
+ (const uint8_t *)(unsigned long)h4p->response,
+ h4p->response_len);
+ switch (res) {
+ case SG_LIB_CAT_CLEAN:
+ break;
+ case SG_LIB_CAT_RECOVERED:
+ pr2serr("Recovered error on block=%d, num=%d\n", rep->blk,
+ rep->num_blks);
+ break;
+ case SG_LIB_CAT_UNIT_ATTENTION:
+ return 1;
+ default:
+ sg_linux_sense_print(wr ? "writing": "reading",
+ h4p->device_status, h4p->transport_status,
+ h4p->driver_status,
+ (const uint8_t *)(unsigned long)h4p->response,
+ h4p->response_len, true);
+ rep->state = SGQ_IO_ERR;
+ return -1;
+ }
+ if (dio && ((h4p->info & SG_INFO_DIRECT_IO_MASK) != SG_INFO_DIRECT_IO))
+ ++clp->dio_incomplete; /* count dios done as indirect IO */
+ clp->sum_of_resids += h4p->din_resid;
+ rep->state = SGQ_IO_FINISHED;
+ if (clp->debug > 5) {
+ pr2serr("%s: %s ", __func__, wr ? "writing" : "reading");
+ pr2serr(" SGQ_IO_FINISHED elem idx=%zd\n", rep - clp->elem);
+ if (use_pack)
+ pr2serr("%s: pack_id=%d\n", __func__, h4p->request_extra);
+ else if (use_tag)
+ pr2serr("%s: request_tag=0x%" PRIx64 "\n", __func__,
+ (uint64_t)h4p->request_tag);
+ }
+ return 0;
+}
+
+static int
+sz_reserve(Rq_coll * clp, bool is_in)
+{
+ const struct flags_t *flagsp = is_in ? &clp->iflag : &clp->oflag;
+ bool pack = flagsp->pack;
+ bool vb = clp->debug;
+ int res, t, flags, err;
+ int fd = is_in ? clp->infd : clp->outfd;
+ int tag = flagsp->tag;
+ struct sg_extended_info sei;
+ struct sg_extended_info * seip;
+
+ seip = &sei;
+ res = ioctl(fd, SG_GET_VERSION_NUM, &t);
+ if ((res < 0) || (t < 30000)) {
+ pr2serr("%s: sg driver prior to 3.0.00\n", my_name);
+ return 1;
+ } else if (t < 40000) {
+ if (vb)
+ pr2serr("%s: warning: sg driver prior to 4.0.00\n", my_name);
+ sgs_old_sg_driver = true;
+ } else if (t < 40045) {
+ sgs_old_sg_driver = false;
+ sgs_full_v4_sg_driver = false;
+ } else
+ sgs_full_v4_sg_driver = true;
+ t = clp->bs * clp->bpt;
+ res = ioctl(fd, SG_SET_RESERVED_SIZE, &t);
+ if (res < 0)
+ perror("sgs_dd: SG_SET_RESERVED_SIZE error");
+
+ if (sgs_full_v4_sg_driver) {
+ if (sgs_nanosec_unit) {
+ memset(seip, 0, sizeof(*seip));
+ seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS;
+ seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TIME_IN_NS;
+ seip->ctl_flags |= SG_CTL_FLAGM_TIME_IN_NS;
+ if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
+ pr2serr("ioctl(EXTENDED(TIME_IN_NS)) failed, errno=%d %s\n",
+ errno, strerror(errno));
+ return 1;
+ }
+ }
+ if (tag || pack) {
+ t = 1;
+ if (ioctl(fd, SG_SET_FORCE_PACK_ID, &t) < 0) {
+ pr2serr("ioctl(SG_SET_FORCE_PACK_ID(on)) failed, errno=%d "
+ "%s\n", errno, strerror(errno));
+ return 1;
+ }
+ if (tag) {
+ memset(seip, 0, sizeof(*seip));
+ seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS;
+ seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TAG_FOR_PACK_ID;
+ seip->ctl_flags |= SG_CTL_FLAGM_TAG_FOR_PACK_ID;
+ if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
+ pr2serr("ioctl(EXTENDED(TAG_FOR_PACK_ID)) failed, "
+ "errno=%d %s\n", errno, strerror(errno));
+ return 1;
+ }
+ }
+ }
+ if (flagsp->evfd) {
+ int evfd = eventfd(0,0);
+
+ if (evfd < 0) {
+ err = errno;
+ pr2serr("eventfd() failed: %s\n", strerror(err));
+ return 1;
+ }
+ if (is_in)
+ clp->in_evfd = evfd;
+ else
+ clp->out_evfd = evfd;
+
+ memset(seip, 0, sizeof(*seip));
+ seip->sei_wr_mask |= SG_SEIM_EVENTFD;
+ seip->sei_rd_mask |= SG_SEIM_EVENTFD;
+ seip->share_fd = evfd;
+ if (ioctl(fd, SG_SET_GET_EXTENDED, seip) < 0) {
+ err = errno;
+ pr2serr("ioctl(EXTENDED(SG_SEIM_EVENTFD)) failed, "
+ "errno=%d %s\n", err, strerror(err));
+ return 1;
+ }
+ }
+ }
+ if (!clp->no_sig) {
+ if (-1 == fcntl(fd, F_SETOWN, getpid())) {
+ perror("fcntl(F_SETOWN)");
+ return 1;
+ }
+ flags = fcntl(fd, F_GETFL, 0);
+ if (-1 == fcntl(fd, F_SETFL, flags | O_ASYNC)) {
+ perror("fcntl(F_SETFL)");
+ return 1;
+ }
+ if (clp->use_rt_sig) {/* displaces SIGIO/SIGPOLL with SIGRTMIN + 1 */
+ if (-1 == fcntl(fd, F_SETSIG, SIGRTMIN + 1))
+ perror("fcntl(F_SETSIG)");
+ }
+ }
+ return 0;
+}
+
+static int
+init_elems(Rq_coll * clp)
+{
+ bool either_mmap = false;
+ int res = 0;
+ int num_bytes = clp->bpt * clp->bs;
+ int k;
+ Rq_elem * rep;
+
+ clp->wr_posp = &clp->elem[0]; /* making ring buffer */
+ clp->rd_posp = clp->wr_posp;
+ if (clp->iflag.mmap || clp->oflag.mmap) {
+ int res;
+
+ either_mmap = true;
+ sgq_num_elems = 2;
+ sgq_rd_ahead_lim = 1;
+ sgq_wr_ahead_lim = 1;
+ if (clp->iflag.mmap) {
+ res = get_mmap_addr(clp->infd, num_bytes, &clp->in_mmapp);
+ if (res < 0)
+ return res;
+ }
+ if (clp->oflag.mmap) {
+ res = get_mmap_addr(clp->outfd, num_bytes, &clp->out_mmapp);
+ if (res < 0)
+ return res;
+ }
+ }
+ for (k = 0; k < sgq_num_elems - 1; ++k)
+ clp->elem[k].nextp = &clp->elem[k + 1];
+ clp->elem[sgq_num_elems - 1].nextp = &clp->elem[0];
+ for (k = 0; k < sgq_num_elems; ++k) {
+ rep = &clp->elem[k];
+ rep->state = SGQ_FREE;
+ rep->iflagp = &clp->iflag;
+ rep->oflagp = &clp->oflag;
+ if (either_mmap) {
+ if (clp->both_mmap)
+ continue;
+ if (clp->iflag.mmap)
+ rep->buffp = clp->in_mmapp;
+ else
+ rep->buffp = clp->out_mmapp;
+ continue;
+ }
+ rep->buffp = sg_memalign(num_bytes, 0, &rep->free_buffp, false);
+ if (NULL == rep->buffp) {
+ pr2serr("out of memory creating user buffers\n");
+ res = -ENOMEM;
+ }
+ }
+ return res;
+}
+
+static void
+remove_elems(Rq_coll * clp)
+{
+ Rq_elem * rep;
+ int k;
+
+ for (k = 0; k < sgq_num_elems; ++k) {
+ rep = &clp->elem[k];
+ if (rep->free_buffp)
+ free(rep->free_buffp);
+ }
+}
+
+static int
+start_read(Rq_coll * clp)
+{
+ int blocks = (clp->in_count > clp->bpt) ? clp->bpt : clp->in_count;
+ Rq_elem * rep = clp->rd_posp;
+ int buf_sz, res;
+ char ebuff[EBUFF_SZ];
+
+ if (clp->debug > 5)
+ pr2serr("%s: elem idx=%zd\n", __func__, rep - clp->elem);
+ rep->wr = false;
+ rep->blk = clp->in_blk;
+ rep->num_blks = blocks;
+ clp->in_blk += blocks;
+ clp->in_count -= blocks;
+ if (clp->in_is_sg) {
+ res = sg_start_io(clp, rep);
+ if (1 == res) { /* ENOMEM, find what's available+try that */
+ if (ioctl(clp->infd, SG_GET_RESERVED_SIZE, &buf_sz) < 0) {
+ res = -errno;
+ perror("RESERVED_SIZE ioctls failed");
+ return res;
+ }
+ clp->bpt = (buf_sz + clp->bs - 1) / clp->bs;
+ pr2serr("Reducing blocks per transfer to %d\n", clp->bpt);
+ if (clp->bpt < 1)
+ return -ENOMEM;
+ res = sg_start_io(clp, rep);
+ if (1 == res)
+ res = -ENOMEM;
+ }
+ if (res < 0) {
+ pr2serr("%s: inputting from sg failed, blk=%d\n", my_name,
+ rep->blk);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ }
+ else {
+ rep->state = SGQ_IO_STARTED;
+ while (((res = read(clp->infd, rep->buffp, blocks * clp->bs)) < 0) &&
+ (EINTR == errno))
+ ;
+ if (res < 0) {
+ res = -errno;
+ snprintf(ebuff, EBUFF_SZ, "%s: reading, in_blk=%d ", my_name,
+ rep->blk);
+ perror(ebuff);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ if (res < blocks * clp->bs) {
+ int o_blocks = blocks;
+ rep->stop_after_wr = true;
+ blocks = res / clp->bs;
+ if ((res % clp->bs) > 0) {
+ blocks++;
+ clp->in_partial++;
+ }
+ /* Reverse out + re-apply blocks on clp */
+ clp->in_blk -= o_blocks;
+ clp->in_count += o_blocks;
+ rep->num_blks = blocks;
+ clp->in_blk += blocks;
+ clp->in_count -= blocks;
+ }
+ clp->in_done_count -= blocks;
+ rep->state = SGQ_IO_FINISHED;
+ }
+ clp->rd_posp = rep->nextp;
+ return blocks;
+}
+
+static int
+start_write(Rq_coll * clp)
+{
+ Rq_elem * rep = clp->wr_posp;
+ int res, blocks;
+ char ebuff[EBUFF_SZ];
+
+ while ((0 != rep->wr) || (SGQ_IO_FINISHED != rep->state)) {
+ rep = rep->nextp;
+ if (rep == clp->rd_posp)
+ return -1;
+ }
+ if (clp->debug > 5)
+ pr2serr("%s: elem idx=%zd\n", __func__, rep - clp->elem);
+ rep->wr = true;
+ blocks = rep->num_blks;
+ rep->blk = clp->out_blk;
+ clp->out_blk += blocks;
+ clp->out_count -= blocks;
+ if (clp->out_is_sg) {
+ res = sg_start_io(clp, rep);
+ if (1 == res) /* ENOMEM, give up */
+ return -ENOMEM;
+ else if (res < 0) {
+ pr2serr("%s: output to sg failed, blk=%d\n", my_name, rep->blk);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ }
+ else {
+ rep->state = SGQ_IO_STARTED;
+ while (((res = write(clp->outfd, rep->buffp,
+ rep->num_blks * clp->bs)) < 0) && (EINTR == errno))
+ ;
+ if (res < 0) {
+ res = -errno;
+ snprintf(ebuff, EBUFF_SZ, "%s: output, out_blk=%d ", my_name,
+ rep->blk);
+ perror(ebuff);
+ rep->state = SGQ_IO_ERR;
+ return res;
+ }
+ if (res < blocks * clp->bs) {
+ blocks = res / clp->bs;
+ if ((res % clp->bs) > 0) {
+ blocks++;
+ clp->out_partial++;
+ }
+ rep->num_blks = blocks;
+ }
+ rep->state = SGQ_IO_FINISHED;
+ }
+ return blocks;
+}
+
+/* Returns 0 if SIGIO/SIGPOLL or (SIGRTMIN + 1) received, else returns negated
+ * errno value; -EAGAIN for timeout. */
+static int
+do_sigwait(Rq_coll * clp, bool inc1_clear0)
+{
+ siginfo_t info;
+ struct timespec ts;
+
+ if (clp->debug > 9)
+ pr2serr("%s: inc1_clear0=%d\n", __func__, (int)inc1_clear0);
+ ts.tv_sec = 0;
+ ts.tv_nsec = DEF_SIGTIMEDWAIT_USEC * 1000;
+ while (sigtimedwait(&clp->blocked_sigs, &info, &ts) < 0) {
+ int err = errno;
+
+ if (EINTR != err) {
+
+ if (EAGAIN != err)
+ pr2serr("%s: sigtimedwait(): %s [%d]\n", __func__,
+ strerror(err), err);
+ return -err; /* EAGAIN is timeout error */
+ }
+ }
+ if ((SIGRTMIN + 1) == info.si_signo) {
+ if (inc1_clear0) {
+ clp->sigs_waiting--;
+ clp->sigs_rt_received++;
+ } else
+ clp->sigs_waiting = 0;
+ } else if (SIGPOLL == info.si_signo) {
+ if (inc1_clear0) {
+ clp->sigs_waiting--;
+ clp->sigs_io_received++;
+ } else
+ clp->sigs_waiting = 0;
+ } else {
+ pr2serr("%s: sigwaitinfo() returned si_signo=%d\n",
+ __func__, info.si_signo);
+ return -EINVAL;
+ }
+ return 0;
+}
+
+/* Returns 1 (or more) on success (found), 0 on not found, -1 on error. */
+static int
+do_num_poll_in(Rq_coll * clp, int fd, bool is_evfd)
+{
+ int err, res;
+ struct pollfd a_pollfd = {0, POLLIN | POLLOUT, 0};
+
+ if (! clp->no_sig) {
+ if (clp->sigs_waiting) {
+ int res = do_sigwait(clp, true);
+
+ if ((res < 0) && (-EAGAIN != res))
+ return res;
+ }
+ }
+ a_pollfd.fd = fd;
+ if (poll(&a_pollfd, 1, clp->poll_ms) < 0) {
+ err = errno;
+ pr2serr("%s: poll(): %s [%d]\n", __func__, strerror(err), err);
+ return -err;
+ }
+ /* pr2serr("%s: revents=0x%x\n", __func__, a_pollfd.revents); */
+ if (a_pollfd.revents & POLLIN) {
+ if (is_evfd) {
+ uint64_t count;
+
+ if ((res = read(fd, &count, sizeof(count))) < 0) {
+ err = errno;
+ pr2serr("%s: read(): %s [%d]\n", __func__,
+ strerror(err), err);
+ return -err;
+ }
+ return (res < (int)sizeof(uint64_t)) ? 0 : (int)count;
+ } else
+ return 1; /* could be more but don't know without evfd */
+ } else if (a_pollfd.revents & POLLERR)
+ ++clp->pollerr_count;
+
+ return 0;
+}
+
+static int
+can_read_write(Rq_coll * clp)
+{
+ Rq_elem * rep = NULL;
+ bool writeable = false;
+ bool in_is_evfd = (clp->in_evfd >= 0);
+ bool out_is_evfd = (clp->out_evfd >= 0);
+ int res = 0;
+ int reading = 0;
+ int writing = 0;
+ int rd_waiting = 0;
+ int wr_waiting = 0;
+ int sg_finished = 0;
+ int num;
+ int ofd = out_is_evfd ? clp->out_evfd : clp->outfd;
+ int ifd= in_is_evfd ? clp->in_evfd : clp->infd;
+
+ /* if write completion pending, then complete it + start read */
+ if (clp->out_is_sg) {
+ while ((res = do_num_poll_in(clp, ofd, out_is_evfd))) {
+ if (res < 0)
+ return res;
+ num = res;
+ while (--num >= 0) {
+ res = sg_finish_io(clp, true /* write */, &rep);
+ if (res < 0)
+ return res;
+ else if (1 == res) {
+ res = sg_start_io(clp, rep);
+ if (0 != res)
+ return -1; /* give up if any problems with retry */
+ } else
+ sg_finished++;
+ }
+ }
+ while ((rep = clp->wr_posp) && (SGQ_IO_FINISHED == rep->state) &&
+ rep->wr && (rep != clp->rd_posp)) {
+ rep->state = SGQ_FREE;
+ clp->out_done_count -= rep->num_blks;
+ clp->wr_posp = rep->nextp;
+ if (rep->stop_after_wr)
+ return -1;
+ }
+ }
+ else if ((rep = clp->wr_posp) && rep->wr &&
+ (SGQ_IO_FINISHED == rep->state)) {
+ rep->state = SGQ_FREE;
+ clp->out_done_count -= rep->num_blks;
+ clp->wr_posp = rep->nextp;
+ if (rep->stop_after_wr)
+ return -1;
+ }
+
+ /* if read completion pending, then complete it + start maybe write */
+ if (clp->in_is_sg) {
+ while ((res = do_num_poll_in(clp, ifd, in_is_evfd))) {
+ if (res < 0)
+ return res;
+ num = res;
+ while (--num >= 0) {
+ res = sg_finish_io(clp, false /* read */, &rep);
+ if (res < 0)
+ return res;
+ if (1 == res) {
+ res = sg_start_io(clp, rep);
+ if (0 != res)
+ return -1; /* give up if any problems with retry */
+ } else {
+ sg_finished++;
+ clp->in_done_count -= rep->num_blks;
+ }
+ }
+ }
+ }
+
+ for (rep = clp->wr_posp, res = 1;
+ rep && (rep != clp->rd_posp); rep = rep->nextp) {
+ if (SGQ_IO_STARTED == rep->state) {
+ if (rep->wr)
+ ++writing;
+ else {
+ res = 0;
+ ++reading;
+ }
+ }
+ else if ((! rep->wr) && (SGQ_IO_FINISHED == rep->state)) {
+ if (res)
+ writeable = true;
+ }
+ else if (SGQ_IO_WAIT == rep->state) {
+ res = 0;
+ if (rep->wr)
+ ++wr_waiting;
+ else
+ ++rd_waiting;
+ }
+ else
+ res = 0;
+ }
+ if (clp->debug > 6) {
+ if ((clp->debug > 7) || wr_waiting || rd_waiting) {
+ pr2serr("%d/%d (nwb/nrb): read=%d/%d (do/wt) "
+ "write=%d/%d (do/wt) writeable=%d sg_fin=%d\n",
+ clp->out_blk, clp->in_blk, reading, rd_waiting,
+ writing, wr_waiting, (int)writeable, sg_finished);
+ }
+ // fflush(stdout);
+ }
+ if (writeable && (writing < sgq_wr_ahead_lim) && (clp->out_count > 0))
+ return SGQ_CAN_WRITE;
+ if ((reading < sgq_rd_ahead_lim) && (clp->in_count > 0) &&
+ (0 == rd_waiting) && (clp->rd_posp->nextp != clp->wr_posp))
+ return SGQ_CAN_READ;
+
+ if (clp->out_done_count <= 0)
+ return SGQ_CAN_DO_NOTHING;
+
+ /* usleep(10000); */ /* hang about for 10 milliseconds */
+ if ((! clp->no_sig) && clp->sigs_waiting) {
+ res = do_sigwait(clp, false);
+ if ((res < 0) && (-EAGAIN != res))
+ return res; /* wasn't timeout */
+ }
+ /* Now check the _whole_ buffer for pending requests */
+ for (rep = clp->rd_posp->nextp; rep && (rep != clp->rd_posp);
+ rep = rep->nextp) {
+ if (SGQ_IO_WAIT == rep->state) {
+ res = sg_start_io(clp, rep);
+ if (res < 0)
+ return res;
+ if (res > 0)
+ return -1;
+ break;
+ }
+ }
+ return SGQ_CAN_DO_NOTHING;
+}
+
+static bool
+process_flags(const char * arg, struct flags_t * fp)
+{
+ char buff[256];
+ char * cp;
+ char * np;
+
+ strncpy(buff, arg, sizeof(buff));
+ buff[sizeof(buff) - 1] = '\0';
+ if ('\0' == buff[0]) {
+ pr2serr("no flag found, 'null' can be used as a placeholder\n");
+ return false;
+ }
+ cp = buff;
+ do {
+ np = strchr(cp, ',');
+ if (np)
+ *np++ = '\0';
+ if (0 == strcmp(cp, "dio"))
+ fp->dio = true;
+ else if (0 == strcmp(cp, "evfd"))
+ fp->evfd = true;
+ else if (0 == strcmp(cp, "excl"))
+ fp->excl = true;
+ else if (0 == strcmp(cp, "hipri"))
+ fp->polled = true;
+ else if (0 == strcmp(cp, "immed"))
+ fp->immed = true;
+ else if (0 == strcmp(cp, "mmap"))
+ fp->mmap = true;
+ else if (0 == strcmp(cp, "noxfer"))
+ fp->noxfer = true;
+ else if (0 == strcmp(cp, "null"))
+ ;
+ else if (0 == strcmp(cp, "pack"))
+ fp->pack = true;
+ else if (0 == strcmp(cp, "polled"))
+ fp->polled = true;
+ else if (0 == strcmp(cp, "tag"))
+ fp->tag = true;
+ else if (0 == strcmp(cp, "v3")) {
+ fp->v3 = true;
+ fp->v4 = false;
+ fp->given_v3v4 = true;
+ } else if (0 == strcmp(cp, "v4")) {
+ fp->v3 = false;
+ fp->v4 = true;
+ fp->given_v3v4 = true;
+ } else {
+ pr2serr("unrecognised flag: %s\n", cp);
+ return false;
+ }
+ cp = np;
+ } while (cp);
+ if (fp->dio && fp->mmap) {
+ pr2serr(" Can't set both mmap and dio\n");
+ return false;
+ }
+ if ((fp->dio || fp->mmap) && fp->noxfer) {
+ pr2serr(" Can't have mmap or dio with noxfer\n");
+ return false;
+ }
+ return true;
+}
+
+
+int
+main(int argc, char * argv[])
+{
+ bool bs_given = false;
+ bool no_sig_given = false;
+ bool polled_present;
+ int skip = 0;
+ int seek = 0;
+ int ibs = 0;
+ int obs = 0;
+ int count = -1;
+ int in_num_sect = 0;
+ int out_num_sect = 0;
+ int help_pg = 0;
+ int res, k, in_sect_sz, out_sect_sz, crw, open_fl;
+ char str[STR_SZ];
+ char * key;
+ char * buf;
+ char inf[INOUTF_SZ];
+ char outf[INOUTF_SZ];
+ char ebuff[EBUFF_SZ];
+ Rq_coll rcoll;
+ Rq_coll * clp = &rcoll;
+
+ memset(clp, 0, sizeof(*clp));
+ clp->bpt = 0;
+ clp->in_evfd = -1;
+ clp->out_evfd = -1;
+ clp->iflag.v3 = true;
+ clp->oflag.v3 = true;
+ inf[0] = '\0';
+ outf[0] = '\0';
+ if (argc < 2) {
+ usage(1);
+ return 1;
+ }
+ sgs_nanosec_unit = !!getenv("SG3_UTILS_LINUX_NANO");
+
+ for(k = 1; k < argc; k++) {
+ if (argv[k]) {
+ strncpy(str, argv[k], STR_SZ);
+ str[STR_SZ - 1] = '\0';
+ }
+ else
+ continue;
+ for(key = str, buf = key; *buf && *buf != '=';)
+ buf++;
+ if (*buf)
+ *buf++ = '\0';
+ if (0 == strcmp(key,"bpt")) {
+ clp->bpt = sg_get_num(buf);
+ if ((clp->bpt < 0) || (clp->bpt > MAX_BPT_VALUE)) {
+ pr2serr("%s: bad argument to 'bpt='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"bs")) {
+ clp->bs = sg_get_num(buf);
+ if ((clp->bs < 0) || (clp->bs > MAX_BPT_VALUE)) {
+ pr2serr("%s: bad argument to 'bs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"count")) {
+ count = sg_get_num(buf);
+ if (count < 0) {
+ pr2serr("%s: bad argument to 'count='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"deb"))
+ clp->debug += sg_get_num(buf);
+ else if (0 == strcmp(key,"ibs")) {
+ ibs = sg_get_num(buf);
+ if ((ibs < 0) || (ibs > MAX_BPT_VALUE)) {
+ pr2serr("%s: bad argument to 'ibs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (strcmp(key,"if") == 0) {
+ memcpy(inf, buf, INOUTF_SZ);
+ inf[INOUTF_SZ - 1] = '\0';
+ } else if (0 == strcmp(key, "iflag")) {
+ if (! process_flags(buf, &clp->iflag)) {
+ pr2serr("%s: bad argument to 'iflag='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (strcmp(key,"mrq") == 0)
+ ; /* do nothing */
+ else if (0 == strcmp(key,"no_sig")) { /* default changes */
+ clp->no_sig = !!sg_get_num(buf);
+ no_sig_given = true;
+ } else if (0 == strcmp(key,"obs")) {
+ obs = sg_get_num(buf);
+ if ((obs < 0) || (obs > MAX_BPT_VALUE)) {
+ pr2serr("%s: bad argument to 'obs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (strcmp(key,"of") == 0) {
+ memcpy(outf, buf, INOUTF_SZ);
+ outf[INOUTF_SZ - 1] = '\0';
+ } else if (0 == strcmp(key, "oflag")) {
+ if (! process_flags(buf, &clp->oflag)) {
+ pr2serr("%s: bad argument to 'oflag='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"poll_ms"))
+ clp->poll_ms = sg_get_num(buf);
+ else if (0 == strcmp(key,"rt_sig"))
+ clp->use_rt_sig = !!sg_get_num(buf);
+ else if (0 == strcmp(key,"seek")) {
+ seek = sg_get_num(buf);
+ if (seek < 0) {
+ pr2serr("%s: bad argument to 'seek='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"skip")) {
+ skip = sg_get_num(buf);
+ if (skip < 0) {
+ pr2serr("%s: bad argument to 'skip='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"time"))
+ ; /* do nothing */
+ else if ((0 == strcmp(key,"-V")) || (0 == strcmp(key,"--version"))) {
+ pr2serr("%s: version: %s\n", my_name, version_str);
+ return 0;
+ } else if (0 == strncmp(key,"-vvvvvvv", 8))
+ clp->debug += 7;
+ else if (0 == strncmp(key,"-vvvvvv", 7))
+ clp->debug += 6;
+ else if (0 == strncmp(key,"-vvvvv", 6))
+ clp->debug += 5;
+ else if (0 == strncmp(key,"-vvvv", 5))
+ clp->debug += 4;
+ else if (0 == strncmp(key,"-vvv", 4))
+ clp->debug += 3;
+ else if (0 == strncmp(key,"-vv", 3))
+ clp->debug += 2;
+ else if ((0 == strcmp(key,"--verbose")) || (0 == strncmp(key,"-v", 2)))
+ ++clp->debug;
+ else if (0 == strcmp(key,"-hhhh"))
+ help_pg += 4;
+ else if (0 == strcmp(key,"-hhh"))
+ help_pg += 3;
+ else if (0 == strcmp(key,"-hh"))
+ help_pg += 2;
+ else if ((0 == strcmp(key,"-h")) || (0 == strcmp(key,"--help")))
+ ++help_pg;
+ else {
+ pr2serr("Unrecognized argument '%s'\n", key);
+ usage(help_pg);
+ return 1;
+ }
+ }
+ if (clp->bs <= 0) {
+ clp->bs = DEF_BLOCK_SIZE;
+ } else
+ bs_given = true;
+
+ if (help_pg > 0) {
+ usage(help_pg);
+ return 0;
+ }
+
+ polled_present = (clp->iflag.polled || clp->oflag.polled);
+ if (no_sig_given) {
+ if ((0 == clp->no_sig) && polled_present)
+ pr2serr("Warning: signalling doesn't work with polled flag\n");
+ } else /* no_sig default varies: 0 normally and 1 if polled present */
+ clp->no_sig = polled_present ? 1 : 0;
+
+ if ((ibs && (ibs != clp->bs)) || (obs && (obs != clp->bs))) {
+ pr2serr("If 'ibs' or 'obs' given must be same as 'bs'\n");
+ usage(1);
+ return 1;
+ }
+ if (clp->bpt <= 0) {
+ clp->bpt = (DEF_BPT_TIMES_BS_SZ / clp->bs);
+ if (0 == clp->bpt)
+ clp->bpt = 1;
+ if (! bs_given)
+ pr2serr("Assume blocks size bs=%d [bytes] and blocks "
+ "per transfer bpt=%d\n", clp->bs, clp->bpt);
+ } else if (! bs_given)
+ pr2serr("Assume 'bs' (block size) of %d bytes\n", clp->bs);
+
+ if ((skip < 0) || (seek < 0)) {
+ pr2serr("%s: skip and seek cannot be negative\n", my_name);
+ return 1;
+ }
+ if (clp->iflag.mmap && clp->oflag.mmap)
+ clp->both_mmap = true;
+
+ if (clp->debug > 3)
+ pr2serr("%s: if=%s skip=%d of=%s seek=%d count=%d\n", my_name,
+ inf, skip, outf, seek, count);
+ if (! clp->no_sig) {
+ /* Need to block signals before SIGPOLL is enabled in sz_reserve() */
+ sigemptyset(&clp->blocked_sigs);
+ if (clp->use_rt_sig)
+ sigaddset(&clp->blocked_sigs, SIGRTMIN + 1);
+ sigaddset(&clp->blocked_sigs, SIGINT);
+ sigaddset(&clp->blocked_sigs, SIGPOLL);
+ sigprocmask(SIG_BLOCK, &clp->blocked_sigs, 0);
+ }
+
+ clp->infd = STDIN_FILENO;
+ clp->outfd = STDOUT_FILENO;
+ if (inf[0] && ('-' != inf[0])) {
+ open_fl = clp->iflag.excl ? O_EXCL : 0;
+ if ((clp->infd = open(inf, open_fl | O_RDONLY)) < 0) {
+ snprintf(ebuff, EBUFF_SZ, "%s: could not open %s for reading",
+ my_name, inf);
+ perror(ebuff);
+ return 1;
+ }
+ if (ioctl(clp->infd, SG_GET_TIMEOUT, 0) < 0) {
+ clp->in_is_sg = false;
+ if (skip > 0) {
+ off_t offset = skip;
+
+ offset *= clp->bs; /* could overflow here! */
+ if (lseek(clp->infd, offset, SEEK_SET) < 0) {
+ snprintf(ebuff, EBUFF_SZ, "%s: couldn't skip to required "
+ "position on %s", my_name, inf);
+ perror(ebuff);
+ return 1;
+ }
+ }
+ } else { /* looks like sg device so close then re-open it RW */
+ close(clp->infd);
+ open_fl = clp->iflag.excl ? O_EXCL : 0;
+ open_fl |= (O_RDWR | O_NONBLOCK);
+ if ((clp->infd = open(inf, open_fl)) < 0) {
+ pr2serr("If %s is a sg device, need read+write "
+ "permissions, even to read it!\n", inf);
+ return 1;
+ }
+ clp->in_is_sg = true;
+ if (sz_reserve(clp, true /* is_in */))
+ return 1;
+ if (sgs_old_sg_driver && (clp->iflag.v4 || clp->oflag.v4)) {
+ pr2serr("Unable to implement v4 flag because sg driver too "
+ "old\n");
+ return 1;
+ }
+ }
+ }
+ if (outf[0] && ('-' != outf[0])) {
+ open_fl = clp->oflag.excl ? O_EXCL : 0;
+ open_fl |= (O_RDWR | O_NONBLOCK);
+ if ((clp->outfd = open(outf, open_fl)) >= 0) {
+ if (ioctl(clp->outfd, SG_GET_TIMEOUT, 0) < 0) {
+ /* not a scsi generic device so now try and open RDONLY */
+ close(clp->outfd);
+ clp->outfd = -1;
+ }
+ else {
+ clp->out_is_sg = true;
+ if (sz_reserve(clp, false /* hence ! is_in */))
+ return 1;
+ if (sgs_old_sg_driver && (clp->iflag.v4 || clp->oflag.v4)) {
+ pr2serr("Unable to implement v4 flag because sg driver "
+ "too old\n");
+ return 1;
+ }
+ }
+ }
+ if (! clp->out_is_sg) {
+ if (clp->outfd >= 0) {
+ close(clp->outfd);
+ clp->outfd = -1;
+ }
+ open_fl = clp->oflag.excl ? O_EXCL : 0;
+ open_fl |= (O_WRONLY | O_CREAT);
+ if ((clp->outfd = open(outf, open_fl, 0666)) < 0) {
+ snprintf(ebuff, EBUFF_SZ,
+ "%s: could not open %s for writing", my_name, outf);
+ perror(ebuff);
+ return 1;
+ }
+ else if (seek > 0) {
+ off_t offset = seek;
+
+ offset *= clp->bs; /* could overflow here! */
+ if (lseek(clp->outfd, offset, SEEK_SET) < 0) {
+ snprintf(ebuff, EBUFF_SZ, "%s: couldn't seek to required "
+ "position on %s", my_name, outf);
+ perror(ebuff);
+ return 1;
+ }
+ }
+ }
+ } else if ('\0' == outf[0]) {
+ if (STDIN_FILENO == clp->infd) {
+ pr2serr("Can't have both 'if' as stdin _and_ 'of' as "
+ "/dev/null\n");
+ return 1;
+ }
+ clp->outfd = open("/dev/null", O_RDWR);
+ if (clp->outfd < 0) {
+ perror("sgs_dd: could not open /dev/null");
+ return 1;
+ }
+ clp->out_is_sg = false;
+ /* ignore any seek */
+ } else { /* must be '-' for stdout */
+ if (STDIN_FILENO == clp->infd) {
+ pr2serr("Can't have both 'if' as stdin _and_ 'of' as stdout\n");
+ return 1;
+ }
+ }
+ if ((clp->in_is_sg || clp->out_is_sg) && !clp->iflag.given_v3v4 &&
+ !clp->oflag.given_v3v4 && (clp->debug > 0)) {
+ clp->iflag.v3 = true;
+ pr2serr("using sg driver version 3 interface on %s\n",
+ clp->in_is_sg ? inf : outf);
+ }
+
+ if (0 == count)
+ return 0;
+ else if (count < 0) {
+ if (clp->in_is_sg) {
+ res = read_capacity(clp->infd, &in_num_sect, &in_sect_sz);
+ if (2 == res) {
+ pr2serr("Unit attention, media changed(in), try again\n");
+ res = read_capacity(clp->infd, &in_num_sect, &in_sect_sz);
+ }
+ if (0 != res) {
+ pr2serr("Unable to read capacity on %s\n", inf);
+ in_num_sect = -1;
+ } else {
+ if (clp->debug > 4)
+ pr2serr("ifile: number of sectors=%d, sector size=%d\n",
+ in_num_sect, in_sect_sz);
+ if (in_num_sect > skip)
+ in_num_sect -= skip;
+ }
+ }
+ if (clp->out_is_sg) {
+ res = read_capacity(clp->outfd, &out_num_sect, &out_sect_sz);
+ if (2 == res) {
+ pr2serr("Unit attention, media changed(out), try again\n");
+ res = read_capacity(clp->outfd, &out_num_sect, &out_sect_sz);
+ }
+ if (0 != res) {
+ pr2serr("Unable to read capacity on %s\n", outf);
+ out_num_sect = -1;
+ } else {
+ if (clp->debug > 4)
+ pr2serr("ofile: number of sectors=%d, sector size=%d\n",
+ out_num_sect, out_sect_sz);
+ if (out_num_sect > seek)
+ out_num_sect -= seek;
+ }
+ }
+ if (clp->debug > 3)
+ pr2serr("Start of loop, count=%d, in_num_sect=%d, "
+ "out_num_sect=%d\n", count, in_num_sect, out_num_sect);
+ if (in_num_sect > 0) {
+ if (out_num_sect > 0)
+ count = (in_num_sect > out_num_sect) ? out_num_sect :
+ in_num_sect;
+ else
+ count = in_num_sect;
+ }
+ else
+ count = out_num_sect;
+ }
+ if (clp->debug > 4)
+ pr2serr("Start of loop, count=%d, bpt=%d\n", count, clp->bpt);
+
+ clp->in_count = count;
+ clp->in_done_count = count;
+ clp->in_blk = skip;
+ clp->out_count = count;
+ clp->out_done_count = count;
+ clp->out_blk = seek;
+ res = init_elems(clp);
+ if (res < 0)
+ pr2serr("init_elems() failed, res=%d\n", res);
+ res = 0;
+
+/* vvvvvvvvvvvvvvvvv Main Loop vvvvvvvvvvvvvvvvvvvvvvvv */
+ while (clp->out_done_count > 0) {
+ crw = can_read_write(clp);
+ if (crw < 0)
+ break;
+ if (SGQ_CAN_READ & crw) {
+ res = start_read(clp);
+ if (res <= 0) {
+ pr2serr("start_read: res=%d\n", res);
+ break;
+ }
+ res = 0;
+ }
+ if (SGQ_CAN_WRITE & crw) {
+ res = start_write(clp);
+ if (res <= 0) {
+ pr2serr("start_write: res=%d\n", res);
+ break;
+ }
+ res = 0;
+ }
+ }
+
+ if ((STDIN_FILENO != clp->infd) && (clp->infd >= 0))
+ close(clp->infd);
+ if ((STDOUT_FILENO != clp->outfd) && (clp->outfd >= 0))
+ close(clp->outfd);
+ if (0 != clp->out_count) {
+ pr2serr("Some error occurred, remaining blocks=%d\n", clp->out_count);
+ res = 1;
+ }
+ pr2serr("%d+%d records in\n", count - clp->in_done_count,
+ clp->in_partial);
+ pr2serr("%d+%d records out\n", count - clp->out_done_count,
+ clp->out_partial);
+ if (clp->dio_incomplete)
+ pr2serr(">> Direct IO requested but incomplete %d times\n",
+ clp->dio_incomplete);
+ if (clp->sum_of_resids)
+ pr2serr(">> Non-zero sum of residual counts=%d\n",
+ clp->sum_of_resids);
+ if (clp->debug > 0) {
+ if (! clp->no_sig)
+ pr2serr("SIGIO/SIGPOLL signals received: %d, RT sigs: %d\n",
+ clp->sigs_io_received, clp->sigs_rt_received);
+ if (polled_present)
+ pr2serr("POLLED (blk_poll) used to complete %d commands\n",
+ clp->blk_poll_count);
+ }
+ if (clp->pollerr_count > 0)
+ pr2serr(">> poll() system call gave POLLERR %d times\n",
+ clp->pollerr_count);
+ remove_elems(clp);
+ return res < 0 ? 99 : res;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 13:30:26 +0000