diff options
Diffstat (limited to 'testing/sg_tst_async.cpp')
| -rw-r--r-- | testing/sg_tst_async.cpp | 2227 |
1 files changed, 2227 insertions, 0 deletions
diff --git a/testing/sg_tst_async.cpp b/testing/sg_tst_async.cpp new file mode 100644 index 00000000..8904e379 --- /dev/null +++ b/testing/sg_tst_async.cpp @@ -0,0 +1,2227 @@ +/* + * Copyright (c) 2014-2022 Douglas Gilbert. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +#include <iostream> +#include <vector> +#include <map> +#include <list> +#include <system_error> +#include <thread> +#include <mutex> +#include <chrono> +#include <atomic> +#include <random> + +#include <unistd.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#include <poll.h> +#include <errno.h> +#include <ctype.h> +#include <time.h> +#include <limits.h> +#include <getopt.h> +#define __STDC_FORMAT_MACROS 1 +#include <inttypes.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <sys/resource.h> /* getrusage */ + + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#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_io_linux.h" +#include "sg_unaligned.h" +#include "sg_pt.h" +#include "sg_cmds.h" + +static const char * version_str = "1.42 20220425"; +static const char * util_name = "sg_tst_async"; + +/* This is a test program for checking the async usage of the Linux sg + * driver. Each thread opens 1 file descriptor to the next sg device (1 + * or more can be given on the command line) and then starts up to + * num_per_thread commands or more while checking with the poll command (or + * ioctl(SG_GET_NUM_WAITING) ) for the completion of those commands. Each + * command has a unique "pack_id" which is a sequence starting at 1. + * Either TEST UNIT UNIT, READ(16) or WRITE(16) commands are issued. + * + * This is C++ code with some things from C++11 (e.g. threads) and was + * only just able to compile (when some things were reverted) with gcc/g++ + * version 4.7.3 found in Ubuntu 13.04 . C++11 "feature complete" support + * was not available until g++ version 4.8.1 . It should build okay on + * recent distributions. + * + * The build uses various object files from the <sg3_utils>/lib directory + * which is assumed to be a sibling of this examples directory. Those + * object files in the lib directory can be built with: + * cd <sg3_utils_package_root> ; ./configure ; cd lib; make + * cd ../testing + * make sg_tst_async + * + * Currently this utility is Linux only and uses the sg driver. The bsg + * driver is known to be broken (it doesn't match responses to the + * correct file descriptor that requested them). Around Linux kernel 4.15 + * the async capability of the bsg driver was removed. So this test code + * no longer appiles to the bsg driver. + * + * BEWARE: >>> This utility will modify a logical block (default LBA 1000) + * on the given device _when_ the '-W' option is given. + * + */ + +using namespace std; +using namespace std::chrono; + +#define DEF_NUM_PER_THREAD 1000 +#define DEF_NUM_THREADS 4 +#define DEF_WAIT_MS 10 /* 0: yield or no wait */ +#define DEF_NANOSEC_WAIT 25000 /* 25 microsecs */ +#define DEF_TIMEOUT_MS 20000 /* 20 seconds */ +#define DEF_LB_SZ 512 +#define DEF_BLOCKING 0 +#define DEF_DIRECT false /* true: direct_io */ +#define DEF_MMAP_IO false /* true: mmap-ed IO with sg */ +#define DEF_NO_XFER 0 +#define DEF_LBA 1000U + +#define MAX_Q_PER_FD 16383 /* sg driver per file descriptor limit */ +#define MAX_CONSEC_NOMEMS 4 /* was 16 */ +#define URANDOM_DEV "/dev/urandom" + +#ifndef SG_FLAG_Q_AT_TAIL +#define SG_FLAG_Q_AT_TAIL 0x10 +#endif +#ifndef SG_FLAG_Q_AT_HEAD +#define SG_FLAG_Q_AT_HEAD 0x20 +#endif + + +#define DEF_PT_TIMEOUT 60 /* 60 seconds */ + +#define EBUFF_SZ 256 + +static mutex console_mutex; +static mutex rand_lba_mutex; +static atomic<int> async_starts(0); +static atomic<int> sync_starts(0); +static atomic<int> async_finishes(0); +static atomic<int> start_ebusy_count(0); +static atomic<int> start_e2big_count(0); +static atomic<int> start_eagain_count(0); +static atomic<int> fin_eagain_count(0); +static atomic<int> fin_ebusy_count(0); +static atomic<int> start_edom_count(0); +static atomic<int> enomem_count(0); +static atomic<int> uniq_pack_id(1); +// static atomic<int> generic_errs(0); + +static int page_size = 4096; /* rough guess, will ask sysconf() */ + +enum command2execute {SCSI_TUR, SCSI_READ16, SCSI_WRITE16}; +/* Linux Block layer queue disciplines: */ +enum blkLQDiscipline {BLQ_DEFAULT, BLQ_AT_HEAD, BLQ_AT_TAIL}; +/* Queue disciplines of this utility. When both completions and + * queuing a new command are both possible: */ +enum myQDiscipline {MYQD_LOW, /* favour completions over new cmds */ + MYQD_MEDIUM, + MYQD_HIGH}; /* favour new cmds over completions */ + +struct opts_t { + vector<const char *> dev_names; + vector<int> blk_szs; + bool block; + bool cmd_time; + bool direct; + bool excl; + bool generic_sync; + bool masync; + bool mmap_io; + bool no_xfer; + bool pack_id_force; + bool sg_vn_ge_40000; + bool sg_vn_ge_40030; + bool submit; + bool verbose_given; + bool v3; + bool v3_given; + bool v4; + bool v4_given; + bool version_given; + int maxq_per_thread; + int num_per_thread; + uint64_t lba; + unsigned int hi_lba; /* last one, inclusive range */ + vector<unsigned int> hi_lbas; /* only used when hi_lba=-1 */ + int lb_sz; + int num_lbs; + int ovn; /* override number for submission */ + int stats; + int verbose; + int wait_ms; + command2execute c2e; + blkLQDiscipline blqd; /* --qat= 0|1 -> at_head|at_tail */ + myQDiscipline myqd; /* --qfav= value (def: 2 --> MYQD_HIGH) */ +}; + +static struct opts_t a_opts; /* Expect zero fill on simple types */ + +static int pr_rusage(int id); + +#if 0 +class Rand_uint { +public: + Rand_uint(unsigned int lo, unsigned int hi) : p{lo, hi} {} + unsigned int operator()() const { return r(); } +private: + uniform_int_distribution<unsigned int>::param_type p; + auto r = bind(uniform_int_distribution<unsigned int>{p}, + default_random_engine()); + /* compiler thinks auto should be a static, bs again? */ +}; +#endif + +#if 0 +class Rand_uint { +public: + Rand_uint(unsigned int lo, unsigned int hi, unsigned int my_seed) + : r(bind(uniform_int_distribution<unsigned int>{lo, hi}, + default_random_engine())) { r.seed(myseed); } + unsigned int operator()() const { return r(); } +private: + function<unsigned int()> r; +}; +#endif + +/* Use this class to wrap C++11 <random> features to produce uniform random + * unsigned ints in the range [lo, hi] (inclusive) given a_seed */ +class Rand_uint { +public: + Rand_uint(unsigned int lo, unsigned int hi, unsigned int a_seed) + : uid(lo, hi), dre(a_seed) { } + /* uid ctor takes inclusive range when integral type */ + + unsigned int get() { return uid(dre); } + +private: + uniform_int_distribution<unsigned int> uid; + default_random_engine dre; +}; + +static struct option long_options[] = { + {"v3", no_argument, 0, '3'}, + {"v4", no_argument, 0, '4'}, + {"more-async", no_argument, 0, 'a'}, + {"more_async", no_argument, 0, 'a'}, + {"masync", no_argument, 0, 'a'}, + {"cmd-time", no_argument, 0, 'c'}, + {"cmd_time", no_argument, 0, 'c'}, + {"direct", no_argument, 0, 'd'}, + {"excl", no_argument, 0, 'e'}, + {"force", no_argument, 0, 'f'}, + {"generic-sync", no_argument, 0, 'g'}, + {"generic_sync", no_argument, 0, 'g'}, + {"help", no_argument, 0, 'h'}, + {"lba", required_argument, 0, 'l'}, + {"lbsz", required_argument, 0, 'L'}, + {"maxqpt", required_argument, 0, 'M'}, + {"mmap-io", no_argument, 0, 'm'}, + {"mmap_io", no_argument, 0, 'm'}, + {"numpt", required_argument, 0, 'n'}, + {"num-pt", required_argument, 0, 'n'}, + {"num_pt", required_argument, 0, 'n'}, + {"noxfer", no_argument, 0, 'N'}, + {"override", required_argument, 0, 'O'}, + {"pack-id", no_argument, 0, 'p'}, + {"pack_id", no_argument, 0, 'p'}, + {"qat", required_argument, 0, 'q'}, + {"qfav", required_argument, 0, 'Q'}, + {"read", no_argument, 0, 'R'}, + {"stats", no_argument, 0, 'S'}, + {"submit", no_argument, 0, 'u'}, + {"szlb", required_argument, 0, 's'}, + {"tnum", required_argument, 0, 't'}, + {"tur", no_argument, 0, 'T'}, + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {"wait", required_argument, 0, 'w'}, + {"write", no_argument, 0, 'W'}, + {0, 0, 0, 0}, +}; + + +static void +usage(void) +{ + printf("Usage: %s [--cmd-time] [--direct] [--excl] [--force]\n" + " [--generic-sync] [--help] [--lba=LBA+] " + "[--lbsz=LBSZ]\n" + " [--masync] [--maxqpt=QPT] [--mmap-io] " + "[--no-waitq]\n" + " [--noxfer] [--numpt=NPT] [--override=OVN] " + "[--pack-id]\n" + " [--qat=AT] [-qfav=FAV] [--read] [--stats] " + "[--submit]\n" + " [--szlb=LB[,NLBS]] [--tnum=NT] [--tur] " + "[--v3] [--v4]\n" + " [--verbose] [--version] [--wait=MS] " + "[--write]\n" + " <sg_disk_device>*\n", + util_name); + printf(" where\n"); + printf(" --cmd-time|-c calculate per command average time (ns)\n"); + printf(" --direct|-d do direct_io (def: indirect)\n"); + printf(" --excl|-e do wait_exclusive calls\n"); + printf(" --force|-f force: any sg device (def: only scsi_debug " + "owned)\n"); + printf(" WARNING: <lba> written to if '-W' given\n"); + printf(" --generic-sync|-g use generic synchronous SG_IO ioctl " + "instead\n"); + printf(" of Linux sg driver assuming /dev/sg* " + "(def)\n"); + printf(" --help|-h print this usage message then exit\n"); + printf(" --lba=LBA|-l LBA logical block to access (def: %u)\n", + DEF_LBA); + printf(" --lba=LBA,HI_LBA|-l LBA,HI_LBA logical block range " + "(inclusive)\n" + " if hi_lba=-1 assume last block on " + "device\n"); + printf(" --lbsz=LBSZ|-L LBSZ logical block size in bytes (def: " + "512)\n" + " should be power of 2 (0 --> 512)\n"); + printf(" --masync|-a set 'more async' flag on devices\n"); + printf(" --maxqpt=QPT|-M QPT maximum commands queued per thread " + "(def:%d)\n", MAX_Q_PER_FD); + printf(" --mmap-io|-m mmap-ed IO (1 cmd outstanding per thread)\n"); + printf(" --noxfer|-N no data xfer (def: xfer on READ and " + "WRITE)\n"); + printf(" --numpt=NPT|-n NPT number of commands per thread " + "(def: %d)\n", DEF_NUM_PER_THREAD); + printf(" --override OVN|-O OVN override FAV=2 when OVN queue " + "depth\n" + " reached (def: 0 -> no override)\n"); + printf(" --pack-id|-p set FORCE_PACK_ID, pack-id input to " + "read/finish\n"); + printf(" --qat=AT|-q AT AT=0: q_at_head; AT=1: q_at_tail (def: " + "(drv): head)\n"); + printf(" --qfav=FAV|-Q FAV FAV=0: favour completions (smaller q),\n" + " FAV=1: medium,\n" + " FAV=2: favour submissions (larger q, " + "default)\n"); + printf(" --read|-R do READs (def: TUR)\n"); + printf(" --stats|-S show more statistics on completion\n"); + printf(" --submit|-u use SG_IOSUBMIT+SG_IORECEIVE instead of " + "write+read\n"); + printf(" --szlb=LB[,NLBS]| LB is logical block size (def: 512)\n"); + printf(" -s LB[,NLBS] NLBS is number of logical blocks (def: " + "1)\n"); + printf(" --tnum=NT|-t NT number of threads (def: %d)\n", + DEF_NUM_THREADS); + printf(" --tur|-T do TEST UNIT READYs (default is TURs)\n"); + printf(" --v3|-3 use sg v3 interface (def: v3 if driver < " + "3.9)\n"); + printf(" --v4|-4 use sg v4 interface (def if v4 driver). Sets " + "--submit\n"); + printf(" --verbose|-v increase verbosity\n"); + printf(" --version|-V print version number then exit\n"); + printf(" --wait=MS|-w MS >0: poll(<wait_ms>); =0: poll(0); (def: " + "%d)\n", DEF_WAIT_MS); + printf(" --write|-W do WRITEs (def: TUR)\n\n"); + printf("Multiple threads send READ(16), WRITE(16) or TEST UNIT READY " + "(TUR) SCSI\ncommands. There can be 1 or more <sg_disk_device>s " + "and each thread takes\nthe next in a round robin fashion. " + "Each thread queues up to NT commands.\nOne block is transferred " + "by each READ and WRITE; zeros are written. If a\nlogical block " + "range is given, a uniform distribution generates a pseudo\n" + "random sequence of LBAs. Set environment variable\n" + "SG3_UTILS_LINUX_NANO to get command timings in nanoseconds\n"); +} + +#ifdef __GNUC__ +static int pr2serr_lk(const char * fmt, ...) + __attribute__ ((format (printf, 1, 2))); +static void pr_errno_lk(int e_no, const char * fmt, ...) + __attribute__ ((format (printf, 2, 3))); +#else +static int pr2serr_lk(const char * fmt, ...); +static void pr_errno_lk(int e_no, const char * fmt, ...); +#endif + + +static int +pr2serr_lk(const char * fmt, ...) +{ + int n; + va_list args; + lock_guard<mutex> lg(console_mutex); + + va_start(args, fmt); + n = vfprintf(stderr, fmt, args); + va_end(args); + return n; +} + +static void +pr_errno_lk(int e_no, const char * fmt, ...) +{ + char b[160]; + va_list args; + lock_guard<mutex> lg(console_mutex); + + va_start(args, fmt); + vsnprintf(b, sizeof(b), fmt, args); + fprintf(stderr, "%s: %s\n", b, strerror(e_no)); + va_end(args); +} + +static unsigned int +get_urandom_uint(void) +{ + unsigned int res = 0; + lock_guard<mutex> lg(rand_lba_mutex); + + int fd = open(URANDOM_DEV, O_RDONLY); + if (fd >= 0) { + uint8_t b[sizeof(unsigned int)]; + int n = read(fd, b, sizeof(unsigned int)); + + if (sizeof(unsigned int) == n) + memcpy(&res, b, sizeof(unsigned int)); + close(fd); + } + return res; +} + +#define TUR_CMD_LEN 6 +#define READ16_CMD_LEN 16 +#define READ16_REPLY_LEN 4096 +#define WRITE16_REPLY_LEN 4096 +#define WRITE16_CMD_LEN 16 + +/* Returns 0 if command injected okay, return -1 for error and 2 for + * not done due to queue data size limit struck. */ +static int +start_sg3_cmd(int sg_fd, command2execute cmd2exe, int pack_id, uint64_t lba, + uint8_t * lbp, int xfer_bytes, int flags, bool submit, + unsigned int & enomem, unsigned int & eagains, + unsigned int & ebusy, unsigned int & e2big, unsigned int & edom) +{ + struct sg_io_hdr pt; + struct sg_io_v4 p4t; + uint8_t turCmdBlk[TUR_CMD_LEN] = {0, 0, 0, 0, 0, 0}; + uint8_t r16CmdBlk[READ16_CMD_LEN] = + {0x88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}; + uint8_t w16CmdBlk[WRITE16_CMD_LEN] = + {0x8a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}; + uint8_t sense_buffer[64] SG_C_CPP_ZERO_INIT; + const char * np = NULL; + struct sg_io_hdr * ptp; + + if (submit) { /* nest a v3 interface inside a store for v4 */ + memset(&p4t, 0, sizeof(p4t)); + ptp = (struct sg_io_hdr *)&p4t; /* p4t is larger than pt */ + } else { + ptp = &pt; + memset(ptp, 0, sizeof(*ptp)); + } + switch (cmd2exe) { + case SCSI_TUR: + np = "TEST UNIT READY"; + ptp->cmdp = turCmdBlk; + ptp->cmd_len = sizeof(turCmdBlk); + ptp->dxfer_direction = SG_DXFER_NONE; + break; + case SCSI_READ16: + np = "READ(16)"; + if (lba > 0xffffffff) + sg_put_unaligned_be32(lba >> 32, &r16CmdBlk[2]); + sg_put_unaligned_be32(lba & 0xffffffff, &r16CmdBlk[6]); + ptp->cmdp = r16CmdBlk; + ptp->cmd_len = sizeof(r16CmdBlk); + ptp->dxfer_direction = SG_DXFER_FROM_DEV; + ptp->dxferp = lbp; + ptp->dxfer_len = xfer_bytes; + break; + case SCSI_WRITE16: + np = "WRITE(16)"; + if (lba > 0xffffffff) + sg_put_unaligned_be32(lba >> 32, &w16CmdBlk[2]); + sg_put_unaligned_be32(lba & 0xffffffff, &w16CmdBlk[6]); + ptp->cmdp = w16CmdBlk; + ptp->cmd_len = sizeof(w16CmdBlk); + ptp->dxfer_direction = SG_DXFER_TO_DEV; + ptp->dxferp = lbp; + ptp->dxfer_len = xfer_bytes; + break; + } + ptp->interface_id = 'S'; + ptp->mx_sb_len = sizeof(sense_buffer); + ptp->sbp = sense_buffer; /* ignored .... */ + ptp->timeout = DEF_TIMEOUT_MS; + ptp->pack_id = pack_id; + ptp->flags = flags; + + for (int k = 0; + (submit ? ioctl(sg_fd, SG_IOSUBMIT_V3, ptp) : + write(sg_fd, ptp, sizeof(*ptp)) < 0); + ++k) { + if ((ENOMEM == errno) && (k < MAX_CONSEC_NOMEMS)) { + ++enomem; + this_thread::yield(); + continue; + } else if (EAGAIN == errno) { + ++eagains; + this_thread::yield(); + continue; + } else if (EBUSY == errno) { + ++ebusy; + this_thread::yield(); + continue; + } else if (E2BIG == errno) { + ++e2big; + return 2; + } else if (EDOM == errno) + ++edom; + else if (ENOMEM == errno) + pr_rusage(-1); + pr_errno_lk(errno, "%s: %s, pack_id=%d", __func__, np, pack_id); + return -1; + } + return 0; +} + +static int +finish_sg3_cmd(int sg_fd, command2execute cmd2exe, int & pack_id, + bool receive, int wait_ms, unsigned int & enomem, + unsigned int & eagains, unsigned int & ebusys, + unsigned int & nanosecs) +{ + bool ok; + int res, k; + uint8_t sense_buffer[64] SG_C_CPP_ZERO_INIT; + const char * np = NULL; + struct sg_io_hdr pt; + struct sg_io_hdr * ptp; + struct sg_io_v4 p4t; + + if (receive) { /* nest a v3 interface inside a store for v4 */ + memset(&p4t, 0, sizeof(p4t)); + ptp = (struct sg_io_hdr *)&p4t; /* p4t is larger than pt */ + } else { + ptp = &pt; + memset(ptp, 0, sizeof(*ptp)); + } + switch (cmd2exe) { + case SCSI_TUR: + np = "TEST UNIT READY"; + ptp->dxfer_direction = SG_DXFER_NONE; + break; + case SCSI_READ16: + np = "READ(16)"; + ptp->dxfer_direction = SG_DXFER_FROM_DEV; + break; + case SCSI_WRITE16: + np = "WRITE(16)"; + ptp->dxfer_direction = SG_DXFER_TO_DEV; + break; + } + ptp->interface_id = 'S'; + ptp->mx_sb_len = sizeof(sense_buffer); + ptp->sbp = sense_buffer; + ptp->timeout = DEF_TIMEOUT_MS; + /* if SG_SET_FORCE_PACK_ID, then need to set ptp->dxfer_direction */ + ptp->pack_id = pack_id; + + k = 0; + while ((((res = receive ? ioctl(sg_fd, SG_IORECEIVE_V3, ptp) : + read(sg_fd, ptp, sizeof(*ptp)))) < 0) && + ((EAGAIN == errno) || (EBUSY == errno) || (ENOMEM == errno))) { + if (ENOMEM == errno) + ++enomem; + else if (EAGAIN == errno) + ++eagains; + else + ++ebusys; + ++k; + if (k > 10000) { + pr2serr_lk("%s: sg_fd=%d: after %d EAGAINs, unable to find " + "pack_id=%d\n", __func__, sg_fd, k, pack_id); + return -1; /* crash out */ + } + if (wait_ms > 0) + this_thread::sleep_for(milliseconds{wait_ms}); + else if (0 == wait_ms) + this_thread::yield(); + else if (-2 == wait_ms) + sleep(0); // process yield ?? + } + if (res < 0) { + if (ENOMEM == errno) + pr_rusage(-1); + pr_errno_lk(errno, "%s: %s", __func__, np); + return -1; + } + /* now for the error processing */ + pack_id = ptp->pack_id; + ok = false; + switch (sg_err_category3(ptp)) { + case SG_LIB_CAT_CLEAN: + ok = true; + break; + case SG_LIB_CAT_RECOVERED: + pr2serr_lk("%s: Recovered error on %s, continuing\n", __func__, np); + ok = true; + break; + default: /* won't bother decoding other categories */ + { + lock_guard<mutex> lg(console_mutex); + sg_chk_n_print3(np, ptp, 1); + } + break; + } + if (ok) + nanosecs = ptp->duration; + return ok ? 0 : -1; +} + +/* Returns 0 if command injected okay, return -1 for error and 2 for + * not done due to queue data size limit struck. */ +static int +start_sg4_cmd(int sg_fd, command2execute cmd2exe, int pack_id, uint64_t lba, + uint8_t * lbp, int xfer_bytes, int flags, bool submit, + unsigned int & enomem, unsigned int & eagains, + unsigned int & ebusy, unsigned int & e2big, unsigned int & edom) +{ + struct sg_io_v4 p4t; + uint8_t turCmdBlk[TUR_CMD_LEN] = {0, 0, 0, 0, 0, 0}; + uint8_t r16CmdBlk[READ16_CMD_LEN] = + {0x88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}; + uint8_t w16CmdBlk[WRITE16_CMD_LEN] = + {0x8a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}; + uint8_t sense_buffer[64] SG_C_CPP_ZERO_INIT; + const char * np = NULL; + struct sg_io_v4 * ptp; + + if (! submit) { + pr2serr_lk("%s: logic error, submit must be true, isn't\n", __func__); + return -1; + } + ptp = &p4t; + memset(ptp, 0, sizeof(*ptp)); + switch (cmd2exe) { + case SCSI_TUR: + np = "TEST UNIT READY"; + ptp->request = (uint64_t)turCmdBlk; + ptp->request_len = sizeof(turCmdBlk); + break; + case SCSI_READ16: + np = "READ(16)"; + if (lba > 0xffffffff) + sg_put_unaligned_be32(lba >> 32, &r16CmdBlk[2]); + sg_put_unaligned_be32(lba & 0xffffffff, &r16CmdBlk[6]); + ptp->request = (uint64_t)r16CmdBlk; + ptp->request_len = sizeof(r16CmdBlk); + ptp->din_xferp = (uint64_t)lbp; + ptp->din_xfer_len = xfer_bytes; + break; + case SCSI_WRITE16: + np = "WRITE(16)"; + if (lba > 0xffffffff) + sg_put_unaligned_be32(lba >> 32, &w16CmdBlk[2]); + sg_put_unaligned_be32(lba & 0xffffffff, &w16CmdBlk[6]); + ptp->request = (uint64_t)w16CmdBlk; + ptp->request_len = sizeof(w16CmdBlk); + ptp->dout_xferp = (uint64_t)lbp; + ptp->dout_xfer_len = xfer_bytes; + break; + } + ptp->guard = 'Q'; + ptp->max_response_len = sizeof(sense_buffer); + ptp->response = (uint64_t)sense_buffer; /* ignored .... */ + ptp->timeout = DEF_TIMEOUT_MS; + ptp->request_extra = pack_id; + ptp->flags = flags; + + for (int k = 0; ioctl(sg_fd, SG_IOSUBMIT, ptp) < 0; ++k) { + if ((ENOMEM == errno) && (k < MAX_CONSEC_NOMEMS)) { + ++enomem; + this_thread::yield(); + continue; + } else if (EAGAIN == errno) { + ++eagains; + this_thread::yield(); + continue; + } else if (EBUSY == errno) { + ++ebusy; + this_thread::yield(); + continue; + } else if (E2BIG == errno) { + ++e2big; + return 2; + } else if (EDOM == errno) + ++edom; + else if (ENOMEM == errno) + pr_rusage(-1); + pr_errno_lk(errno, "%s: %s, pack_id=%d", __func__, np, pack_id); + return -1; + } + return 0; +} + +static int +finish_sg4_cmd(int sg_fd, command2execute cmd2exe, int & pack_id, + bool receive, int wait_ms, unsigned int & enomem, + unsigned int & eagains, unsigned int & ebusys, + unsigned int & nanosecs) +{ + bool ok; + int res, k; + uint8_t sense_buffer[64] SG_C_CPP_ZERO_INIT; + const char * np = NULL; + struct sg_io_v4 * ptp; + struct sg_io_v4 p4t; + + if (! receive) { + pr2serr_lk("%s: logic error, receive must be true, isn't\n", + __func__); + return -1; + } + ptp = &p4t; + memset(ptp, 0, sizeof(*ptp)); + switch (cmd2exe) { + case SCSI_TUR: + np = "TEST UNIT READY"; + break; + case SCSI_READ16: + np = "READ(16)"; + break; + case SCSI_WRITE16: + np = "WRITE(16)"; + break; + } + ptp->guard = 'Q'; + ptp->max_response_len = sizeof(sense_buffer); + ptp->response = (uint64_t)sense_buffer; + ptp->timeout = DEF_TIMEOUT_MS; + /* if SG_SET_FORCE_PACK_ID, then need to set ptp->dxfer_direction */ + ptp->request_extra = pack_id; + + k = 0; + while ((((res = ioctl(sg_fd, SG_IORECEIVE, ptp))) < 0) && + ((EAGAIN == errno) || (EBUSY == errno))) { + if (EAGAIN == errno) + ++eagains; + else + ++ebusys; + ++k; + if (k > 10000) { + pr2serr_lk("%s: sg_fd=%d: after %d EAGAINs, unable to find " + "pack_id=%d\n", __func__, sg_fd, k, pack_id); + return -1; /* crash out */ + } + if (wait_ms > 0) + this_thread::sleep_for(milliseconds{wait_ms}); + else if (0 == wait_ms) + this_thread::yield(); + else if (-2 == wait_ms) + sleep(0); // process yield ?? + } + if (res < 0) { + if (ENOMEM == errno) { + ++enomem; + pr_rusage(-1); + } + pr_errno_lk(errno, "%s: %s", __func__, np); + return -1; + } + /* now for the error processing */ + pack_id = ptp->request_extra; + ok = false; + res = sg_err_category_new(ptp->device_status, ptp->transport_status, + ptp->driver_status, + (const uint8_t *)ptp->response, + ptp->response_len); + switch (res) { + case SG_LIB_CAT_CLEAN: + ok = true; + break; + case SG_LIB_CAT_RECOVERED: + pr2serr_lk("%s: Recovered error on %s, continuing\n", __func__, np); + ok = true; + break; + default: /* won't bother decoding other categories */ + { + lock_guard<mutex> lg(console_mutex); + + sg_linux_sense_print(np, ptp->device_status, + ptp->transport_status, + ptp->driver_status, + (const uint8_t *)ptp->response, + ptp->response_len, true); + } + break; + } + if (ok) + nanosecs = ptp->duration; + return ok ? 0 : -1; +} + +static int +num_submitted(int sg_fd) +{ + uint32_t num_subm_wait = 0; + struct sg_extended_info sei; + struct sg_extended_info *seip = &sei; + const char * err = NULL; + + memset(seip, 0, sizeof(*seip)); + seip->sei_wr_mask |= SG_SEIM_READ_VAL; + seip->sei_rd_mask |= SG_SEIM_READ_VAL; + seip->read_value = SG_SEIRV_SUBMITTED; + if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) + err = "ioctl(SG_SET_GET_EXTENDED) failed\n"; + else + num_subm_wait = seip->read_value; + if (err) + pr2serr_lk("%s: %s, errno=%d\n", __func__, err, errno); + return err ? -1 : (int)num_subm_wait; +} + +static int +pr_rusage(int id) +{ + int res; + struct rusage ru; + + res = getrusage(RUSAGE_SELF /* RUSAGE_THREAD */, &ru); + if (res < 0) { + pr2serr_lk("%d->id: %s: getrusage() failed, errno=%d\n", id, + __func__, errno); + return res; + } + pr2serr_lk("%d->id: maxrss=%ldKB nvcsw=%ld nivcsw=%ld majflt=%ld\n", id, + ru.ru_maxrss, ru.ru_nvcsw, ru.ru_nivcsw, ru.ru_majflt); + return 0; +} + +static void +work_sync_thread(int id, const char * dev_name, unsigned int /* hi_lba */, + struct opts_t * op) +{ + bool is_rw = (SCSI_TUR != op->c2e); + int k, sg_fd, err, rs, n, sense_cat, ret; + int vb = op->verbose; + int num_errs = 0; + int thr_sync_starts = 0; + struct sg_pt_base * ptp = NULL; + uint8_t cdb[6]; + uint8_t sense_b[32] SG_C_CPP_ZERO_INIT; + char b[120]; + + if (is_rw) { + pr2serr_lk("id=%d: only support TUR here for now\n", id); + goto err_out; + } + if (op->verbose) + pr2serr_lk("id=%d: using libsgutils generic sync passthrough\n", id); + + if ((sg_fd = sg_cmds_open_device(dev_name, false /* ro */, vb)) < 0) { + pr2serr_lk("id=%d: error opening file: %s: %s\n", id, dev_name, + safe_strerror(-sg_fd)); + if (ENOMEM == -sg_fd) + pr_rusage(id); + goto err_out; + } + if (vb > 2) + pr2serr_lk(">>>> id=%d: open(%s) --> fd=%d\n", id, dev_name, sg_fd); + + ptp = construct_scsi_pt_obj_with_fd(sg_fd, vb); + err = 0; + if ((NULL == ptp) || ((err = get_scsi_pt_os_err(ptp)))) { + ret = sg_convert_errno(err ? err : ENOMEM); + sg_exit2str(ret, true, sizeof(b), b); + pr2serr_lk("id=%d: construct_scsi_pt_obj_with_fd: %s\n", id, b); + goto err_out; + } + for (k = 0; k < op->num_per_thread; ++k) { + /* Might get Unit Attention on first invocation */ + memset(cdb, 0, sizeof(cdb)); /* TUR's cdb is 6 zeros */ + set_scsi_pt_cdb(ptp, cdb, sizeof(cdb)); + set_scsi_pt_sense(ptp, sense_b, sizeof(sense_b)); + set_scsi_pt_packet_id(ptp, uniq_pack_id.fetch_add(1)); + ++thr_sync_starts; + rs = do_scsi_pt(ptp, -1, DEF_PT_TIMEOUT, vb); + n = sg_cmds_process_resp(ptp, "Test unit ready", rs, + (0 == k), vb, &sense_cat); + if (-1 == n) { + ret = sg_convert_errno(get_scsi_pt_os_err(ptp)); + sg_exit2str(ret, true, sizeof(b), b); + pr2serr_lk("id=%d: do_scsi_pt: %s\n", id, b); + goto err_out; + } else if (-2 == n) { + switch (sense_cat) { + case SG_LIB_CAT_RECOVERED: + case SG_LIB_CAT_NO_SENSE: + break; + case SG_LIB_CAT_NOT_READY: + ++num_errs; + if (1 == op->num_per_thread) { + pr2serr_lk("id=%d: device not ready\n", id); + } + break; + case SG_LIB_CAT_UNIT_ATTENTION: + ++num_errs; + if (vb) + pr2serr_lk("Ignoring Unit attention (sense key)\n"); + break; + default: + ++num_errs; + if (1 == op->num_per_thread) { + sg_get_category_sense_str(sense_cat, sizeof(b), b, vb); + pr2serr_lk("%s\n", b); + goto err_out; + } + break; + } + } + clear_scsi_pt_obj(ptp); + } +err_out: + if (ptp) + destruct_scsi_pt_obj(ptp); + if (num_errs > 0) + pr2serr_lk("id=%d: number of errors: %d\n", id, num_errs); + sync_starts += thr_sync_starts; +} + +static void +work_thread(int id, struct opts_t * op) +{ + bool is_rw = (SCSI_TUR != op->c2e); + bool need_finish, repeat; + bool once = false; + bool once1000 = false; + bool once_2000 = false; + bool once_4000 = false; + bool once5000 = false; + bool once_6000 = false; + bool once_7000 = false; + bool once10_000 = false; + bool once20_000 = false; + int open_flags = O_RDWR; + int thr_async_starts = 0; + int thr_async_finishes = 0; + int vb = op->verbose; + int k, n, res, sg_fd, num_outstanding, do_inc, npt, pack_id, sg_flags; + int num_waiting_read, sz, encore_pack_id, ask, j, m, o; + int prev_pack_id, blk_sz; + unsigned int thr_enomem_count = 0; + unsigned int thr_start_eagain_count = 0; + unsigned int thr_start_ebusy_count = 0; + unsigned int thr_start_e2big_count = 0; + unsigned int thr_fin_eagain_count = 0; + unsigned int thr_fin_ebusy_count = 0; + unsigned int thr_start_edom_count = 0; + int needed_sz = op->lb_sz * op->num_lbs; + unsigned int nanosecs; + unsigned int hi_lba; + uint64_t lba; + uint64_t sum_nanosecs = 0; + uint8_t * lbp; + uint8_t * free_lbp = NULL; + uint8_t * wrkMmap = NULL; + const char * dev_name; + const char * err = NULL; + Rand_uint * ruip = NULL; + char ebuff[EBUFF_SZ]; + struct pollfd pfd[1]; + list<pair<uint8_t *, uint8_t *> > free_lst; /* of aligned lb buffers */ + map<int, pair<uint8_t *, uint8_t *> > pi2buff;/* pack_id -> lb buffer */ + map<int, uint64_t> pi_2_lba; /* pack_id -> LBA */ + pair<uint8_t *, uint8_t *> encore_lbps; + + /* device name and hi_lba may depend on id */ + n = op->dev_names.size(); + dev_name = op->dev_names[id % n]; + if (op->blk_szs.size() >= (unsigned)n) + blk_sz = op->blk_szs[id % n]; + else + blk_sz = DEF_LB_SZ; + if ((UINT_MAX == op->hi_lba) && (n == (int)op->hi_lbas.size())) + hi_lba = op->hi_lbas[id % n]; + else + hi_lba = op->hi_lba; + + if (vb) { + if ((vb > 1) && hi_lba) + pr2serr_lk("Enter work_t_id=%d using %s\n" + " LBA range: 0x%x to 0x%x (inclusive)\n", + id, dev_name, (unsigned int)op->lba, hi_lba); + else + pr2serr_lk("Enter work_t_id=%d using %s\n", id, dev_name); + } + if (op->generic_sync) { + work_sync_thread(id, dev_name, hi_lba, op); + return; + } + if (! op->block) + open_flags |= O_NONBLOCK; + + sg_fd = open(dev_name, open_flags); + if (sg_fd < 0) { + pr_errno_lk(errno, "%s: id=%d, error opening file: %s", __func__, id, + dev_name); + if (ENOMEM == -sg_fd) + pr_rusage(id); + return; + } + if (vb > 2) + pr2serr_lk(">>>> id=%d: open(%s) --> fd=%d\n", id, dev_name, sg_fd); + if (op->pack_id_force) { + k = 1; + if (ioctl(sg_fd, SG_SET_FORCE_PACK_ID, &k) < 0) + pr2serr_lk("ioctl(SG_SET_FORCE_PACK_ID) failed, errno=%d %s\n", + errno, strerror(errno)); + } + if (op->sg_vn_ge_40000) { + if (ioctl(sg_fd, SG_GET_RESERVED_SIZE, &k) >= 0) { + if (needed_sz > k) + ioctl(sg_fd, SG_SET_RESERVED_SIZE, &needed_sz); + } + if (op->sg_vn_ge_40030 && (op->cmd_time || op->masync)) { + struct sg_extended_info sei; + struct sg_extended_info * seip; + + seip = &sei; + memset(seip, 0, sizeof(*seip)); + seip->sei_wr_mask |= SG_SEIM_CTL_FLAGS; + seip->sei_rd_mask |= SG_SEIM_CTL_FLAGS; + if (op->cmd_time) { + seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_TIME_IN_NS; + seip->ctl_flags_rd_mask |= SG_CTL_FLAGM_TIME_IN_NS; + seip->ctl_flags |= SG_CTL_FLAGM_TIME_IN_NS; + } + if (op->masync) { + seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_MORE_ASYNC; + seip->ctl_flags |= SG_CTL_FLAGM_MORE_ASYNC; + } + if (op->excl) { + seip->ctl_flags_wr_mask |= SG_CTL_FLAGM_EXCL_WAITQ; + seip->ctl_flags |= SG_CTL_FLAGM_EXCL_WAITQ; + } + if (ioctl(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) { + pr2serr_lk("ioctl(EXTENDED(TIME_IN_NS)) failed, errno=%d %s\n", + errno, strerror(errno)); + } + if (op->cmd_time && + (! (SG_CTL_FLAGM_TIME_IN_NS & seip->ctl_flags))) { + memset(seip, 0, sizeof(*seip)); + seip->sei_rd_mask |= SG_SEIM_CTL_FLAGS; + 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(sg_fd, SG_SET_GET_EXTENDED, seip) < 0) + pr2serr_lk("ioctl(EXTENDED(TIME_IN_NS)) failed, " + "errno=%d %s\n", errno, strerror(errno)); + else if (vb > 1) + pr2serr_lk("t_id: %d: set TIME_IN_NS flag\n", id); + } + } + } + if (is_rw && op->mmap_io) { + + if (ioctl(sg_fd, SG_GET_RESERVED_SIZE, &sz) < 0) { + pr2serr_lk("t_id=%d: ioctl(SG_GET_RESERVED_SIZE) errno=%d\n", + id, errno); + return; + } + if (sz < needed_sz) { + sz = needed_sz; + if (ioctl(sg_fd, SG_SET_RESERVED_SIZE, &sz) < 0) { + pr2serr_lk("t_id=%d: ioctl(SG_SET_RESERVED_SIZE) errno=%d\n", + id, errno); + return; + } + if (ioctl(sg_fd, SG_GET_RESERVED_SIZE, &sz) < 0) { + pr2serr_lk("t_id=%d: ioctl(SG_GET_RESERVED_SIZE) errno=%d\n", + id, errno); + return; + } + if (sz < needed_sz) { + pr2serr_lk("t_id=%d: unable to grow reserve buffer to %d " + "bytes\n", id, needed_sz); + return; + } + } + wrkMmap = (uint8_t *)mmap(NULL, needed_sz, PROT_READ | PROT_WRITE, + MAP_SHARED, sg_fd, 0); + if (MAP_FAILED == wrkMmap) { + int ern = errno; + + pr2serr_lk("t_id=%d: mmap() failed, errno=%d\n", id, ern); + return; + } + } + pfd[0].fd = sg_fd; + pfd[0].events = POLLIN; + if (is_rw && hi_lba) { + unsigned int seed = get_urandom_uint(); + + if (vb > 1) + pr2serr_lk(" id=%d, /dev/urandom seed=0x%x\n", id, seed); + ruip = new Rand_uint((unsigned int)op->lba, hi_lba, seed); + } + + sg_flags = 0; + if (BLQ_AT_TAIL == op->blqd) + sg_flags |= SG_FLAG_Q_AT_TAIL; + else if (BLQ_AT_HEAD == op->blqd) + sg_flags |= SG_FLAG_Q_AT_HEAD; + if (op->direct) + sg_flags |= SG_FLAG_DIRECT_IO; + if (op->mmap_io) + sg_flags |= SG_FLAG_MMAP_IO; + if (op->no_xfer) + sg_flags |= SG_FLAG_NO_DXFER; + if (vb > 1) + pr2serr_lk(" id=%d, sg_flags=0x%x, %s cmds\n", id, sg_flags, + ((SCSI_TUR == op->c2e) ? "TUR": + ((SCSI_READ16 == op->c2e) ? "READ" : "WRITE"))); + + npt = op->num_per_thread; + need_finish = false; + lba = 0; + pack_id = 0; + prev_pack_id = 0; + encore_pack_id = 0; + do_inc = 0; + /* main loop, continues until num_per_thread exhausted and there are + * no more outstanding responses */ + for (k = 0, m = 0, o=0, num_outstanding = 0; (k < npt) || num_outstanding; + k = do_inc ? k + 1 : k, ++o) { + int num_to_read = 0; + + if (do_inc) + m = 0; + else { + ++m; + if (m > 100) { + if (vb) + pr2serr_lk("%d->id: no main loop inc =%d times\n", id, m); + m = 0; + } + } + if (vb && (! once1000) && (num_outstanding >= 1000)) { + int num_waiting; + int num_subm = (op->sg_vn_ge_40030) ? num_submitted(sg_fd) : + pi2buff.size(); + + once1000 = true; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + pr2serr_lk("%d->id: once 1000: k=%d, submitted=%d waiting=%d; " + "pi2buff.sz=%u\n", id, k, num_subm, num_waiting, + (uint32_t)pi2buff.size()); + pr_rusage(id); + } + if (vb && ! once5000 && num_outstanding >= 5000) { + int num_waiting; + int num_subm = (op->sg_vn_ge_40030) ? num_submitted(sg_fd) : + pi2buff.size(); + + once5000 = true; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + pr2serr_lk("%d->id: once 5000: k=%d, submitted=%d waiting=%d\n", + id, k, num_subm, num_waiting); + pr_rusage(id); + } + if (vb && ! once_7000 && num_outstanding >= 7000) { + int num_waiting; + int num_subm = (op->sg_vn_ge_40030) ? num_submitted(sg_fd) : + pi2buff.size(); + + once_7000 = true; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + pr2serr_lk("%d->id: once 7000: k=%d, submitted=%d waiting=%d\n", + id, k, num_subm, num_waiting); + pr_rusage(id); + } + if (vb && ! once10_000 && num_outstanding >= 10000) { + int num_waiting; + int num_subm = (op->sg_vn_ge_40030) ? num_submitted(sg_fd) : + pi2buff.size(); + + once10_000 = true; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + pr2serr_lk("%d->id: once 10^4: k=%d, submitted=%d waiting=%d\n", + id, k, num_subm, num_waiting); + pr_rusage(id); + } + if (vb && ! once20_000 && num_outstanding >= 20000) { + int num_waiting; + int num_subm = (op->sg_vn_ge_40030) ? num_submitted(sg_fd) : + pi2buff.size(); + + once20_000 = true; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + pr2serr_lk("%d->id: once 20000: k=%d, submitted=%d waiting=%d\n", + id, k, num_subm, num_waiting); + pr_rusage(id); + } + do_inc = 0; + if ((num_outstanding < op->maxq_per_thread) && (k < npt)) { + do_inc = 1; + if (need_finish) { + pack_id = encore_pack_id; + need_finish = false; + repeat = true; + } else { + prev_pack_id = pack_id; + pack_id = uniq_pack_id.fetch_add(1); + repeat = false; + } + if (is_rw) { /* get new lb buffer or one from free list */ + if (free_lst.empty()) { + lbp = sg_memalign(op->lb_sz * op->num_lbs, 0, &free_lbp, + false); + if (NULL == lbp) { + err = "out of memory"; + break; + } + } else if (! repeat) { + lbp = free_lst.back().first; + free_lbp = free_lst.back().second; + free_lst.pop_back(); + } else { + lbp = encore_lbps.first; + free_lbp = encore_lbps.second; + if (vb && !once && free_lst.size() > 1000) { + once = true; + pr2serr_lk("%d->id: free_lst.size() over 1000\n", id); + } + if (vb && !once_2000 && free_lst.size() > 2000) { + once_2000 = true; + pr2serr_lk("%d->id: free_lst.size() over 2000\n", id); + } + if (vb && !once_6000 && free_lst.size() > 6000) { + once_2000 = true; + pr2serr_lk("%d->id: free_lst.size() over 6000\n", id); + } + } + } else + lbp = NULL; + if (is_rw) { + if (ruip) { + if (! repeat) { + lba = ruip->get(); /* fetch a random LBA */ + if (vb > 3) + pr2serr_lk(" id=%d: start IO at lba=0x%" PRIx64 + "\n", id, lba); + } + } else + lba = op->lba; + } else + lba = 0; + if (vb > 4) + pr2serr_lk("t_id=%d: starting pack_id=%d\n", id, pack_id); + res = (op->v4) ? + start_sg4_cmd(sg_fd, op->c2e, pack_id, lba, lbp, + blk_sz * op->num_lbs, sg_flags, op->submit, + thr_enomem_count, thr_start_eagain_count, + thr_start_ebusy_count, thr_start_e2big_count, + thr_start_edom_count) : + start_sg3_cmd(sg_fd, op->c2e, pack_id, lba, lbp, + blk_sz * op->num_lbs, sg_flags, op->submit, + thr_enomem_count, thr_start_eagain_count, + thr_start_ebusy_count, thr_start_e2big_count, + thr_start_edom_count); + if (res) { + if (res > 1) { /* here if E2BIG, start not done, try finish */ + do_inc = 0; + need_finish = true; + encore_pack_id = pack_id; + pack_id = prev_pack_id; + encore_lbps = make_pair(lbp, free_lbp); + if (vb > 2) + pr2serr_lk("t_id=%d: E2BIG hit, prev_pack_id=%d, " + "encore_pack_id=%d\n", id, prev_pack_id, + encore_pack_id); + } else { + err = "start_sg3_cmd()"; + break; + } + } else { /* no error */ + ++thr_async_starts; + ++num_outstanding; + pi2buff[pack_id] = make_pair(lbp, free_lbp); + if (ruip) + pi_2_lba[pack_id] = lba; + } + if (vb && !once && (pi2buff.size() > 1000)) { + once = true; + pr2serr_lk("%d->id: pi2buff.size() over 1000 (b)\n", id); + } + if (vb && !once_2000 && free_lst.size() > 2000) { + once_2000 = true; + pr2serr_lk("%d->id: free_lst.size() over 2000 (b)\n", id); + } + if (vb && !once_6000 && free_lst.size() > 6000) { + once_2000 = true; + pr2serr_lk("%d->id: free_lst.size() over 6000 (b)\n", id); + } + } + if (need_finish) { + num_waiting_read = 0; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting_read) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } else if (vb > 3) + pr2serr_lk("t_id=%d: num_waiting_read=%d\n", id, + num_waiting_read); + if (num_waiting_read > 0) + num_to_read = num_waiting_read; + else { + struct timespec tspec = {0, 100000 /* 100 usecs */}; + + nanosleep(&tspec, NULL); + if (vb > 3) + pr2serr_lk("t_id=%d: E2BIG, 100 usecs sleep\n", id); + // err = "strange, E2BIG but nothing to read"; + // break; + } + } else if ((num_outstanding >= op->maxq_per_thread) || (k >= npt)) { + /* full queue or finished injecting */ + num_waiting_read = 0; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting_read) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + if (1 == num_waiting_read) + num_to_read = num_waiting_read; + else if (num_waiting_read > 0) { + if (k >= npt) + num_to_read = num_waiting_read; + else { + switch (op->myqd) { + case MYQD_LOW: + num_to_read = num_waiting_read; + break; + case MYQD_MEDIUM: + num_to_read = num_waiting_read / 2; + break; + case MYQD_HIGH: + default: + if (op->ovn > 0) { + if (op->sg_vn_ge_40030) { + int num_subm = num_submitted(sg_fd); + + if (num_subm > op->ovn) { + num_to_read = num_waiting_read > 0 ? + num_waiting_read : 1; + break; + } + } else { + if (num_waiting_read > (op->ovn / 2)) { + num_to_read = num_waiting_read / 2; + break; + } + } + } + num_to_read = 1; + break; + } + } + } else { /* nothing waiting to be read */ + if (op->sg_vn_ge_40030) { + int val = num_submitted(sg_fd); + + if (0 == val) { + err = "nothing submitted now ??"; + break; + } else if (val < 0) { + err = "num_submitted failed"; + break; + } + } + n = (op->wait_ms > 0) ? op->wait_ms : 0; + if (n > 0) { + for (j = 0; (j < 1000000) && + (0 == (res = poll(pfd, 1, n))); + ++j) + ; + if (j >= 1000000) { + err = "poll() looped 1 million times"; + break; + } + if (res < 0) { + err = "poll(wait_ms) failed"; + break; + } + } else { + struct timespec ts; + + ts.tv_sec = 0; + ts.tv_nsec = DEF_NANOSEC_WAIT; + if (nanosleep(&ts, NULL) < 0) { + err = "nanosleep() failed"; + break; + } + } + } + } else { /* not full, not finished injecting */ + if (MYQD_HIGH == op->myqd) { + num_to_read = 0; + if (op->ovn) { + if (op->sg_vn_ge_40030) { + int num_subm = num_submitted(sg_fd); + + if (num_subm > op->ovn) + num_to_read = num_waiting_read > 0 ? + num_waiting_read : 1; + } else { + num_waiting_read = 0; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, + &num_waiting_read) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + if (num_waiting_read > (op->ovn / 2)) + num_to_read = num_waiting_read / 2; + } + } + } else { + num_waiting_read = 0; + if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting_read) < 0) { + err = "ioctl(SG_GET_NUM_WAITING) failed"; + break; + } + if (num_waiting_read > 0) + num_to_read = num_waiting_read / + ((MYQD_LOW == op->myqd) ? 1 : 2); + else + num_to_read = 0; + } + } + + if (vb && !once_4000 && (num_to_read > 4000)) { + once_4000 = true; + pr2serr_lk("%d->id: num_to_read=%d\n", id, num_to_read); + } + while (num_to_read > 0) { + --num_to_read; + if (op->pack_id_force) { + j = pi2buff.size(); + if (j > 0) + pack_id = pi2buff.begin()->first; + else + pack_id = -1; + } else + pack_id = -1; + ask = pack_id; + res = (op->v4) ? + finish_sg4_cmd(sg_fd, op->c2e, pack_id, op->submit, + op->wait_ms, thr_enomem_count, + thr_fin_eagain_count, thr_fin_ebusy_count, + nanosecs) : + finish_sg3_cmd(sg_fd, op->c2e, pack_id, op->submit, + op->wait_ms, thr_enomem_count, + thr_fin_eagain_count, thr_fin_ebusy_count, + nanosecs); + if (res) { + err = "finish_sg3_cmd()"; + if (ruip && (pack_id > 0)) { + auto q = pi_2_lba.find(pack_id); + + if (q != pi_2_lba.end()) { + snprintf(ebuff, sizeof(ebuff), "%s: lba=0x%" PRIx64 , + err, q->second); + err = ebuff; + } + } + break; + } + if (op->cmd_time && op->sg_vn_ge_40030) + sum_nanosecs += nanosecs; + ++thr_async_finishes; + --num_outstanding; + if (vb > 4) + pr2serr_lk("t_id=%d: finishing pack_id ask=%d, got=%d, " + "outstanding=%d\n", id, ask, pack_id, + num_outstanding); + auto p = pi2buff.find(pack_id); + + if (p == pi2buff.end()) { + snprintf(ebuff, sizeof(ebuff), "pack_id=%d from " + "finish_sg3_cmd() not found\n", pack_id); + if (! err) + err = ebuff; + } else { + lbp = p->second.first; + free_lbp = p->second.second; + pi2buff.erase(p); + if (lbp) + free_lst.push_front(make_pair(lbp, free_lbp)); + } + if (ruip && (pack_id > 0)) { + auto q = pi_2_lba.find(pack_id); + + if (q != pi_2_lba.end()) { + if (vb > 3) + pr2serr_lk(" id=%d: finish IO at lba=0x%" PRIx64 + "\n", id, q->second); + pi_2_lba.erase(q); + } + } + if (err) + break; + } /* end of while loop counting down num_to_read */ + if (err) + break; + } /* end of for loop over npt (number per thread) */ + if (vb) + pr2serr_lk("%d->id: leaving main thread loop; k=%d, o=%d\n", id, k, + o); + close(sg_fd); // sg driver will handle any commands "in flight" + if (ruip) + delete ruip; + + if (err || (k < npt)) { + if (k < npt) + pr2serr_lk("t_id=%d FAILed at iteration %d%s%s\n", id, k, + (err ? ", Reason: " : ""), (err ? err : "")); + else + pr2serr_lk("t_id=%d FAILed on last%s%s\n", id, + (err ? ", Reason: " : ""), (err ? err : "")); + } + n = pi2buff.size(); + if (n > 0) + pr2serr_lk("t_id=%d Still %d elements in pi2buff map on " + "exit\n", id, n); + for (k = 0; ! free_lst.empty(); ++k) { + lbp = free_lst.back().first; + free_lbp = free_lst.back().second; + free_lst.back().second = NULL; + free_lst.pop_back(); + if (vb > 6) + pr2serr_lk("t_id=%d freeing %p (free_ %p)\n", id, lbp, free_lbp); + if (free_lbp) { + free(free_lbp); + free_lbp = NULL; + } + } + if ((vb > 2) && (k > 0)) + pr2serr_lk("%d->id: Maximum number of READ/WRITEs queued: %d\n", + id, k); + async_starts += thr_async_starts; + async_finishes += thr_async_finishes; + start_eagain_count += thr_start_eagain_count; + start_ebusy_count += thr_start_ebusy_count; + start_e2big_count += thr_start_e2big_count; + fin_eagain_count += thr_fin_eagain_count; + fin_ebusy_count += thr_fin_ebusy_count; + enomem_count += thr_enomem_count; + start_edom_count += thr_start_edom_count; + if (op->cmd_time && op->sg_vn_ge_40030 && (npt > 0)) { + pr2serr_lk("t_id=%d average nanosecs per cmd: %" PRId64 + "\n", id, sum_nanosecs / npt); + } +} + +#define INQ_REPLY_LEN 96 +#define INQ_CMD_LEN 6 + +/* Send INQUIRY and fetches response. If okay puts PRODUCT ID field + * in b (up to m_blen bytes). Does not use O_EXCL flag. Returns 0 on success, + * else -1 . */ +static int +do_inquiry_prod_id(const char * dev_name, int block, int & sg_ver_num, + char * b, int b_mlen) +{ + int sg_fd, ok, ret; + struct sg_io_hdr pt; + uint8_t inqCmdBlk [INQ_CMD_LEN] = + {0x12, 0, 0, 0, INQ_REPLY_LEN, 0}; + uint8_t inqBuff[INQ_REPLY_LEN]; + uint8_t sense_buffer[64] SG_C_CPP_ZERO_INIT; + int open_flags = O_RDWR; /* O_EXCL | O_RDONLY fails with EPERM */ + + if (! block) + open_flags |= O_NONBLOCK; + sg_fd = open(dev_name, open_flags); + if (sg_fd < 0) { + pr_errno_lk(errno, "%s: error opening file: %s", __func__, dev_name); + return -1; + } + if (ioctl(sg_fd, SG_GET_VERSION_NUM, &sg_ver_num) < 0) + sg_ver_num = 0; + /* Prepare INQUIRY command */ + memset(&pt, 0, sizeof(pt)); + pt.interface_id = 'S'; + pt.cmd_len = sizeof(inqCmdBlk); + /* pt.iovec_count = 0; */ /* memset takes care of this */ + pt.mx_sb_len = sizeof(sense_buffer); + pt.dxfer_direction = SG_DXFER_FROM_DEV; + pt.dxfer_len = INQ_REPLY_LEN; + pt.dxferp = inqBuff; + pt.cmdp = inqCmdBlk; + pt.sbp = sense_buffer; + pt.timeout = 20000; /* 20000 millisecs == 20 seconds */ + /* pt.flags = 0; */ /* take defaults: indirect IO, etc */ + /* pt.pack_id = 0; */ + /* pt.usr_ptr = NULL; */ + + if (ioctl(sg_fd, SG_IO, &pt) < 0) { + pr_errno_lk(errno, "%s: Inquiry SG_IO ioctl error", __func__); + close(sg_fd); + return -1; + } + + /* now for the error processing */ + ok = 0; + switch (sg_err_category3(&pt)) { + case SG_LIB_CAT_CLEAN: + ok = 1; + break; + case SG_LIB_CAT_RECOVERED: + pr2serr_lk("Recovered error on INQUIRY, continuing\n"); + ok = 1; + break; + default: /* won't bother decoding other categories */ + { + lock_guard<mutex> lg(console_mutex); + sg_chk_n_print3("INQUIRY command error", &pt, 1); + } + break; + } + if (ok) { + /* Good, so fetch Product ID from response, copy to 'b' */ + if (b_mlen > 0) { + if (b_mlen > 16) { + memcpy(b, inqBuff + 16, 16); + b[16] = '\0'; + } else { + memcpy(b, inqBuff + 16, b_mlen - 1); + b[b_mlen - 1] = '\0'; + } + } + ret = 0; + } else + ret = -1; + + close(sg_fd); + return ret; +} + +/* Only allow ranges up to 2**32-1 upper limit, so READ CAPACITY(10) + * sufficient. Return of 0 -> success, -1 -> failure, 2 -> try again */ +static int +do_read_capacity(const char * dev_name, int block, unsigned int * last_lba, + unsigned int * blk_sz) +{ + int res, sg_fd; + uint8_t rcCmdBlk [10] = {0x25, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + uint8_t rcBuff[64]; + uint8_t sense_b[64] SG_C_CPP_ZERO_INIT; + sg_io_hdr_t io_hdr SG_C_CPP_ZERO_INIT; + int open_flags = O_RDWR; /* O_EXCL | O_RDONLY fails with EPERM */ + + if (! block) + open_flags |= O_NONBLOCK; + sg_fd = open(dev_name, open_flags); + if (sg_fd < 0) { + pr_errno_lk(errno, "%s: error opening file: %s", __func__, dev_name); + return -1; + } + /* Prepare READ CAPACITY(10) command */ + 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 = 20000; /* 20000 millisecs == 20 seconds */; + + if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) { + pr_errno_lk(errno, "%s (SG_IO) error", __func__); + close(sg_fd); + return -1; + } + res = sg_err_category3(&io_hdr); + if (SG_LIB_CAT_UNIT_ATTENTION == res) { + lock_guard<mutex> lg(console_mutex); + sg_chk_n_print3("read capacity", &io_hdr, 1); + close(sg_fd); + return 2; /* probably have another go ... */ + } else if (SG_LIB_CAT_CLEAN != res) { + lock_guard<mutex> lg(console_mutex); + sg_chk_n_print3("read capacity", &io_hdr, 1); + close(sg_fd); + return -1; + } + *last_lba = sg_get_unaligned_be32(&rcBuff[0]); + *blk_sz = sg_get_unaligned_be32(&rcBuff[4]); + close(sg_fd); + return 0; +} + + +int +main(int argc, char * argv[]) +{ + bool maxq_per_thread_given = false; + int n; + int force = 0; + int64_t ll; + int num_threads = DEF_NUM_THREADS; + struct timespec start_tm, end_tm; + struct opts_t * op; + const char * cp; + + op = &a_opts; +#if 0 + memset(op, 0, sizeof(*op)); // C++ doesn't like this +#endif + op->direct = DEF_DIRECT; + op->lba = DEF_LBA; + op->hi_lba = 0; + op->lb_sz = DEF_LB_SZ; + op->maxq_per_thread = MAX_Q_PER_FD; + op->mmap_io = DEF_MMAP_IO; + op->num_per_thread = DEF_NUM_PER_THREAD; + op->num_lbs = 1; + op->no_xfer = !! DEF_NO_XFER; + op->verbose = 0; + op->wait_ms = DEF_WAIT_MS; + op->c2e = SCSI_TUR; + op->blqd = BLQ_DEFAULT; + op->block = !! DEF_BLOCKING; + op->myqd = MYQD_HIGH; + page_size = sysconf(_SC_PAGESIZE); + + while (1) { + int option_index = 0; + int c; + + c = getopt_long(argc, argv, + "34acdefghl:L:mM:n:NO:pq:Q:Rs:St:TuvVw:W", + long_options, &option_index); + if (c == -1) + break; + + switch (c) { + case '3': + op->v3 = true; + op->v3_given = true; + op->v4 = false; /* if '-4 -3' take latter */ + op->v4_given = false; + break; + case '4': + op->v4 = true; + op->v4_given = true; + op->v3 = false; + op->v3_given = false; + break; + case 'a': + op->masync = true; + break; + case 'c': + op->cmd_time = true; + break; + case 'd': + op->direct = true; + break; + case 'e': + op->excl = true; + break; + case 'f': + force = true; + break; + case 'g': + op->generic_sync = true; + break; + case 'h': + case '?': + usage(); + return 0; + case 'l': + if (isdigit(*optarg)) { + ll = sg_get_llnum(optarg); + if (-1 == ll) { + pr2serr_lk("could not decode lba\n"); + return 1; + } else + op->lba = (uint64_t)ll; + cp = strchr(optarg, ','); + if (cp) { + if (0 == strcmp("-1", cp + 1)) + op->hi_lba = UINT_MAX; + else { + ll = sg_get_llnum(cp + 1); + if ((-1 == ll) || (ll > UINT_MAX)) { + pr2serr_lk("could not decode hi_lba, or > " + "UINT_MAX\n"); + return 1; + } else + op->hi_lba = (unsigned int)ll; + } + } + } else { + pr2serr_lk("--lba= expects a number\n"); + return 1; + } + break; + case 'L': + op->lb_sz = sg_get_num(optarg); + if (op->lb_sz < 0) { + pr2serr_lk("--lbsz= expects power of 2\n"); + return 1; + } + if (0 == op->lb_sz) + op->lb_sz = DEF_LB_SZ; + break; + case 'm': + op->mmap_io = true; + break; + case 'M': + if (isdigit(*optarg)) { + n = atoi(optarg); + if ((n < 1) || (n > MAX_Q_PER_FD)) { + pr2serr_lk("-M expects a value from 1 to %d\n", + MAX_Q_PER_FD); + return 1; + } + maxq_per_thread_given = true; + op->maxq_per_thread = n; + } else { + pr2serr_lk("--maxqpt= expects a number\n"); + return 1; + } + break; + case 'n': + if (isdigit(*optarg)) + op->num_per_thread = sg_get_num(optarg); + else { + pr2serr_lk("--numpt= expects a number\n"); + return 1; + } + break; + case 'N': + op->no_xfer = true; + break; + case 'O': + if (isdigit(*optarg)) + op->ovn = sg_get_num(optarg); + else { + pr2serr_lk("--override= expects a number\n"); + return 1; + } + if (op->ovn < 0) { + pr2serr_lk("--override= bad number\n"); + return 1; + } + break; + case 'p': + op->pack_id_force = true; + break; + case 'q': + if (isdigit(*optarg)) { + n = atoi(optarg); + if (0 == n) + op->blqd = BLQ_AT_HEAD; + else if (1 == n) + op->blqd = BLQ_AT_TAIL; + } else { + pr2serr_lk("--qat= expects a number: 0 or 1\n"); + return 1; + } + break; + case 'Q': + if (isdigit(*optarg)) { + n = atoi(optarg); + if (0 == n) + op->myqd = MYQD_LOW; + else if (1 == n) + op->myqd = MYQD_MEDIUM; + else if (2 == n) + op->myqd = MYQD_HIGH; + } else { + pr2serr_lk("--qfav= expects a number: 0, 1 or 2\n"); + return 1; + } + break; + case 'R': + op->c2e = SCSI_READ16; + break; + case 's': + if (isdigit(*optarg)) { + op->lb_sz = atoi(optarg); + if (op->lb_sz < 256) { + cerr << "Strange lb_sz, using 256" << endl; + op->lb_sz = 256; + } + } else { + pr2serr_lk("--szlb= expects a number\n"); + return 1; + } + if ((cp = strchr(optarg, ','))) { + n = sg_get_num(cp + 1); + if (n < 1) { + pr2serr_lk("could not decode 2nd part of " + "--szlb=LBS,NLBS\n"); + return 1; + } + op->num_lbs = n; + } + break; + case 'S': + ++op->stats; + break; + case 't': + if (isdigit(*optarg)) + num_threads = atoi(optarg); + else { + pr2serr_lk("--tnum= expects a number\n"); + return 1; + } + break; + case 'T': + op->c2e = SCSI_TUR; + break; + case 'u': + op->submit = true; + break; + case 'v': + op->verbose_given = true; + ++op->verbose; + break; + case 'V': + op->version_given = true; + break; + case 'w': + if ((isdigit(*optarg) || ('-' == *optarg))) { + if ('-' == *optarg) + op->wait_ms = - atoi(optarg + 1); + else + op->wait_ms = atoi(optarg); + } else { + pr2serr_lk("--wait= expects a number\n"); + return 1; + } + break; + case 'W': + op->c2e = SCSI_WRITE16; + break; + default: + pr2serr_lk("unrecognised option code 0x%x ??\n", c); + usage(); + return 1; + } + } + if (optind < argc) { + for (; optind < argc; ++optind) + op->dev_names.push_back(argv[optind]); + } +#ifdef DEBUG + pr2serr_lk("In DEBUG mode, "); + if (op->verbose_given && op->version_given) { + pr2serr_lk("but override: '-vV' given, zero verbose and continue\n"); + op->verbose_given = false; + op->version_given = false; + op->verbose = 0; + } else if (! op->verbose_given) { + pr2serr_lk("set '-vv'\n"); + op->verbose = 2; + } else + pr2serr_lk("keep verbose=%d\n", op->verbose); +#else + if (op->verbose_given && op->version_given) + pr2serr_lk("Not in DEBUG mode, so '-vV' has no special action\n"); +#endif + if (op->version_given) { + pr2serr_lk("version: %s\n", version_str); + return 0; + } + if (op->mmap_io) { + if (maxq_per_thread_given && (op->maxq_per_thread > 1)) { + pr2serr_lk("With mmap_io selected, QPT cannot exceed 1\n"); + return 1; + } else if (op->direct) { + pr2serr_lk("direct IO and mmap-ed IO cannot both be selected\n"); + return 1; + } else if (op->generic_sync) { + pr2serr_lk("--generic-sync and and mmap-ed IO are compatible\n"); + return 1; + } else + op->maxq_per_thread = 1; + } + if (! op->cmd_time && getenv("SG3_UTILS_LINUX_NANO")) { + op->cmd_time = true; + if (op->verbose) + fprintf(stderr, "setting nanosecond timing due to environment " + "variable: SG3_UTILS_LINUX_NANO\n"); + } + if (0 == op->dev_names.size()) { + fprintf(stderr, "No sg_disk_device-s given\n\n"); + usage(); + return 1; + } + if (op->hi_lba && (op->lba > op->hi_lba)) { + cerr << "lba,hi_lba range is illegal" << endl; + return 1; + } + if (op->v4) { + if (! op->submit) { + op->submit = true; + if (op->verbose > 1) + cerr << "when --v4 is given, --submit will be set" << endl; + } + } + + try { + int k, sg_ver_num; + unsigned int last_lba; + unsigned int blk_sz; + struct stat a_stat; + + for (k = 0; k < (int)op->dev_names.size(); ++k) { + int res; + const char * dev_name; + char b[128]; + + dev_name = op->dev_names[k]; + if (stat(dev_name, &a_stat) < 0) { + snprintf(b, sizeof(b), "could not stat() %s", dev_name); + perror(b); + return 1; + } + if (! S_ISCHR(a_stat.st_mode)) { + pr2serr_lk("%s should be a sg device which is a char " + "device. %s\n", dev_name, dev_name); + pr2serr_lk("is not a char device and damage could be done " + "if it is a BLOCK\ndevice, exiting ...\n"); + return 1; + } + res = do_inquiry_prod_id(dev_name, op->block, sg_ver_num, + b, sizeof(b)); + if (! force) { + if (res) { + pr2serr_lk("INQUIRY failed on %s\n", dev_name); + return 1; + } + // For safety, since <lba> written to, only permit scsi_debug + // devices. Bypass this with '-f' option. + if (0 != memcmp("scsi_debug", b, 10)) { + pr2serr_lk("Since this utility may write to LBAs, " + "only devices with the\n" + "product ID 'scsi_debug' accepted. Use '-f' " + "to override.\n"); + return 2; + } + } + if (sg_ver_num < 30000) { + pr2serr_lk("%s either not sg device or too old\n", dev_name); + return 2; + } else if (sg_ver_num >= 40030) { + op->sg_vn_ge_40030 = true; + op->sg_vn_ge_40000 = true; + if (! (op->v3_given || op->v4_given)) { + op->v4 = true; + op->v3 = false; + op->submit = true; + } + } else if (sg_ver_num >= 40000) { + op->sg_vn_ge_40030 = false; + op->sg_vn_ge_40000 = true; + if (! (op->v3_given || op->v4_given)) { + op->v4 = true; + op->v3 = false; + op->submit = true; + } + } else { + if (! (op->v3_given || op->v4_given)) { + op->v4 = false; + op->v3 = true; + op->submit = false; + } + } + + if ((SCSI_WRITE16 == op->c2e) || (SCSI_READ16 == op->c2e)) { + res = do_read_capacity(dev_name, op->block, &last_lba, + &blk_sz); + if (2 == res) + res = do_read_capacity(dev_name, op->block, &last_lba, + &blk_sz); + if (res) { + pr2serr_lk("READ CAPACITY(10) failed on %s\n", dev_name); + return 1; + } + if (blk_sz != (unsigned int)op->lb_sz) { + pr2serr_lk(">>> Logical block size (%d) of %s\n" + " differs from command line option (or " + "default)\n", blk_sz, dev_name); + pr2serr_lk("... continue anyway\n"); + } + op->blk_szs.push_back(blk_sz); + if (UINT_MAX == op->hi_lba) + op->hi_lbas.push_back(last_lba); + } + } + + start_tm.tv_sec = 0; + start_tm.tv_nsec = 0; + if (clock_gettime(CLOCK_MONOTONIC, &start_tm) < 0) + perror("clock_gettime failed"); + + vector<thread *> vt; + + /* start multi-threaded section */ + for (k = 0; k < num_threads; ++k) { + thread * tp = new thread {work_thread, k, op}; + vt.push_back(tp); + } + + // g++ 4.7.3 didn't like range-for loop here + for (k = 0; k < (int)vt.size(); ++k) + vt[k]->join(); + /* end multi-threaded section, just this main thread left */ + + for (k = 0; k < (int)vt.size(); ++k) + delete vt[k]; + + n = uniq_pack_id.load() - 1; + if (((n > 0) || op->generic_sync) && + (0 == clock_gettime(CLOCK_MONOTONIC, &end_tm))) { + struct timespec res_tm; + double a, b; + + if (op->generic_sync) + n = op->num_per_thread * num_threads; + res_tm.tv_sec = end_tm.tv_sec - start_tm.tv_sec; + res_tm.tv_nsec = end_tm.tv_nsec - start_tm.tv_nsec; + if (res_tm.tv_nsec < 0) { + --res_tm.tv_sec; + res_tm.tv_nsec += 1000000000; + } + a = res_tm.tv_sec; + a += (0.000001 * (res_tm.tv_nsec / 1000)); + b = (double)n; + if (a > 0.000001) { + printf("Time to complete %d commands was %d.%06d seconds\n", + n, (int)res_tm.tv_sec, (int)(res_tm.tv_nsec / 1000)); + printf("Implies %.0f IOPS\n", (b / a)); + } + } + + if (op->verbose || op->stats) { + cout << "Number of sync_starts: " << sync_starts.load() << endl; + cout << "Number of async_starts: " << async_starts.load() << endl; + cout << "Number of async_finishes: " << async_finishes.load() << + endl; + cout << "Last pack_id: " << n << endl; + } + n = start_ebusy_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of start EBUSYs: " << n << endl; + n = fin_ebusy_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of finish EBUSYs: " << n << endl; + n = start_eagain_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of start EAGAINs: " << n << endl; + n = fin_eagain_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of finish EAGAINs: " << n << endl; + n = start_e2big_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of E2BIGs: " << n << endl; + n = start_edom_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of EDOMs: " << n << endl; + n = enomem_count.load(); + if (op->verbose || op->stats || (n > 0)) + cout << "Number of ENOMEMs: " << n << endl; + } + catch(system_error& e) { + cerr << "got a system_error exception: " << e.what() << '\n'; + auto ec = e.code(); + cerr << "category: " << ec.category().name() << '\n'; + cerr << "value: " << ec.value() << '\n'; + cerr << "message: " << ec.message() << '\n'; + cerr << "\nNote: if g++ may need '-pthread' or similar in " + "compile/link line" << '\n'; + } + catch(...) { + cerr << "got another exception: " << '\n'; + } + return 0; +} |