/* 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 #include #include #include #include #include #include #include #include #include #include #include #define __STDC_FORMAT_MACROS 1 #include #include #include #include #include #ifndef major #include #endif #include #include /* for MEM_MAJOR, SCSI_GENERIC_MAJOR, etc */ #include /* 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 #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 or ). */ 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; }