aboutsummaryrefslogtreecommitdiff
path: root/src/sgp_dd.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/sgp_dd.c')
-rw-r--r--src/sgp_dd.c2019
1 files changed, 2019 insertions, 0 deletions
diff --git a/src/sgp_dd.c b/src/sgp_dd.c
new file mode 100644
index 00000000..6a039f43
--- /dev/null
+++ b/src/sgp_dd.c
@@ -0,0 +1,2019 @@
+/* A utility program for copying files. Specialised for "files" that
+ * represent devices that understand the SCSI command set.
+ *
+ * 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 specialisation of the Unix "dd" command in which
+ * one or both of the given files is a scsi generic device or a raw
+ * device. A logical 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 or 'of=-' then stdout assumed.
+ *
+ * A non-standard argument "bpt" (blocks per transfer) is added to control
+ * the maximum number of blocks in each transfer. The default value is 128.
+ * For example if "bs=512" and "bpt=32" then a maximum of 32 blocks (16 KiB
+ * in this case) are transferred to or from the sg device in a single SCSI
+ * command.
+ *
+ * This version is designed for the Linux kernel 2.4, 2.6, 3, 4 and 5 series.
+ *
+ * sgp_dd is a Posix threads specialization of the sg_dd utility. Both
+ * sgp_dd and sg_dd only perform special tasks when one or both of the given
+ * devices belong to the Linux sg driver
+ */
+
+#define _XOPEN_SOURCE 600
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1
+#endif
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <pthread.h>
+#include <signal.h>
+#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+#ifndef major
+#include <sys/types.h>
+#endif
+#include <sys/time.h>
+#include <linux/major.h> /* for MEM_MAJOR, SCSI_GENERIC_MAJOR, etc */
+#include <linux/fs.h> /* for BLKSSZGET and friends */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef __STDC_VERSION__
+#if __STDC_VERSION__ >= 201112L && defined(HAVE_STDATOMIC_H)
+#ifndef __STDC_NO_ATOMICS__
+
+#define HAVE_C11_ATOMICS
+#include <stdatomic.h>
+
+#endif
+#endif
+#endif
+
+#ifndef HAVE_C11_ATOMICS
+#warning "Don't have C11 Atomics, using mutex with pack_id"
+#endif
+
+#include "sg_lib.h"
+#include "sg_cmds_basic.h"
+#include "sg_io_linux.h"
+#include "sg_unaligned.h"
+#include "sg_pr2serr.h"
+
+
+static const char * version_str = "5.84 20220118";
+
+#define DEF_BLOCK_SIZE 512
+#define DEF_BLOCKS_PER_TRANSFER 128
+#define DEF_BLOCKS_PER_2048TRANSFER 32
+#define DEF_SCSI_CDBSZ 10
+#define MAX_SCSI_CDBSZ 16
+#define MAX_BPT_VALUE (1 << 24) /* used for maximum bs as well */
+#define MAX_COUNT_SKIP_SEEK (1LL << 48) /* coverity wants upper bound */
+
+
+#define SENSE_BUFF_LEN 64 /* Arbitrary, could be larger */
+#define READ_CAP_REPLY_LEN 8
+#define RCAP16_REPLY_LEN 32
+
+#define DEF_TIMEOUT 60000 /* 60,000 millisecs == 60 seconds */
+
+#define SGP_READ10 0x28
+#define SGP_WRITE10 0x2a
+#define DEF_NUM_THREADS 4
+#define MAX_NUM_THREADS 1024 /* was SG_MAX_QUEUE (16) but no longer applies */
+
+#ifndef RAW_MAJOR
+#define RAW_MAJOR 255 /*unlikely value */
+#endif
+
+#define FT_OTHER 1 /* filetype other than one of the following */
+#define FT_SG 2 /* filetype is sg char device */
+#define FT_RAW 4 /* filetype is raw char device */
+#define FT_DEV_NULL 8 /* either "/dev/null" or "." as filename */
+#define FT_ST 16 /* filetype is st char device (tape) */
+#define FT_BLOCK 32 /* filetype is a block device */
+#define FT_ERROR 64 /* couldn't "stat" file */
+
+#define DEV_NULL_MINOR_NUM 3
+
+#define EBUFF_SZ 768
+
+#ifndef SG_FLAG_MMAP_IO
+#define SG_FLAG_MMAP_IO 4
+#endif
+
+#define STR_SZ 1024
+#define INOUTF_SZ 512
+
+
+struct flags_t {
+ bool append;
+ bool coe;
+ bool dio;
+ bool direct;
+ bool dpo;
+ bool dsync;
+ bool excl;
+ bool fua;
+ bool mmap;
+};
+
+struct opts_t
+{ /* one instance visible to all threads */
+ int infd;
+ int64_t skip;
+ int in_type;
+ int cdbsz_in;
+ struct flags_t in_flags;
+ int64_t in_blk; /* next block address to read */
+ int64_t in_count; /* blocks remaining for next read */
+ int64_t in_rem_count; /* count of remaining in blocks */
+ int in_partial;
+ pthread_mutex_t inout_mutex;
+ int outfd;
+ int64_t seek;
+ int out_type;
+ int cdbsz_out;
+ struct flags_t out_flags;
+ int64_t out_blk; /* next block address to write */
+ int64_t out_count; /* blocks remaining for next write */
+ int64_t out_rem_count; /* count of remaining out blocks */
+ int out_partial;
+ pthread_cond_t out_sync_cv;
+ int bs;
+ int bpt;
+ int num_threads;
+ int dio_incomplete_count;
+ int sum_of_resids;
+ bool mmap_active;
+ int chkaddr; /* check read data contains 4 byte, big endian block
+ * addresses, once: check only 4 bytes per block */
+ int progress; /* accept --progress or -p, does nothing */
+ int debug;
+ int dry_run;
+};
+
+struct thread_arg
+{ /* pointer to this argument passed to thread */
+ int id;
+ int64_t seek_skip;
+};
+
+typedef struct request_element
+{ /* one instance per worker thread */
+ bool wr;
+ bool in_stop;
+ bool in_err;
+ bool out_err;
+ bool use_no_dxfer;
+ int infd;
+ int outfd;
+ int64_t blk;
+ int num_blks;
+ uint8_t * buffp;
+ uint8_t * alloc_bp;
+ struct sg_io_hdr io_hdr;
+ uint8_t cdb[MAX_SCSI_CDBSZ];
+ uint8_t sb[SENSE_BUFF_LEN];
+ int bs;
+ int dio_incomplete_count;
+ int resid;
+ int cdbsz_in;
+ int cdbsz_out;
+ struct flags_t in_flags;
+ struct flags_t out_flags;
+ int debug;
+ uint32_t pack_id;
+} Rq_elem;
+
+static sigset_t signal_set;
+static pthread_t sig_listen_thread_id;
+
+static const char * sg_allow_dio = "/sys/module/sg/parameters/allow_dio";
+
+static void sg_in_operation(struct opts_t * clp, Rq_elem * rep);
+static void sg_out_operation(struct opts_t * clp, Rq_elem * rep,
+ bool bump_out_blk);
+static void normal_in_operation(struct opts_t * clp, Rq_elem * rep,
+ int blocks);
+static void normal_out_operation(struct opts_t * clp, Rq_elem * rep,
+ int blocks, bool bump_out_blk);
+static int sg_start_io(Rq_elem * rep);
+static int sg_finish_io(bool wr, Rq_elem * rep, pthread_mutex_t * a_mutp);
+
+#ifdef HAVE_C11_ATOMICS
+
+/* Assume initialized to 0, but want to start at 1, hence adding 1 in macro */
+static atomic_uint ascending_val;
+
+static atomic_uint num_eintr;
+static atomic_uint num_eagain;
+static atomic_uint num_ebusy;
+static atomic_bool exit_threads;
+
+#define GET_NEXT_PACK_ID(_v) (atomic_fetch_add(&ascending_val, _v) + (_v))
+
+#else
+
+static pthread_mutex_t av_mut = PTHREAD_MUTEX_INITIALIZER;
+static int ascending_val = 1;
+static volatile bool exit_threads;
+
+static unsigned int
+GET_NEXT_PACK_ID(unsigned int val)
+{
+ int res;
+
+ pthread_mutex_lock(&av_mut);
+ res = ascending_val;
+ ascending_val += val;
+ pthread_mutex_unlock(&av_mut);
+ return res;
+}
+
+#endif
+
+#define STRERR_BUFF_LEN 128
+
+static pthread_mutex_t strerr_mut = PTHREAD_MUTEX_INITIALIZER;
+
+static pthread_t threads[MAX_NUM_THREADS];
+static struct thread_arg thr_arg_a[MAX_NUM_THREADS];
+
+static bool shutting_down = false;
+static bool do_sync = false;
+static bool do_time = false;
+static struct opts_t my_opts;
+static struct timeval start_tm;
+static int64_t dd_count = -1;
+static int exit_status = 0;
+static char infn[INOUTF_SZ];
+static char outfn[INOUTF_SZ];
+
+static const char * my_name = "sgp_dd: ";
+
+
+static void
+calc_duration_throughput(int contin)
+{
+ struct timeval end_tm, res_tm;
+ double a, b;
+
+ gettimeofday(&end_tm, NULL);
+ res_tm.tv_sec = end_tm.tv_sec - start_tm.tv_sec;
+ res_tm.tv_usec = end_tm.tv_usec - start_tm.tv_usec;
+ if (res_tm.tv_usec < 0) {
+ --res_tm.tv_sec;
+ res_tm.tv_usec += 1000000;
+ }
+ a = res_tm.tv_sec;
+ a += (0.000001 * res_tm.tv_usec);
+ b = (double)my_opts.bs * (dd_count - my_opts.out_rem_count);
+ pr2serr("time to transfer data %s %d.%06d secs",
+ (contin ? "so far" : "was"), (int)res_tm.tv_sec,
+ (int)res_tm.tv_usec);
+ if ((a > 0.00001) && (b > 511))
+ pr2serr(", %.2f MB/sec\n", b / (a * 1000000.0));
+ else
+ pr2serr("\n");
+}
+
+static void
+print_stats(const char * str)
+{
+ int64_t infull, outfull;
+
+ if (0 != my_opts.out_rem_count)
+ pr2serr(" remaining block count=%" PRId64 "\n",
+ my_opts.out_rem_count);
+ infull = dd_count - my_opts.in_rem_count;
+ pr2serr("%s%" PRId64 "+%d records in\n", str,
+ infull - my_opts.in_partial, my_opts.in_partial);
+
+ outfull = dd_count - my_opts.out_rem_count;
+ pr2serr("%s%" PRId64 "+%d records out\n", str,
+ outfull - my_opts.out_partial, my_opts.out_partial);
+}
+
+static void
+interrupt_handler(int sig)
+{
+ struct sigaction sigact;
+
+ sigact.sa_handler = SIG_DFL;
+ sigemptyset(&sigact.sa_mask);
+ sigact.sa_flags = 0;
+ sigaction(sig, &sigact, NULL);
+ pr2serr("Interrupted by signal,");
+ if (do_time)
+ calc_duration_throughput(0);
+ print_stats("");
+ kill(getpid (), sig);
+}
+
+static void
+siginfo_handler(int sig)
+{
+ if (sig) { ; } /* unused, dummy to suppress warning */
+ pr2serr("Progress report, continuing ...\n");
+ if (do_time)
+ calc_duration_throughput(1);
+ print_stats(" ");
+}
+
+static void
+install_handler(int sig_num, void (*sig_handler) (int sig))
+{
+ struct sigaction sigact;
+ sigaction (sig_num, NULL, &sigact);
+ if (sigact.sa_handler != SIG_IGN)
+ {
+ sigact.sa_handler = sig_handler;
+ sigemptyset (&sigact.sa_mask);
+ sigact.sa_flags = 0;
+ sigaction (sig_num, &sigact, NULL);
+ }
+}
+
+#ifdef SG_LIB_ANDROID
+static void
+thread_exit_handler(int sig)
+{
+ pthread_exit(0);
+}
+#endif
+
+/* Make safe_strerror() thread safe */
+static char *
+tsafe_strerror(int code, char * ebp)
+{
+ int status;
+ char * cp;
+
+ status = pthread_mutex_lock(&strerr_mut);
+ if (0 != status) pr2serr("lock strerr_mut");
+ cp = safe_strerror(code);
+ strncpy(ebp, cp, STRERR_BUFF_LEN);
+ status = pthread_mutex_unlock(&strerr_mut);
+ if (0 != status) pr2serr("unlock strerr_mut");
+ ebp[STRERR_BUFF_LEN - 1] = '\0';
+ return ebp;
+}
+
+
+/* Following macro from D.R. Butenhof's POSIX threads book:
+ * ISBN 0-201-63392-2 . [Highly recommended book.] Changed __FILE__
+ * to __func__ */
+#define err_exit(code,text) do { \
+ char _strerr_buff[STRERR_BUFF_LEN + 1]; \
+ pr2serr("%s at \"%s\":%d: %s\n", \
+ text, __func__, __LINE__, tsafe_strerror(code, _strerr_buff)); \
+ exit(1); \
+ } while (0)
+
+
+static int
+dd_filetype(const char * filename)
+{
+ struct stat st;
+ size_t len = strlen(filename);
+
+ if ((1 == len) && ('.' == filename[0]))
+ return FT_DEV_NULL;
+ if (stat(filename, &st) < 0)
+ return FT_ERROR;
+ if (S_ISCHR(st.st_mode)) {
+ if ((MEM_MAJOR == major(st.st_rdev)) &&
+ (DEV_NULL_MINOR_NUM == minor(st.st_rdev)))
+ return FT_DEV_NULL;
+ if (RAW_MAJOR == major(st.st_rdev))
+ return FT_RAW;
+ if (SCSI_GENERIC_MAJOR == major(st.st_rdev))
+ return FT_SG;
+ if (SCSI_TAPE_MAJOR == major(st.st_rdev))
+ return FT_ST;
+ } else if (S_ISBLK(st.st_mode))
+ return FT_BLOCK;
+ return FT_OTHER;
+}
+
+static void
+usage()
+{
+ pr2serr("Usage: sgp_dd [bs=BS] [count=COUNT] [ibs=BS] [if=IFILE]"
+ " [iflag=FLAGS]\n"
+ " [obs=BS] [of=OFILE] [oflag=FLAGS] "
+ "[seek=SEEK] [skip=SKIP]\n"
+ " [--help] [--version]\n\n");
+ pr2serr(" [bpt=BPT] [cdbsz=6|10|12|16] [coe=0|1] "
+ "[deb=VERB] [dio=0|1]\n"
+ " [fua=0|1|2|3] [sync=0|1] [thr=THR] "
+ "[time=0|1] [verbose=VERB]\n"
+ " [--dry-run] [--verbose]\n"
+ " where:\n"
+ " bpt is blocks_per_transfer (default is 128)\n"
+ " bs must be device logical block size (default "
+ "512)\n"
+ " cdbsz size of SCSI READ or WRITE cdb (default is 10)\n"
+ " coe continue on error, 0->exit (def), "
+ "1->zero + continue\n"
+ " count number of blocks to copy (def: device size)\n"
+ " deb for debug, 0->none (def), > 0->varying degrees "
+ "of debug\n");
+ pr2serr(" dio is direct IO, 1->attempt, 0->indirect IO (def)\n"
+ " fua force unit access: 0->don't(def), 1->OFILE, "
+ "2->IFILE,\n"
+ " 3->OFILE+IFILE\n"
+ " if file or device to read from (def: stdin)\n"
+ " iflag comma separated list from: [coe,dio,direct,dpo,"
+ "dsync,excl,\n"
+ " fua,mmap,null]\n"
+ " of file or device to write to (def: stdout), "
+ "OFILE of '.'\n"
+ " treated as /dev/null\n"
+ " oflag comma separated list from: [append,coe,dio,"
+ "direct,dpo,\n"
+ " dsync,excl,fua,mmap,null]\n"
+ " seek block position to start writing to OFILE\n"
+ " skip block position to start reading from IFILE\n"
+ " sync 0->no sync(def), 1->SYNCHRONIZE CACHE on OFILE "
+ "after copy\n"
+ " thr is number of threads, must be > 0, default 4, "
+ "max 1024\n"
+ " time 0->no timing(def), 1->time plus calculate "
+ "throughput\n"
+ " verbose same as 'deb=VERB': increase verbosity\n"
+ " --chkaddr|-c check read data contains blk address\n"
+ " --dry-run|-d prepare but bypass copy/read\n"
+ " --help|-h output this usage message then exit\n"
+ " --verbose|-v increase verbosity of utility\n"
+ " --version|-V output version string then exit\n"
+ "Copy from IFILE to OFILE, similar to dd command\n"
+ "specialized for SCSI devices, uses multiple POSIX threads\n");
+}
+
+static int
+sgp_mem_mmap(int fd, int res_sz, uint8_t ** mmpp)
+{
+ int t;
+
+ if (ioctl(fd, SG_GET_RESERVED_SIZE, &t) < 0) {
+ perror("SG_GET_RESERVED_SIZE error");
+ return -1;
+ }
+ if (t < (int)sg_get_page_size())
+ t = sg_get_page_size();
+ if (res_sz > t) {
+ if (ioctl(fd, SG_SET_RESERVED_SIZE, &res_sz) < 0) {
+ perror("SG_SET_RESERVED_SIZE error");
+ return -1;
+ }
+ }
+ *mmpp = (uint8_t *)mmap(NULL, res_sz,
+ PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ if (MAP_FAILED == *mmpp) {
+ perror("mmap() failed");
+ return -1;
+ }
+ return 0;
+}
+
+/* Return of 0 -> success, see sg_ll_read_capacity*() otherwise */
+static int
+scsi_read_capacity(int sg_fd, int64_t * num_sect, int * sect_sz)
+{
+ int res;
+ uint8_t rcBuff[RCAP16_REPLY_LEN];
+
+ res = sg_ll_readcap_10(sg_fd, 0, 0, rcBuff, READ_CAP_REPLY_LEN, false, 0);
+ if (0 != res)
+ return res;
+
+ if ((0xff == rcBuff[0]) && (0xff == rcBuff[1]) && (0xff == rcBuff[2]) &&
+ (0xff == rcBuff[3])) {
+
+ res = sg_ll_readcap_16(sg_fd, 0, 0, rcBuff, RCAP16_REPLY_LEN, false,
+ 0);
+ if (0 != res)
+ return res;
+ *num_sect = sg_get_unaligned_be64(rcBuff + 0) + 1;
+ *sect_sz = sg_get_unaligned_be32(rcBuff + 8);
+ } else {
+ /* take care not to sign extend values > 0x7fffffff */
+ *num_sect = (int64_t)sg_get_unaligned_be32(rcBuff + 0) + 1;
+ *sect_sz = sg_get_unaligned_be32(rcBuff + 4);
+ }
+ return 0;
+}
+
+/* Return of 0 -> success, -1 -> failure. BLKGETSIZE64, BLKGETSIZE and */
+/* BLKSSZGET macros problematic (from <linux/fs.h> or <sys/mount.h>). */
+static int
+read_blkdev_capacity(int sg_fd, int64_t * num_sect, int * sect_sz)
+{
+#ifdef BLKSSZGET
+ if ((ioctl(sg_fd, BLKSSZGET, sect_sz) < 0) && (*sect_sz > 0)) {
+ perror("BLKSSZGET ioctl error");
+ return -1;
+ } else {
+ #ifdef BLKGETSIZE64
+ uint64_t ull;
+
+ if (ioctl(sg_fd, BLKGETSIZE64, &ull) < 0) {
+
+ perror("BLKGETSIZE64 ioctl error");
+ return -1;
+ }
+ *num_sect = ((int64_t)ull / (int64_t)*sect_sz);
+ #else
+ unsigned long ul;
+
+ if (ioctl(sg_fd, BLKGETSIZE, &ul) < 0) {
+ perror("BLKGETSIZE ioctl error");
+ return -1;
+ }
+ *num_sect = (int64_t)ul;
+ #endif
+ }
+ return 0;
+#else
+ *num_sect = 0;
+ *sect_sz = 0;
+ return -1;
+#endif
+}
+
+static void *
+sig_listen_thread(void * v_clp)
+{
+ struct opts_t * clp = (struct opts_t *)v_clp;
+ int sig_number;
+
+ while (1) {
+ sigwait(&signal_set, &sig_number);
+ if (shutting_down)
+ break;
+ if (SIGINT == sig_number) {
+ pr2serr("%sinterrupted by SIGINT\n", my_name);
+#ifdef HAVE_C11_ATOMICS
+ atomic_store(&exit_threads, true);
+#else
+ exit_threads = true;
+#endif
+ pthread_cond_broadcast(&clp->out_sync_cv);
+ }
+ }
+ return NULL;
+}
+
+static void
+cleanup_in(void * v_clp)
+{
+ struct opts_t * clp = (struct opts_t *)v_clp;
+
+ pr2serr("thread cancelled while in mutex held\n");
+ pthread_mutex_unlock(&clp->inout_mutex);
+ pthread_cond_broadcast(&clp->out_sync_cv);
+}
+
+static void
+cleanup_out(void * v_clp)
+{
+ struct opts_t * clp = (struct opts_t *)v_clp;
+
+ pr2serr("thread cancelled while out mutex held\n");
+ pthread_mutex_unlock(&clp->inout_mutex);
+ pthread_cond_broadcast(&clp->out_sync_cv);
+}
+
+static int
+sg_prepare(int fd, int bs, int bpt)
+{
+ int res, t;
+
+ res = ioctl(fd, SG_GET_VERSION_NUM, &t);
+ if ((res < 0) || (t < 30000)) {
+ pr2serr("%ssg driver prior to 3.x.y\n", my_name);
+ return 1;
+ }
+ t = bs * bpt;
+ res = ioctl(fd, SG_SET_RESERVED_SIZE, &t);
+ if (res < 0)
+ perror("sgp_dd: SG_SET_RESERVED_SIZE error");
+ t = 1;
+ res = ioctl(fd, SG_SET_FORCE_PACK_ID, &t);
+ if (res < 0)
+ perror("sgp_dd: SG_SET_FORCE_PACK_ID error");
+ return 0;
+}
+
+static int
+sg_in_open(const char * fnp, struct flags_t * flagp, int bs, int bpt)
+{
+ int flags = O_RDWR;
+ int fd, err;
+ char ebuff[800];
+
+ if (flagp->direct)
+ flags |= O_DIRECT;
+ if (flagp->excl)
+ flags |= O_EXCL;
+ if (flagp->dsync)
+ flags |= O_SYNC;
+
+ if ((fd = open(fnp, flags)) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scould not open %s for sg "
+ "reading", my_name, fnp);
+ perror(ebuff);
+ return -sg_convert_errno(err);
+ }
+ if (sg_prepare(fd, bs, bpt)) {
+ close(fd);
+ return -SG_LIB_FILE_ERROR;
+ }
+ return fd;
+}
+
+static int
+sg_out_open(const char * fnp, struct flags_t * flagp, int bs, int bpt)
+{
+ int flags = O_RDWR;
+ int fd, err;
+ char ebuff[800];
+
+ if (flagp->direct)
+ flags |= O_DIRECT;
+ if (flagp->excl)
+ flags |= O_EXCL;
+ if (flagp->dsync)
+ flags |= O_SYNC;
+
+ if ((fd = open(fnp, flags)) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scould not open %s for sg "
+ "writing", my_name, fnp);
+ perror(ebuff);
+ return -sg_convert_errno(err);
+ }
+ if (sg_prepare(fd, bs, bpt)) {
+ close(fd);
+ return -SG_LIB_FILE_ERROR;
+ }
+ return fd;
+}
+
+static void *
+read_write_thread(void * v_tap)
+{
+ struct thread_arg * tap = (struct thread_arg *)v_tap;
+ struct opts_t * clp = &my_opts;
+ Rq_elem rel;
+ Rq_elem * rep = &rel;
+ volatile bool stop_after_write, bb;
+ bool enforce_write_ordering;
+ int sz, c_addr;
+ int64_t out_blk, out_count;
+ int64_t seek_skip = tap->seek_skip;
+ int blocks, status;
+
+ stop_after_write = false;
+ enforce_write_ordering = (FT_DEV_NULL != clp->out_type) &&
+ (FT_SG != clp->out_type);
+ c_addr = clp->chkaddr;
+ memset(rep, 0, sizeof(*rep));
+ /* Following clp members are constant during lifetime of thread */
+ rep->bs = clp->bs;
+ if ((clp->num_threads > 1) && clp->mmap_active) {
+ /* sg devices need separate file descriptor */
+ if (clp->in_flags.mmap && (FT_SG == clp->in_type)) {
+ rep->infd = sg_in_open(infn, &clp->in_flags, rep->bs, clp->bpt);
+ if (rep->infd < 0) err_exit(-rep->infd, "error opening infn");
+ } else
+ rep->infd = clp->infd;
+ if (clp->out_flags.mmap && (FT_SG == clp->out_type)) {
+ rep->outfd = sg_out_open(outfn, &clp->out_flags, rep->bs,
+ clp->bpt);
+ if (rep->outfd < 0) err_exit(-rep->outfd, "error opening outfn");
+
+ } else
+ rep->outfd = clp->outfd;
+ } else {
+ rep->infd = clp->infd;
+ rep->outfd = clp->outfd;
+ }
+ sz = clp->bpt * rep->bs;
+ rep->debug = clp->debug;
+ rep->cdbsz_in = clp->cdbsz_in;
+ rep->cdbsz_out = clp->cdbsz_out;
+ rep->in_flags = clp->in_flags;
+ rep->out_flags = clp->out_flags;
+ rep->use_no_dxfer = (FT_DEV_NULL == clp->out_type);
+ if (clp->mmap_active) {
+ int fd = clp->in_flags.mmap ? rep->infd : rep->outfd;
+
+ status = sgp_mem_mmap(fd, sz, &rep->buffp);
+ if (status) err_exit(status, "sgp_mem_mmap() failed");
+ } else {
+ rep->buffp = sg_memalign(sz, 0 /* page align */, &rep->alloc_bp,
+ false);
+ if (NULL == rep->buffp)
+ err_exit(ENOMEM, "out of memory creating user buffers\n");
+ }
+
+ while(1) {
+ if ((rep->in_stop) || (rep->in_err) || (rep->out_err))
+ break;
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+#ifdef HAVE_C11_ATOMICS
+ bb = atomic_load(&exit_threads);
+#else
+ bb = exit_threads;
+#endif
+ if (bb || (clp->in_count <= 0)) {
+ /* no more to do, exit loop then thread */
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ break;
+ }
+ blocks = (clp->in_count > clp->bpt) ? clp->bpt : clp->in_count;
+ rep->wr = false;
+ rep->blk = clp->in_blk;
+ rep->num_blks = blocks;
+ clp->in_blk += blocks;
+ clp->in_count -= blocks;
+ /* while we have this lock, find corresponding out_blk */
+ out_blk = rep->blk + seek_skip;
+ out_count = clp->out_count;
+ if (! enforce_write_ordering)
+ clp->out_blk += blocks;
+ clp->out_count -= blocks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+
+ pthread_cleanup_push(cleanup_in, (void *)clp);
+ if (FT_SG == clp->in_type)
+ sg_in_operation(clp, rep);
+ else
+ normal_in_operation(clp, rep, blocks);
+ if (c_addr && (rep->bs > 3)) {
+ int k, j, off, num;
+ uint32_t addr = (uint32_t)rep->blk;
+
+ num = (1 == c_addr) ? 4 : (rep->bs - 3);
+ for (k = 0, off = 0; k < blocks; ++k, ++addr, off += rep->bs) {
+ for (j = 0; j < num; j += 4) {
+ if (addr != sg_get_unaligned_be32(rep->buffp + off + j))
+ break;
+ }
+ if (j < num)
+ break;
+ }
+ if (k < blocks) {
+ pr2serr("%s: chkaddr failure at addr=0x%x\n", __func__, addr);
+ rep->in_err = true;
+ }
+ }
+ pthread_cleanup_pop(0);
+ if (rep->in_err) {
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ /* write-side not done, so undo changes to out_blk + out_count */
+ if (! enforce_write_ordering)
+ clp->out_blk -= blocks;
+ clp->out_count += blocks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ break;
+ }
+
+ if (enforce_write_ordering) {
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+#ifdef HAVE_C11_ATOMICS
+ bb = atomic_load(&exit_threads);
+#else
+ bb = exit_threads;
+#endif
+ while ((! bb) && (out_blk != clp->out_blk)) {
+ /* if write would be out of sequence then wait */
+ pthread_cleanup_push(cleanup_out, (void *)clp);
+ status = pthread_cond_wait(&clp->out_sync_cv,
+ &clp->inout_mutex);
+ if (0 != status) err_exit(status, "cond out_sync_cv");
+ pthread_cleanup_pop(0);
+ }
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ }
+
+#ifdef HAVE_C11_ATOMICS
+ bb = atomic_load(&exit_threads);
+#else
+ bb = exit_threads;
+#endif
+ if (bb || (out_count <= 0))
+ break;
+
+ rep->wr = true;
+ rep->blk = out_blk;
+
+ if (0 == rep->num_blks) {
+ break; /* read nothing so leave loop */
+ }
+
+ pthread_cleanup_push(cleanup_out, (void *)clp);
+ if (FT_SG == clp->out_type)
+ sg_out_operation(clp, rep, enforce_write_ordering);
+ else if (FT_DEV_NULL == clp->out_type) {
+ /* skip actual write operation */
+ clp->out_rem_count -= blocks;
+ }
+ else
+ normal_out_operation(clp, rep, blocks, enforce_write_ordering);
+ pthread_cleanup_pop(0);
+
+ if (enforce_write_ordering)
+ pthread_cond_broadcast(&clp->out_sync_cv);
+ } /* end of while loop */
+
+ if (rep->alloc_bp)
+ free(rep->alloc_bp);
+ if (rep->in_err || rep->out_err) {
+ stop_after_write = true;
+#ifdef HAVE_C11_ATOMICS
+ if (! atomic_load(&exit_threads))
+ atomic_store(&exit_threads, true);
+#else
+ if (! exit_threads)
+ exit_threads = true;
+#endif
+ }
+ pthread_cond_broadcast(&clp->out_sync_cv);
+ return (stop_after_write || rep->in_stop) ? NULL : clp;
+}
+
+static void
+normal_in_operation(struct opts_t * clp, Rq_elem * rep, int blocks)
+{
+ int res, status;
+ char strerr_buff[STRERR_BUFF_LEN + 1];
+
+ while (((res = read(rep->infd, rep->buffp, blocks * rep->bs)) < 0) &&
+ ((EINTR == errno) || (EAGAIN == errno)))
+ ;
+ if (res < 0) {
+ if (rep->in_flags.coe) {
+ memset(rep->buffp, 0, rep->num_blks * rep->bs);
+ pr2serr(">> substituted zeros for in blk=%" PRId64 " for %d "
+ "bytes, %s\n", rep->blk,
+ rep->num_blks * rep->bs,
+ tsafe_strerror(errno, strerr_buff));
+ res = rep->num_blks * rep->bs;
+ }
+ else {
+ pr2serr("error in normal read, %s\n",
+ tsafe_strerror(errno, strerr_buff));
+ rep->in_stop = true;
+ rep->in_err = true;
+ return;
+ }
+ }
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ if (res < blocks * rep->bs) {
+ int o_blocks = blocks;
+
+ rep->in_stop = true;
+ blocks = res / rep->bs;
+ if ((res % rep->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_rem_count -= blocks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+}
+
+static void
+normal_out_operation(struct opts_t * clp, Rq_elem * rep, int blocks,
+ bool bump_out_blk)
+{
+ int res, status;
+ char strerr_buff[STRERR_BUFF_LEN + 1];
+
+ while (((res = write(rep->outfd, rep->buffp, rep->num_blks * rep->bs))
+ < 0) && ((EINTR == errno) || (EAGAIN == errno)))
+ ;
+ if (res < 0) {
+ if (rep->out_flags.coe) {
+ pr2serr(">> ignored error for out blk=%" PRId64 " for %d bytes, "
+ "%s\n", rep->blk, rep->num_blks * rep->bs,
+ tsafe_strerror(errno, strerr_buff));
+ res = rep->num_blks * rep->bs;
+ }
+ else {
+ pr2serr("error normal write, %s\n",
+ tsafe_strerror(errno, strerr_buff));
+ rep->out_err = true;
+ return;
+ }
+ }
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ if (res < blocks * rep->bs) {
+ blocks = res / rep->bs;
+ if ((res % rep->bs) > 0) {
+ blocks++;
+ clp->out_partial++;
+ }
+ rep->num_blks = blocks;
+ }
+ clp->out_rem_count -= blocks;
+ if (bump_out_blk)
+ clp->out_blk += blocks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+}
+
+static int
+sg_build_scsi_cdb(uint8_t * cdbp, int cdb_sz, unsigned int blocks,
+ int64_t start_block, bool write_true, bool fua, bool dpo)
+{
+ int rd_opcode[] = {0x8, 0x28, 0xa8, 0x88};
+ int wr_opcode[] = {0xa, 0x2a, 0xaa, 0x8a};
+ int sz_ind;
+
+ memset(cdbp, 0, cdb_sz);
+ if (dpo)
+ cdbp[1] |= 0x10;
+ if (fua)
+ cdbp[1] |= 0x8;
+ switch (cdb_sz) {
+ case 6:
+ sz_ind = 0;
+ cdbp[0] = (uint8_t)(write_true ? wr_opcode[sz_ind] :
+ rd_opcode[sz_ind]);
+ sg_put_unaligned_be24(0x1fffff & start_block, cdbp + 1);
+ cdbp[4] = (256 == blocks) ? 0 : (uint8_t)blocks;
+ if (blocks > 256) {
+ pr2serr("%sfor 6 byte commands, maximum number of blocks is "
+ "256\n", my_name);
+ return 1;
+ }
+ if ((start_block + blocks - 1) & (~0x1fffff)) {
+ pr2serr("%sfor 6 byte commands, can't address blocks beyond "
+ "%d\n", my_name, 0x1fffff);
+ return 1;
+ }
+ if (dpo || fua) {
+ pr2serr("%sfor 6 byte commands, neither dpo nor fua bits "
+ "supported\n", my_name);
+ return 1;
+ }
+ break;
+ case 10:
+ sz_ind = 1;
+ cdbp[0] = (uint8_t)(write_true ? wr_opcode[sz_ind] :
+ rd_opcode[sz_ind]);
+ sg_put_unaligned_be32((uint32_t)start_block, cdbp + 2);
+ sg_put_unaligned_be16((uint16_t)blocks, cdbp + 7);
+ if (blocks & (~0xffff)) {
+ pr2serr("%sfor 10 byte commands, maximum number of blocks is "
+ "%d\n", my_name, 0xffff);
+ return 1;
+ }
+ break;
+ case 12:
+ sz_ind = 2;
+ cdbp[0] = (uint8_t)(write_true ? wr_opcode[sz_ind] :
+ rd_opcode[sz_ind]);
+ sg_put_unaligned_be32((uint32_t)start_block, cdbp + 2);
+ sg_put_unaligned_be32((uint32_t)blocks, cdbp + 6);
+ break;
+ case 16:
+ sz_ind = 3;
+ cdbp[0] = (uint8_t)(write_true ? wr_opcode[sz_ind] :
+ rd_opcode[sz_ind]);
+ sg_put_unaligned_be64((uint64_t)start_block, cdbp + 2);
+ sg_put_unaligned_be32((uint32_t)blocks, cdbp + 10);
+ break;
+ default:
+ pr2serr("%sexpected cdb size of 6, 10, 12, or 16 but got %d\n",
+ my_name, cdb_sz);
+ return 1;
+ }
+ return 0;
+}
+
+static void
+sg_in_operation(struct opts_t * clp, Rq_elem * rep)
+{
+ int res;
+ int status;
+
+ while (1) {
+ res = sg_start_io(rep);
+ if (1 == res)
+ err_exit(ENOMEM, "sg starting in command");
+ else if (res < 0) {
+ pr2serr("%sinputting to sg failed, blk=%" PRId64 "\n", my_name,
+ rep->blk);
+ rep->in_stop = true;
+ rep->in_err = true;
+ return;
+ }
+ res = sg_finish_io(rep->wr, rep, &clp->inout_mutex);
+ switch (res) {
+ case SG_LIB_CAT_ABORTED_COMMAND:
+ case SG_LIB_CAT_UNIT_ATTENTION:
+ /* try again with same addr, count info */
+ /* now re-acquire in mutex for balance */
+ /* N.B. This re-read could now be out of read sequence */
+ break;
+ case SG_LIB_CAT_MEDIUM_HARD:
+ if (0 == rep->in_flags.coe) {
+ pr2serr("error finishing sg in command (medium)\n");
+ if (exit_status <= 0)
+ exit_status = res;
+ rep->in_stop = true;
+ rep->in_err = true;
+ return;
+ } else {
+ memset(rep->buffp, 0, rep->num_blks * rep->bs);
+ pr2serr(">> substituted zeros for in blk=%" PRId64 " for %d "
+ "bytes\n", rep->blk, rep->num_blks * rep->bs);
+ }
+#if defined(__GNUC__)
+#if (__GNUC__ >= 7)
+ __attribute__((fallthrough));
+ /* FALL THROUGH */
+#endif
+#endif
+ case 0:
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ if (rep->dio_incomplete_count || rep->resid) {
+ clp->dio_incomplete_count += rep->dio_incomplete_count;
+ clp->sum_of_resids += rep->resid;
+ }
+ clp->in_rem_count -= rep->num_blks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ return;
+ case SG_LIB_CAT_ILLEGAL_REQ:
+ if (clp->debug)
+ sg_print_command_len(rep->cdb, rep->cdbsz_in);
+ /* FALL THROUGH */
+ default:
+ pr2serr("error finishing sg in command (%d)\n", res);
+ if (exit_status <= 0)
+ exit_status = res;
+ rep->in_stop = true;
+ rep->in_err = true;
+ return;
+ }
+ } /* end of while loop */
+}
+
+static void
+sg_out_operation(struct opts_t * clp, Rq_elem * rep, bool bump_out_blk)
+{
+ int res;
+ int status;
+
+ while (1) {
+ res = sg_start_io(rep);
+ if (1 == res)
+ err_exit(ENOMEM, "sg starting out command");
+ else if (res < 0) {
+ pr2serr("%soutputting from sg failed, blk=%" PRId64 "\n",
+ my_name, rep->blk);
+ rep->out_err = true;
+ return;
+ }
+ res = sg_finish_io(rep->wr, rep, &clp->inout_mutex);
+ switch (res) {
+ case SG_LIB_CAT_ABORTED_COMMAND:
+ case SG_LIB_CAT_UNIT_ATTENTION:
+ /* try again with same addr, count info */
+ /* now re-acquire out mutex for balance */
+ /* N.B. This re-write could now be out of write sequence */
+ break;
+ case SG_LIB_CAT_MEDIUM_HARD:
+ if (0 == rep->out_flags.coe) {
+ pr2serr("error finishing sg out command (medium)\n");
+ if (exit_status <= 0)
+ exit_status = res;
+ rep->out_err = true;
+ return;
+ } else
+ pr2serr(">> ignored error for out blk=%" PRId64 " for %d "
+ "bytes\n", rep->blk, rep->num_blks * rep->bs);
+#if defined(__GNUC__)
+#if (__GNUC__ >= 7)
+ __attribute__((fallthrough));
+ /* FALL THROUGH */
+#endif
+#endif
+ case 0:
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ if (rep->dio_incomplete_count || rep->resid) {
+ clp->dio_incomplete_count += rep->dio_incomplete_count;
+ clp->sum_of_resids += rep->resid;
+ }
+ clp->out_rem_count -= rep->num_blks;
+ if (bump_out_blk)
+ clp->out_blk += rep->num_blks;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ return;
+ case SG_LIB_CAT_ILLEGAL_REQ:
+ if (clp->debug)
+ sg_print_command_len(rep->cdb, rep->cdbsz_out);
+ /* FALL THROUGH */
+ default:
+ rep->out_err = true;
+ pr2serr("error finishing sg out command (%d)\n", res);
+ if (exit_status <= 0)
+ exit_status = res;
+ return;
+ }
+ }
+}
+
+static int
+sg_start_io(Rq_elem * rep)
+{
+ struct sg_io_hdr * hp = &rep->io_hdr;
+ bool fua = rep->wr ? rep->out_flags.fua : rep->in_flags.fua;
+ bool dpo = rep->wr ? rep->out_flags.dpo : rep->in_flags.dpo;
+ bool dio = rep->wr ? rep->out_flags.dio : rep->in_flags.dio;
+ bool mmap = rep->wr ? rep->out_flags.mmap : rep->in_flags.mmap;
+ bool no_dxfer = rep->wr ? false : rep->use_no_dxfer;
+ int cdbsz = rep->wr ? rep->cdbsz_out : rep->cdbsz_in;
+ int res;
+
+ if (sg_build_scsi_cdb(rep->cdb, cdbsz, rep->num_blks, rep->blk,
+ rep->wr, fua, dpo)) {
+ pr2serr("%sbad cdb build, start_blk=%" PRId64 ", blocks=%d\n",
+ my_name, rep->blk, rep->num_blks);
+ return -1;
+ }
+ memset(hp, 0, sizeof(struct sg_io_hdr));
+ hp->interface_id = 'S';
+ hp->cmd_len = cdbsz;
+ hp->cmdp = rep->cdb;
+ hp->dxfer_direction = rep->wr ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV;
+ hp->dxfer_len = rep->bs * rep->num_blks;
+ hp->dxferp = mmap ? NULL : rep->buffp;
+ hp->mx_sb_len = sizeof(rep->sb);
+ hp->sbp = rep->sb;
+ hp->timeout = DEF_TIMEOUT;
+ hp->usr_ptr = rep;
+ rep->pack_id = GET_NEXT_PACK_ID(1);
+ hp->pack_id = (int)rep->pack_id;
+ if (dio)
+ hp->flags |= SG_FLAG_DIRECT_IO;
+ if (mmap)
+ hp->flags |= SG_FLAG_MMAP_IO;
+ if (no_dxfer)
+ hp->flags |= SG_FLAG_NO_DXFER;
+ if (rep->debug > 8) {
+ pr2serr("%s: SCSI %s, blk=%" PRId64 " num_blks=%d\n", __func__,
+ rep->wr ? "WRITE" : "READ", rep->blk, rep->num_blks);
+ sg_print_command(hp->cmdp);
+ }
+
+ while (((res = write(rep->wr ? rep->outfd : rep->infd, hp,
+ sizeof(struct sg_io_hdr))) < 0) &&
+ ((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno))) {
+#ifdef HAVE_C11_ATOMICS
+ if (EINTR == errno)
+ atomic_fetch_add(&num_eintr, 1);
+ else if (EAGAIN == errno)
+ atomic_fetch_add(&num_eagain, 1);
+ else
+ atomic_fetch_add(&num_ebusy, 1);
+#endif
+ }
+ if (res < 0) {
+ if (ENOMEM == errno)
+ return 1;
+ perror("starting io on sg device, error");
+ return -1;
+ }
+ return 0;
+}
+
+/* 0 -> successful, SG_LIB_CAT_UNIT_ATTENTION or SG_LIB_CAT_ABORTED_COMMAND
+ -> try again, SG_LIB_CAT_NOT_READY, SG_LIB_CAT_MEDIUM_HARD,
+ -1 other errors */
+static int
+sg_finish_io(bool wr, Rq_elem * rep, pthread_mutex_t * a_mutp)
+{
+ int res, status;
+ struct sg_io_hdr io_hdr;
+ struct sg_io_hdr * hp;
+#if 0
+ static int testing = 0; /* thread dubious! */
+#endif
+
+ memset(&io_hdr, 0 , sizeof(struct sg_io_hdr));
+ /* FORCE_PACK_ID active set only read packet with matching pack_id */
+ io_hdr.interface_id = 'S';
+ io_hdr.dxfer_direction = wr ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV;
+ io_hdr.pack_id = (int)rep->pack_id;
+
+ while (((res = read(wr ? rep->outfd : rep->infd, &io_hdr,
+ sizeof(struct sg_io_hdr))) < 0) &&
+ ((EINTR == errno) || (EAGAIN == errno) || (EBUSY == errno)))
+ ;
+ if (res < 0) {
+ perror("finishing io on sg device, error");
+ return -1;
+ }
+ if (rep != (Rq_elem *)io_hdr.usr_ptr)
+ err_exit(0, "sg_finish_io: bad usr_ptr, request-response mismatch\n");
+ memcpy(&rep->io_hdr, &io_hdr, sizeof(struct sg_io_hdr));
+ hp = &rep->io_hdr;
+
+ res = sg_err_category3(hp);
+ switch (res) {
+ case SG_LIB_CAT_CLEAN:
+ break;
+ case SG_LIB_CAT_RECOVERED:
+ sg_chk_n_print3((wr ? "writing continuing":
+ "reading continuing"), hp, false);
+ break;
+ case SG_LIB_CAT_ABORTED_COMMAND:
+ case SG_LIB_CAT_UNIT_ATTENTION:
+ if (rep->debug)
+ sg_chk_n_print3((wr ? "writing": "reading"), hp, false);
+ return res;
+ case SG_LIB_CAT_NOT_READY:
+ default:
+ rep->out_err = false;
+ if (rep->debug) {
+ char ebuff[EBUFF_SZ];
+
+ snprintf(ebuff, EBUFF_SZ, "%s blk=%" PRId64,
+ wr ? "writing": "reading", rep->blk);
+ status = pthread_mutex_lock(a_mutp);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ sg_chk_n_print3(ebuff, hp, false);
+ status = pthread_mutex_unlock(a_mutp);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+ }
+ return res;
+ }
+#if 0
+ if (0 == (++testing % 100)) return -1;
+#endif
+ if ((wr ? rep->out_flags.dio : rep->in_flags.dio) &&
+ ((hp->info & SG_INFO_DIRECT_IO_MASK) != SG_INFO_DIRECT_IO))
+ rep->dio_incomplete_count = 1; /* count dios done as indirect IO */
+ else
+ rep->dio_incomplete_count = 0;
+ rep->resid = hp->resid;
+ if (rep->debug > 8)
+ pr2serr("%s: completed %s\n", __func__, wr ? "WRITE" : "READ");
+ return 0;
+}
+
+static int
+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\n");
+ return 1;
+ }
+ cp = buff;
+ do {
+ np = strchr(cp, ',');
+ if (np)
+ *np++ = '\0';
+ if (0 == strcmp(cp, "append"))
+ fp->append = true;
+ else if (0 == strcmp(cp, "coe"))
+ fp->coe = true;
+ else if (0 == strcmp(cp, "dio"))
+ fp->dio = true;
+ else if (0 == strcmp(cp, "direct"))
+ fp->direct = true;
+ else if (0 == strcmp(cp, "dpo"))
+ fp->dpo = true;
+ else if (0 == strcmp(cp, "dsync"))
+ fp->dsync = true;
+ else if (0 == strcmp(cp, "excl"))
+ fp->excl = true;
+ else if (0 == strcmp(cp, "fua"))
+ fp->fua = true;
+ else if (0 == strcmp(cp, "mmap"))
+ fp->mmap = true;
+ else if (0 == strcmp(cp, "null"))
+ ;
+ else {
+ pr2serr("unrecognised flag: %s\n", cp);
+ return 1;
+ }
+ cp = np;
+ } while (cp);
+ return 0;
+}
+
+/* Returns the number of times 'ch' is found in string 's' given the
+ * string's length. */
+static int
+num_chs_in_str(const char * s, int slen, int ch)
+{
+ int res = 0;
+
+ while (--slen >= 0) {
+ if (ch == s[slen])
+ ++res;
+ }
+ return res;
+}
+
+
+int
+main(int argc, char * argv[])
+{
+ bool verbose_given = false;
+ bool version_given = false;
+ int64_t skip = 0;
+ int64_t seek = 0;
+ int ibs = 0;
+ int obs = 0;
+ int bpt_given = 0;
+ int cdbsz_given = 0;
+ char str[STR_SZ];
+ char * key;
+ char * buf;
+ int res, k, err, keylen;
+ int64_t in_num_sect = 0;
+ int64_t out_num_sect = 0;
+ int64_t seek_skip;
+ int in_sect_sz, out_sect_sz, status, n, flags;
+ void * vp;
+ struct opts_t * clp = &my_opts;
+ char ebuff[EBUFF_SZ];
+#if SG_LIB_ANDROID
+ struct sigaction actions;
+
+ memset(&actions, 0, sizeof(actions));
+ sigemptyset(&actions.sa_mask);
+ actions.sa_flags = 0;
+ actions.sa_handler = thread_exit_handler;
+ sigaction(SIGUSR1, &actions, NULL);
+#endif
+ memset(clp, 0, sizeof(*clp));
+ clp->num_threads = DEF_NUM_THREADS;
+ clp->bpt = DEF_BLOCKS_PER_TRANSFER;
+ clp->in_type = FT_OTHER;
+ clp->out_type = FT_OTHER;
+ clp->cdbsz_in = DEF_SCSI_CDBSZ;
+ clp->cdbsz_out = DEF_SCSI_CDBSZ;
+ infn[0] = '\0';
+ outfn[0] = '\0';
+
+ 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';
+ keylen = strlen(key);
+ if (0 == strcmp(key,"bpt")) {
+ clp->bpt = sg_get_num(buf);
+ if ((clp->bpt < 0) || (clp->bpt > MAX_BPT_VALUE)) {
+ pr2serr("%sbad argument to 'bpt='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ bpt_given = 1;
+ } else if (0 == strcmp(key,"bs")) {
+ clp->bs = sg_get_num(buf);
+ if ((clp->bs < 0) || (clp->bs > MAX_BPT_VALUE)) {
+ pr2serr("%sbad argument to 'bs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"cdbsz")) {
+ clp->cdbsz_in = sg_get_num(buf);
+ if ((clp->cdbsz_in < 6) || (clp->cdbsz_in > 32)) {
+ pr2serr("%s'cdbsz' expects 6, 10, 12, 16 or 32\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ clp->cdbsz_out = clp->cdbsz_in;
+ cdbsz_given = 1;
+ } else if (0 == strcmp(key,"coe")) {
+ clp->in_flags.coe = !! sg_get_num(buf);
+ clp->out_flags.coe = clp->in_flags.coe;
+ } else if (0 == strcmp(key,"count")) {
+ if (0 != strcmp("-1", buf)) {
+ dd_count = sg_get_llnum(buf);
+ if ((dd_count < 0) || (dd_count > MAX_COUNT_SKIP_SEEK)) {
+ pr2serr("%sbad argument to 'count='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } /* treat 'count=-1' as calculate count (same as not given) */
+ } else if ((0 == strncmp(key,"deb", 3)) ||
+ (0 == strncmp(key,"verb", 4)))
+ clp->debug = sg_get_num(buf);
+ else if (0 == strcmp(key,"dio")) {
+ clp->in_flags.dio = !! sg_get_num(buf);
+ clp->out_flags.dio = clp->in_flags.dio;
+ } else if (0 == strcmp(key,"fua")) {
+ n = sg_get_num(buf);
+ if (n & 1)
+ clp->out_flags.fua = true;
+ if (n & 2)
+ clp->in_flags.fua = true;
+ } else if (0 == strcmp(key,"ibs")) {
+ ibs = sg_get_num(buf);
+ if ((ibs < 0) || (ibs > MAX_BPT_VALUE)) {
+ pr2serr("%sbad argument to 'ibs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (strcmp(key,"if") == 0) {
+ if ('\0' != infn[0]) {
+ pr2serr("Second 'if=' argument??\n");
+ return SG_LIB_SYNTAX_ERROR;
+ } else {
+ memcpy(infn, buf, INOUTF_SZ);
+ infn[INOUTF_SZ - 1] = '\0';
+ }
+ } else if (0 == strcmp(key, "iflag")) {
+ if (process_flags(buf, &clp->in_flags)) {
+ pr2serr("%sbad argument to 'iflag='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"obs")) {
+ obs = sg_get_num(buf);
+ if ((obs < 0) || (obs > MAX_BPT_VALUE)) {
+ pr2serr("%sbad argument to 'obs='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (strcmp(key,"of") == 0) {
+ if ('\0' != outfn[0]) {
+ pr2serr("Second 'of=' argument??\n");
+ return SG_LIB_SYNTAX_ERROR;
+ } else {
+ memcpy(outfn, buf, INOUTF_SZ);
+ outfn[INOUTF_SZ - 1] = '\0';
+ }
+ } else if (0 == strcmp(key, "oflag")) {
+ if (process_flags(buf, &clp->out_flags)) {
+ pr2serr("%sbad argument to 'oflag='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"seek")) {
+ seek = sg_get_llnum(buf);
+ if ((seek < 0) || (seek > MAX_COUNT_SKIP_SEEK)) {
+ pr2serr("%sbad argument to 'seek='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"skip")) {
+ skip = sg_get_llnum(buf);
+ if ((skip < 0) || (skip > MAX_COUNT_SKIP_SEEK)) {
+ pr2serr("%sbad argument to 'skip='\n", my_name);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strcmp(key,"sync"))
+ do_sync = !! sg_get_num(buf);
+ else if (0 == strcmp(key,"thr"))
+ clp->num_threads = sg_get_num(buf);
+ else if (0 == strcmp(key,"time"))
+ do_time = !! sg_get_num(buf);
+ else if ((keylen > 1) && ('-' == key[0]) && ('-' != key[1])) {
+ res = 0;
+ n = num_chs_in_str(key + 1, keylen - 1, 'c');
+ clp->chkaddr += n;
+ res += n;
+ n = num_chs_in_str(key + 1, keylen - 1, 'd');
+ clp->dry_run += n;
+ res += n;
+ n = num_chs_in_str(key + 1, keylen - 1, 'h');
+ if (n > 0) {
+ usage();
+ return 0;
+ }
+ n = num_chs_in_str(key + 1, keylen - 1, 'p');
+ clp->progress += n;
+ res += n;
+ n = num_chs_in_str(key + 1, keylen - 1, 'v');
+ if (n > 0)
+ verbose_given = true;
+ clp->debug += n; /* -v ---> --verbose */
+ res += n;
+ n = num_chs_in_str(key + 1, keylen - 1, 'V');
+ if (n > 0)
+ version_given = true;
+ res += n;
+
+ if (res < (keylen - 1)) {
+ pr2serr("Unrecognised short option in '%s', try '--help'\n",
+ key);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ } else if (0 == strncmp(key, "--chkaddr", 9))
+ ++clp->chkaddr;
+ else if ((0 == strncmp(key, "--dry-run", 9)) ||
+ (0 == strncmp(key, "--dry_run", 9)))
+ ++clp->dry_run;
+ else if ((0 == strncmp(key, "--help", 6)) ||
+ (0 == strcmp(key, "-?"))) {
+ usage();
+ return 0;
+ } else if (0 == strncmp(key, "--prog", 6))
+ ++clp->progress;
+ else if (0 == strncmp(key, "--verb", 6)) {
+ verbose_given = true;
+ ++clp->debug; /* --verbose */
+ } else if (0 == strncmp(key, "--vers", 6))
+ version_given = true;
+ else {
+ pr2serr("Unrecognized option '%s'\n", key);
+ pr2serr("For more information use '--help'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ }
+
+#ifdef DEBUG
+ pr2serr("In DEBUG mode, ");
+ if (verbose_given && version_given) {
+ pr2serr("but override: '-vV' given, zero verbose and continue\n");
+ verbose_given = false;
+ version_given = false;
+ clp->debug = 0;
+ } else if (! verbose_given) {
+ pr2serr("set '-vv'\n");
+ clp->debug = 2;
+ } else
+ pr2serr("keep verbose=%d\n", clp->debug);
+#else
+ if (verbose_given && version_given)
+ pr2serr("Not in DEBUG mode, so '-vV' has no special action\n");
+#endif
+ if (version_given) {
+ pr2serr("%s%s\n", my_name, version_str);
+ return 0;
+ }
+
+ if (clp->bs <= 0) {
+ clp->bs = DEF_BLOCK_SIZE;
+ pr2serr("Assume default 'bs' ((logical) block size) of %d bytes\n",
+ clp->bs);
+ }
+ if ((ibs && (ibs != clp->bs)) || (obs && (obs != clp->bs))) {
+ pr2serr("If 'ibs' or 'obs' given must be same as 'bs'\n");
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if ((skip < 0) || (seek < 0)) {
+ pr2serr("skip and seek cannot be negative\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (clp->out_flags.append && (seek > 0)) {
+ pr2serr("Can't use both append and seek switches\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if ((clp->bpt < 1) || (clp->bpt > MAX_BPT_VALUE)) {
+ pr2serr("bpt must be > 0 and <= %d\n", MAX_BPT_VALUE);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (clp->in_flags.mmap && clp->out_flags.mmap) {
+ pr2serr("can only use mmap flag in iflag= or oflag=, not both\n");
+ return SG_LIB_SYNTAX_ERROR;
+ } else if (clp->in_flags.mmap || clp->out_flags.mmap)
+ clp->mmap_active = true;
+ /* defaulting transfer size to 128*2048 for CD/DVDs is too large
+ for the block layer in lk 2.6 and results in an EIO on the
+ SG_IO ioctl. So reduce it in that case. */
+ if ((clp->bs >= 2048) && (0 == bpt_given))
+ clp->bpt = DEF_BLOCKS_PER_2048TRANSFER;
+ if ((clp->num_threads < 1) || (clp->num_threads > MAX_NUM_THREADS)) {
+ pr2serr("too few or too many threads requested\n");
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (clp->debug > 2)
+ pr2serr("%sif=%s skip=%" PRId64 " of=%s seek=%" PRId64 " count=%"
+ PRId64 "\n", my_name, infn, skip, outfn, seek, dd_count);
+
+ install_handler(SIGINT, interrupt_handler);
+ install_handler(SIGQUIT, interrupt_handler);
+ install_handler(SIGPIPE, interrupt_handler);
+ install_handler(SIGUSR1, siginfo_handler);
+
+ clp->infd = STDIN_FILENO;
+ clp->outfd = STDOUT_FILENO;
+ if (infn[0] && ('-' != infn[0])) {
+ clp->in_type = dd_filetype(infn);
+
+ if (FT_ERROR == clp->in_type) {
+ pr2serr("%sunable to access %s\n", my_name, infn);
+ return SG_LIB_FILE_ERROR;
+ } else if (FT_ST == clp->in_type) {
+ pr2serr("%sunable to use scsi tape device %s\n", my_name, infn);
+ return SG_LIB_FILE_ERROR;
+ } else if (FT_SG == clp->in_type) {
+ clp->infd = sg_in_open(infn, &clp->in_flags, clp->bs, clp->bpt);
+ if (clp->infd < 0)
+ return -clp->infd;
+ }
+ else {
+ flags = O_RDONLY;
+ if (clp->in_flags.direct)
+ flags |= O_DIRECT;
+ if (clp->in_flags.excl)
+ flags |= O_EXCL;
+ if (clp->in_flags.dsync)
+ flags |= O_SYNC;
+
+ if ((clp->infd = open(infn, flags)) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scould not open %s for reading",
+ my_name, infn);
+ perror(ebuff);
+ return sg_convert_errno(err);
+ }
+ else if (skip > 0) {
+ off64_t offset = skip;
+
+ offset *= clp->bs; /* could exceed 32 bits here! */
+ if (lseek64(clp->infd, offset, SEEK_SET) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scouldn't skip to required "
+ "position on %s", my_name, infn);
+ perror(ebuff);
+ return sg_convert_errno(err);
+ }
+ }
+ }
+ }
+ if (outfn[0] && ('-' != outfn[0])) {
+ clp->out_type = dd_filetype(outfn);
+
+ if (FT_ST == clp->out_type) {
+ pr2serr("%sunable to use scsi tape device %s\n", my_name, outfn);
+ return SG_LIB_FILE_ERROR;
+ } else if (FT_SG == clp->out_type) {
+ clp->outfd = sg_out_open(outfn, &clp->out_flags, clp->bs,
+ clp->bpt);
+ if (clp->outfd < 0)
+ return -clp->outfd;
+ } else if (FT_DEV_NULL == clp->out_type)
+ clp->outfd = -1; /* don't bother opening */
+ else {
+ if (FT_RAW != clp->out_type) {
+ flags = O_WRONLY | O_CREAT;
+ if (clp->out_flags.direct)
+ flags |= O_DIRECT;
+ if (clp->out_flags.excl)
+ flags |= O_EXCL;
+ if (clp->out_flags.dsync)
+ flags |= O_SYNC;
+ if (clp->out_flags.append)
+ flags |= O_APPEND;
+
+ if ((clp->outfd = open(outfn, flags, 0666)) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scould not open %s for "
+ "writing", my_name, outfn);
+ perror(ebuff);
+ return sg_convert_errno(err);
+ }
+ }
+ else { /* raw output file */
+ if ((clp->outfd = open(outfn, O_WRONLY)) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scould not open %s for raw "
+ "writing", my_name, outfn);
+ perror(ebuff);
+ return sg_convert_errno(err);
+ }
+ }
+ if (seek > 0) {
+ off64_t offset = seek;
+
+ offset *= clp->bs; /* could exceed 32 bits here! */
+ if (lseek64(clp->outfd, offset, SEEK_SET) < 0) {
+ err = errno;
+ snprintf(ebuff, EBUFF_SZ, "%scouldn't seek to required "
+ "position on %s", my_name, outfn);
+ perror(ebuff);
+ return sg_convert_errno(err);
+ }
+ }
+ }
+ }
+ if ((STDIN_FILENO == clp->infd) && (STDOUT_FILENO == clp->outfd)) {
+ pr2serr("Won't default both IFILE to stdin _and_ OFILE to stdout\n");
+ pr2serr("For more information use '--help'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (dd_count < 0) {
+ in_num_sect = -1;
+ if (FT_SG == clp->in_type) {
+ res = scsi_read_capacity(clp->infd, &in_num_sect, &in_sect_sz);
+ if (2 == res) {
+ pr2serr("Unit attention, media changed(in), continuing\n");
+ res = scsi_read_capacity(clp->infd, &in_num_sect,
+ &in_sect_sz);
+ }
+ if (0 != res) {
+ if (res == SG_LIB_CAT_INVALID_OP)
+ pr2serr("read capacity not supported on %s\n", infn);
+ else if (res == SG_LIB_CAT_NOT_READY)
+ pr2serr("read capacity failed, %s not ready\n", infn);
+ else
+ pr2serr("Unable to read capacity on %s\n", infn);
+ in_num_sect = -1;
+ }
+ } else if (FT_BLOCK == clp->in_type) {
+ if (0 != read_blkdev_capacity(clp->infd, &in_num_sect,
+ &in_sect_sz)) {
+ pr2serr("Unable to read block capacity on %s\n", infn);
+ in_num_sect = -1;
+ }
+ if (clp->bs != in_sect_sz) {
+ pr2serr("logical block size on %s confusion; bs=%d, from "
+ "device=%d\n", infn, clp->bs, in_sect_sz);
+ in_num_sect = -1;
+ }
+ }
+ if (in_num_sect > skip)
+ in_num_sect -= skip;
+
+ out_num_sect = -1;
+ if (FT_SG == clp->out_type) {
+ res = scsi_read_capacity(clp->outfd, &out_num_sect, &out_sect_sz);
+ if (2 == res) {
+ pr2serr("Unit attention, media changed(out), continuing\n");
+ res = scsi_read_capacity(clp->outfd, &out_num_sect,
+ &out_sect_sz);
+ }
+ if (0 != res) {
+ if (res == SG_LIB_CAT_INVALID_OP)
+ pr2serr("read capacity not supported on %s\n", outfn);
+ else if (res == SG_LIB_CAT_NOT_READY)
+ pr2serr("read capacity failed, %s not ready\n", outfn);
+ else
+ pr2serr("Unable to read capacity on %s\n", outfn);
+ out_num_sect = -1;
+ }
+ } else if (FT_BLOCK == clp->out_type) {
+ if (0 != read_blkdev_capacity(clp->outfd, &out_num_sect,
+ &out_sect_sz)) {
+ pr2serr("Unable to read block capacity on %s\n", outfn);
+ out_num_sect = -1;
+ }
+ if (clp->bs != out_sect_sz) {
+ pr2serr("logical block size on %s confusion: bs=%d, from "
+ "device=%d\n", outfn, clp->bs, out_sect_sz);
+ out_num_sect = -1;
+ }
+ }
+ if (out_num_sect > seek)
+ out_num_sect -= seek;
+
+ if (in_num_sect > 0) {
+ if (out_num_sect > 0)
+ dd_count = (in_num_sect > out_num_sect) ? out_num_sect :
+ in_num_sect;
+ else
+ dd_count = in_num_sect;
+ }
+ else
+ dd_count = out_num_sect;
+ }
+ if (clp->debug > 1)
+ pr2serr("Start of loop, count=%" PRId64 ", in_num_sect=%" PRId64
+ ", out_num_sect=%" PRId64 "\n", dd_count, in_num_sect,
+ out_num_sect);
+ if (dd_count < 0) {
+ pr2serr("Couldn't calculate count, please give one\n");
+ return SG_LIB_CAT_OTHER;
+ }
+ if (! cdbsz_given) {
+ if ((FT_SG == clp->in_type) && (MAX_SCSI_CDBSZ != clp->cdbsz_in) &&
+ (((dd_count + skip) > UINT_MAX) || (clp->bpt > USHRT_MAX))) {
+ pr2serr("Note: SCSI command size increased to 16 bytes (for "
+ "'if')\n");
+ clp->cdbsz_in = MAX_SCSI_CDBSZ;
+ }
+ if ((FT_SG == clp->out_type) && (MAX_SCSI_CDBSZ != clp->cdbsz_out) &&
+ (((dd_count + seek) > UINT_MAX) || (clp->bpt > USHRT_MAX))) {
+ pr2serr("Note: SCSI command size increased to 16 bytes (for "
+ "'of')\n");
+ clp->cdbsz_out = MAX_SCSI_CDBSZ;
+ }
+ }
+
+ clp->in_count = dd_count;
+ clp->in_rem_count = dd_count;
+ clp->skip = skip;
+ clp->in_blk = skip;
+ clp->out_count = dd_count;
+ clp->out_rem_count = dd_count;
+ clp->seek = seek;
+ status = pthread_mutex_init(&clp->inout_mutex, NULL);
+ if (0 != status) err_exit(status, "init inout_mutex");
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock inout_mutex");
+ clp->out_blk = seek;
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock inout_mutex");
+
+ status = pthread_cond_init(&clp->out_sync_cv, NULL);
+ if (0 != status) err_exit(status, "init out_sync_cv");
+
+ if (clp->dry_run > 0) {
+ pr2serr("Due to --dry-run option, bypass copy/read\n");
+ goto fini;
+ }
+ sigemptyset(&signal_set);
+ sigaddset(&signal_set, SIGINT);
+ status = pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
+ if (0 != status) err_exit(status, "pthread_sigmask");
+ status = pthread_create(&sig_listen_thread_id, NULL,
+ sig_listen_thread, (void *)clp);
+ if (0 != status) err_exit(status, "pthread_create, sig...");
+
+ if (do_time) {
+ start_tm.tv_sec = 0;
+ start_tm.tv_usec = 0;
+ gettimeofday(&start_tm, NULL);
+ }
+
+/* vvvvvvvvvvv Start worker threads vvvvvvvvvvvvvvvvvvvvvvvv */
+ if ((clp->out_rem_count > 0) && (clp->num_threads > 0)) {
+ /* Run 1 work thread to shake down infant retryable stuff */
+ status = pthread_mutex_lock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "lock out_mutex");
+ seek_skip = clp->seek - clp->skip;
+ thr_arg_a[0].id = 0;
+ thr_arg_a[0].seek_skip = seek_skip;
+ status = pthread_create(&threads[0], NULL, read_write_thread,
+ (void *)(thr_arg_a + 0));
+ if (0 != status) err_exit(status, "pthread_create");
+ if (clp->debug)
+ pr2serr("Starting worker thread k=0\n");
+
+ /* wait for any broadcast */
+ pthread_cleanup_push(cleanup_out, (void *)clp);
+ status = pthread_cond_wait(&clp->out_sync_cv, &clp->inout_mutex);
+ if (0 != status) err_exit(status, "cond out_sync_cv");
+ pthread_cleanup_pop(0);
+ status = pthread_mutex_unlock(&clp->inout_mutex);
+ if (0 != status) err_exit(status, "unlock out_mutex");
+
+ /* now start the rest of the threads */
+ for (k = 1; k < clp->num_threads; ++k) {
+
+ thr_arg_a[k].id = k;
+ thr_arg_a[k].seek_skip = seek_skip;
+ status = pthread_create(&threads[k], NULL, read_write_thread,
+ (void *)(thr_arg_a + k));
+ if (0 != status) err_exit(status, "pthread_create");
+ if (clp->debug > 2)
+ pr2serr("Starting worker thread k=%d\n", k);
+ }
+
+ /* now wait for worker threads to finish */
+ for (k = 0; k < clp->num_threads; ++k) {
+ status = pthread_join(threads[k], &vp);
+ if (0 != status) err_exit(status, "pthread_join");
+ if (clp->debug > 2)
+ pr2serr("Worker thread k=%d terminated\n", k);
+ }
+ } /* started worker threads and here after they have all exited */
+
+ if (do_time && (start_tm.tv_sec || start_tm.tv_usec))
+ calc_duration_throughput(0);
+
+ if (do_sync) {
+ if (FT_SG == clp->out_type) {
+ pr2serr(">> Synchronizing cache on %s\n", outfn);
+ res = sg_ll_sync_cache_10(clp->outfd, 0, 0, 0, 0, 0, false, 0);
+ if (SG_LIB_CAT_UNIT_ATTENTION == res) {
+ pr2serr("Unit attention(out), continuing\n");
+ res = sg_ll_sync_cache_10(clp->outfd, 0, 0, 0, 0, 0, false,
+ 0);
+ }
+ if (0 != res)
+ pr2serr("Unable to synchronize cache\n");
+ }
+ }
+
+#if 0
+#if SG_LIB_ANDROID
+ /* Android doesn't have pthread_cancel() so use pthread_kill() instead.
+ * Also there is no need to link with -lpthread in Android */
+ status = pthread_kill(sig_listen_thread_id, SIGUSR1);
+ if (0 != status) err_exit(status, "pthread_kill");
+#else
+ status = pthread_cancel(sig_listen_thread_id);
+ if (0 != status) err_exit(status, "pthread_cancel");
+#endif
+#endif /* 0, because always do pthread_kill() next */
+
+ shutting_down = true;
+ status = pthread_kill(sig_listen_thread_id, SIGINT);
+ if (0 != status) err_exit(status, "pthread_kill");
+ /* valgrind says the above _kill() leaks; web says it needs a following
+ * _join() to clear heap taken by associated _create() */
+
+fini:
+ if ((STDIN_FILENO != clp->infd) && (clp->infd >= 0))
+ close(clp->infd);
+ if ((STDOUT_FILENO != clp->outfd) && (FT_DEV_NULL != clp->out_type)) {
+ if (clp->outfd >= 0)
+ close(clp->outfd);
+ }
+ res = exit_status;
+ if ((0 != clp->out_count) && (0 == clp->dry_run)) {
+ pr2serr(">>>> Some error occurred, remaining blocks=%" PRId64 "\n",
+ clp->out_count);
+ if (0 == res)
+ res = SG_LIB_CAT_OTHER;
+ }
+ print_stats("");
+ if (clp->dio_incomplete_count) {
+ int fd;
+ char c;
+
+ pr2serr(">> Direct IO requested but incomplete %d times\n",
+ clp->dio_incomplete_count);
+ if ((fd = open(sg_allow_dio, O_RDONLY)) >= 0) {
+ if (1 == read(fd, &c, 1)) {
+ if ('0' == c)
+ pr2serr(">>> %s set to '0' but should be set to '1' for "
+ "direct IO\n", sg_allow_dio);
+ }
+ close(fd);
+ }
+ }
+ if (clp->sum_of_resids)
+ pr2serr(">> Non-zero sum of residual counts=%d\n",
+ clp->sum_of_resids);
+#ifdef HAVE_C11_ATOMICS
+ {
+ unsigned int ui;
+
+ if ((ui = atomic_load(&num_eagain)) > 0)
+ pr2serr(">> number of IO call yielding EAGAIN %u\n", ui);
+ if ((ui = atomic_load(&num_ebusy)) > 0)
+ pr2serr(">> number of IO call yielding EBUSY %u\n", ui);
+ if ((ui = atomic_load(&num_eintr)) > 0)
+ pr2serr(">> number of IO call yielding EINTR %u\n", ui);
+ }
+#endif
+ return (res >= 0) ? res : SG_LIB_CAT_OTHER;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 15:53:18 +0000