sg_ses: fix crash when 'm LEN' < 252

Cleanups suggested cppcheck


git-svn-id: https://svn.bingwo.ca/repos/sg3_utils/trunk@907 6180dd3e-e324-4e3e-922d-17de1ae2f315

7 files changed, 98 insertions, 113 deletions

diff --git a/testing/sg_iovec_tst.cpp b/testing/sg_iovec_tst.cpp
index 73c6168c..6228b9eb 100644
--- a/testing/sg_iovec_tst.cpp
+++ b/testing/sg_iovec_tst.cpp
@@ -151,8 +151,7 @@ sg_read(int sg_fd, uint8_t * buff, int num_blocks, int from_block, int bs,
     struct sg_io_hdr io_hdr;
     struct pollfd a_poll;
     int dxfer_len = bs * num_blocks;
-    int k, pos, rem, res;
-    char b[128];
+    int k, pos, rem;
 
     sg_put_unaligned_be32((uint32_t)from_block, rdCmd + 2);
     sg_put_unaligned_be16((uint16_t)num_blocks, rdCmd + 7);
@@ -185,12 +184,16 @@ sg_read(int sg_fd, uint8_t * buff, int num_blocks, int from_block, int bs,
     io_hdr.sbp = senseBuff;
     io_hdr.timeout = DEF_TIMEOUT;
     io_hdr.pack_id = from_block;
-    if (verbose)
+    if (verbose) {
+        char b[128];
+
         fprintf(stderr, "cdb: %s\n", sg_get_command_str(rdCmd, 10, true,
                 sizeof(b), b));
+    }
 
     if (async) {
-        res = write(sg_fd, &io_hdr, sizeof(io_hdr));
+        int res = write(sg_fd, &io_hdr, sizeof(io_hdr));
+
         if (res < 0) {
             perror("write(<sg_device>), error");
             return -1;
@@ -253,7 +256,6 @@ sg_read_v4(int sg_fd, uint8_t * buff, int num_blocks, int from_block, int bs,
     struct pollfd a_poll;
     int dxfer_len = bs * num_blocks;
     int k, pos, rem, res;
-    char b[128];
 
     sg_put_unaligned_be32((uint32_t)from_block, rdCmd + 2);
     sg_put_unaligned_be16((uint16_t)num_blocks, rdCmd + 7);
@@ -285,10 +287,12 @@ sg_read_v4(int sg_fd, uint8_t * buff, int num_blocks, int from_block, int bs,
     io_hdr.response = (uint64_t)(uintptr_t)senseBuff;
     io_hdr.timeout = DEF_TIMEOUT;
     io_hdr.request_extra = from_block;   /* pack_id */
-    if (verbose)
+    if (verbose) {
+        char b[128];
+
         fprintf(stderr, "cdb: %s\n", sg_get_command_str(rdCmd, 10, true,
                 sizeof(b), b));
-
+    }
     if (async) {
         res = ioctl(sg_fd, SG_IOSUBMIT, &io_hdr);
         if (res < 0) {
diff --git a/testing/sg_mrq_dd.cpp b/testing/sg_mrq_dd.cpp
index 2f1aff94..4dc1f54c 100644
--- a/testing/sg_mrq_dd.cpp
+++ b/testing/sg_mrq_dd.cpp
@@ -30,7 +30,7 @@
  *
  */
 
-static const char * version_str = "1.32 20210627";
+static const char * version_str = "1.33 20210730";
 
 #define _XOPEN_SOURCE 600
 #ifndef _GNU_SOURCE
@@ -1797,7 +1797,6 @@ read_write_thread(struct global_collection * clp, int thr_idx, int slice_idx,
             clp->processed = true;
         }   /* this unlocks lk */
         clp->infant_cv.notify_one();
-        singleton = false;
     }
     if (res < 0) {
         if (seg_blks >= 0)
@@ -2235,9 +2234,8 @@ process_mrq_response(Rq_elem * rep, const struct sg_io_v4 * ctl_v4p,
     }   /* end of request array scan loop */
     if ((n_subm == num_mrq) || (vb < 3))
         goto fini;
-    if (vb)
-        pr2serr_lk("[%d] checking response array _beyond_ number of "
-                   "submissions [%d] to num_mrq:\n", id, k);
+    pr2serr_lk("[%d] checking response array _beyond_ number of "
+               "submissions [%d] to num_mrq:\n", id, k);
     for (all_good = true; k < num_mrq; ++k, ++a_v4p) {
         if (SG_INFO_MRQ_FINI & a_v4p->info) {
             pr2serr_lk("[%d] a_v4[%d]: unexpected SG_INFO_MRQ_FINI set [%s]\n",
@@ -3386,7 +3384,7 @@ process_flags(const char * arg, struct flags_t * fp)
             fp->no_dur = true;
         else if (0 == strcmp(cp, "no_dur"))
             fp->no_dur = true;
-        else if (0 == strcmp(cp, "no_dur"))
+        else if (0 == strcmp(cp, "no-dur"))
             fp->no_dur = true;
         else if (0 == strcmp(cp, "nothresh"))
             fp->no_thresh = true;
@@ -3716,8 +3714,8 @@ parse_cmdline_sanity(int argc, char * argv[], struct global_collection * clp,
                 goto syn_err;
             }
             seek_buf = (char *)calloc(n + 16, 1);
-	    if (NULL == seek_buf)
-		goto syn_err;
+            if (NULL == seek_buf)
+                goto syn_err;
             memcpy(seek_buf, buf, n + 1);
         } else if (0 == strcmp(key, "skip")) {
             n = strlen(buf);
@@ -3726,8 +3724,8 @@ parse_cmdline_sanity(int argc, char * argv[], struct global_collection * clp,
                 goto syn_err;
             }
             skip_buf = (char *)calloc(n + 16, 1);
-	    if (NULL == skip_buf)
-		goto syn_err;
+            if (NULL == skip_buf)
+                goto syn_err;
             memcpy(skip_buf, buf, n + 1);
         } else if (0 == strcmp(key, "sync"))
             do_sync = !! sg_get_num(buf);
diff --git a/testing/sg_scat_gath.cpp b/testing/sg_scat_gath.cpp
index b5edc481..e9aa633d 100644
--- a/testing/sg_scat_gath.cpp
+++ b/testing/sg_scat_gath.cpp
@@ -418,7 +418,6 @@ void
 scat_gath_list::dbg_print(bool skip_meta, const char * id_str, bool to_stdout,
                           bool show_sgl) const
 {
-    int k;
     int num = sgl.size();
     const char * caller = id_str ? id_str : "unknown";
     FILE * fp = to_stdout ? stdout : stderr;
@@ -435,6 +434,8 @@ scat_gath_list::dbg_print(bool skip_meta, const char * id_str, bool to_stdout,
     fprintf(fp, "  >> %s scatter gather list (%d element%s):\n", caller, num,
             (num == 1 ? "" : "s"));
     if (show_sgl) {
+        int k;
+
         for (k = 0; k < num; ++k) {
             const class scat_gath_elem & sge = sgl[k];
 
@@ -622,7 +623,6 @@ sgls_eq_off(const scat_gath_list & left, int l_e_ind, int l_blk_off,
             const scat_gath_list & right, int r_e_ind, int r_blk_off,
             bool allow_partial)
 {
-    int lrem, rrem;
     int lelems = left.sgl.size();
     int relems = right.sgl.size();
 
@@ -630,8 +630,10 @@ sgls_eq_off(const scat_gath_list & left, int l_e_ind, int l_blk_off,
         if ((left.sgl[l_e_ind].lba + l_blk_off) !=
             (right.sgl[r_e_ind].lba + r_blk_off))
             return false;
-        lrem = left.sgl[l_e_ind].num - l_blk_off;
-        rrem = right.sgl[r_e_ind].num - r_blk_off;
+
+        int lrem = left.sgl[l_e_ind].num - l_blk_off;
+        int rrem = right.sgl[r_e_ind].num - r_blk_off;
+
         if (lrem == rrem) {
             ++l_e_ind;
             l_blk_off = 0;
@@ -726,7 +728,6 @@ scat_gath_iter::set_by_blk_idx(int64_t _blk_idx)
     int k;
     const int elems = sglist.sgl.size();
     const int last_ind = elems - 1;
-    uint32_t num;
     int64_t bc = _blk_idx;
 
     if (bc < 0)
@@ -740,8 +741,8 @@ scat_gath_iter::set_by_blk_idx(int64_t _blk_idx)
     } else
         k = 0;
     for (first = true; k < elems; ++k, first = false) {
-        num = ((k == last_ind) && extend_last) ? MAX_SGL_NUM_VAL :
-                                                 sglist.sgl[k].num;
+        uint32_t num = ((k == last_ind) && extend_last) ? MAX_SGL_NUM_VAL :
+                                                          sglist.sgl[k].num;
         if (first) {
             if ((int64_t)(num - it_blk_off) < bc)
                 bc -= (num - it_blk_off);
@@ -780,14 +781,13 @@ scat_gath_iter::add_blks(uint64_t blk_count)
     int k;
     const int elems = sglist.sgl.size();
     const int last_ind = elems - 1;
-    uint32_t num;
     uint64_t bc = blk_count;
 
     if (0 == bc)
         return true;
     for (first = true, k = it_el_ind; k < elems; ++k) {
-        num = ((k == last_ind) && extend_last) ? MAX_SGL_NUM_VAL :
-                                                 sglist.sgl[k].num;
+        uint32_t num = ((k == last_ind) && extend_last) ? MAX_SGL_NUM_VAL :
+                                                          sglist.sgl[k].num;
         if (first) {
             first = false;
             if ((uint64_t)(num - it_blk_off) <= bc)
diff --git a/testing/sg_scat_gath.h b/testing/sg_scat_gath.h
index e864bf8b..d316a7b1 100644
--- a/testing/sg_scat_gath.h
+++ b/testing/sg_scat_gath.h
@@ -105,7 +105,7 @@ private:
 
 class scat_gath_iter {
 public:
-    scat_gath_iter(const scat_gath_list & my_scat_gath_list);
+    explicit scat_gath_iter(const scat_gath_list & my_scat_gath_list);
     scat_gath_iter(const scat_gath_iter & src) = default;
     scat_gath_iter&  operator=(const scat_gath_iter&) = delete;
     ~scat_gath_iter() = default;
diff --git a/testing/sg_tst_async.cpp b/testing/sg_tst_async.cpp
index 2a3b54a8..acef7e04 100644
--- a/testing/sg_tst_async.cpp
+++ b/testing/sg_tst_async.cpp
@@ -137,7 +137,7 @@ using namespace std::chrono;
 #define DEF_DIRECT false        /* true: direct_io */
 #define DEF_MMAP_IO false       /* true: mmap-ed IO with sg */
 #define DEF_NO_XFER 0
-#define DEF_LBA 1000
+#define DEF_LBA 1000U
 
 #define MAX_Q_PER_FD 16383      /* sg driver per file descriptor limit */
 #define MAX_CONSEC_NOMEMS 4     /* was 16 */
@@ -432,13 +432,13 @@ static unsigned int
 get_urandom_uint(void)
 {
     unsigned int res = 0;
-    int n;
-    uint8_t b[sizeof(unsigned int)];
     lock_guard<mutex> lg(rand_lba_mutex);
 
     int fd = open(URANDOM_DEV, O_RDONLY);
     if (fd >= 0) {
-        n = read(fd, b, sizeof(unsigned int));
+        uint8_t b[sizeof(unsigned int)];
+        int n = read(fd, b, sizeof(unsigned int));
+
         if (sizeof(unsigned int) == n)
             memcpy(&res, b, sizeof(unsigned int));
         close(fd);
@@ -965,10 +965,9 @@ work_thread(int id, struct opts_t * op)
     int open_flags = O_RDWR;
     int thr_async_starts = 0;
     int thr_async_finishes = 0;
-    int thr_ovn_force_read = 0;
     int vb = op->verbose;
     int k, n, res, sg_fd, num_outstanding, do_inc, npt, pack_id, sg_flags;
-    int num_waiting_read, num_to_read, sz, ern, encore_pack_id, ask, j, m, o;
+    int num_waiting_read, sz, encore_pack_id, ask, j, m, o;
     int prev_pack_id, blk_sz;
     unsigned int thr_enomem_count = 0;
     unsigned int thr_start_eagain_count = 0;
@@ -977,7 +976,6 @@ work_thread(int id, struct opts_t * op)
     unsigned int thr_fin_eagain_count = 0;
     unsigned int thr_fin_ebusy_count = 0;
     unsigned int thr_start_edom_count = 0;
-    unsigned int seed = 0;
     int needed_sz = op->lb_sz * op->num_lbs;
     unsigned int nanosecs;
     unsigned int hi_lba;
@@ -1112,7 +1110,8 @@ work_thread(int id, struct opts_t * op)
         wrkMmap = (uint8_t *)mmap(NULL, needed_sz, PROT_READ | PROT_WRITE,
                                   MAP_SHARED, sg_fd, 0);
         if (MAP_FAILED == wrkMmap) {
-            ern = errno;
+            int ern = errno;
+
             pr2serr_lk("t_id=%d: mmap() failed, errno=%d\n", id, ern);
             return;
         }
@@ -1120,7 +1119,8 @@ work_thread(int id, struct opts_t * op)
     pfd[0].fd = sg_fd;
     pfd[0].events = POLLIN;
     if (is_rw && hi_lba) {
-        seed = get_urandom_uint();
+        unsigned int seed = get_urandom_uint();
+
         if (vb > 1)
             pr2serr_lk("  id=%d, /dev/urandom seed=0x%x\n", id, seed);
         ruip = new Rand_uint((unsigned int)op->lba, hi_lba, seed);
@@ -1153,6 +1153,8 @@ work_thread(int id, struct opts_t * op)
      * no more outstanding responses */
     for (k = 0, m = 0, o=0, num_outstanding = 0; (k < npt) || num_outstanding;
          k = do_inc ? k + 1 : k, ++o) {
+        int num_to_read = 0;
+
         if (do_inc)
             m = 0;
         else {
@@ -1336,7 +1338,6 @@ work_thread(int id, struct opts_t * op)
                 pr2serr_lk("%d->id: free_lst.size() over 6000 (b)\n", id);
             }
         }
-        num_to_read = 0;
         if (need_finish) {
             num_waiting_read = 0;
             if (ioctl(sg_fd, SG_GET_NUM_WAITING, &num_waiting_read) < 0) {
@@ -1579,9 +1580,6 @@ work_thread(int id, struct opts_t * op)
     if ((vb > 2) && (k > 0))
         pr2serr_lk("%d->id: Maximum number of READ/WRITEs queued: %d\n",
                    id, k);
-    if (vb && (thr_ovn_force_read > 0))
-        pr2serr_lk("%d->id: Number of ovn (override number) forced reads: "
-                   "%d\n", id, thr_ovn_force_read);
     async_starts += thr_async_starts;
     async_finishes += thr_async_finishes;
     start_eagain_count += thr_start_eagain_count;
@@ -1742,15 +1740,13 @@ int
 main(int argc, char * argv[])
 {
     bool maxq_per_thread_given = false;
-    int k, n, c, res;
+    int n;
     int force = 0;
     int64_t ll;
     int num_threads = DEF_NUM_THREADS;
-    char b[128];
     struct timespec start_tm, end_tm;
     struct opts_t * op;
     const char * cp;
-    const char * dev_name;
 
     op = &a_opts;
 #if 0
@@ -1775,6 +1771,7 @@ main(int argc, char * argv[])
 
     while (1) {
         int option_index = 0;
+        int c;
 
         c = getopt_long(argc, argv,
                         "34acdefghl:L:mM:n:NO:pq:Q:Rs:St:TuvVw:W",
@@ -1992,10 +1989,8 @@ main(int argc, char * argv[])
         }
     }
     if (optind < argc) {
-        if (optind < argc) {
-            for (; optind < argc; ++optind)
-                op->dev_names.push_back(argv[optind]);
-        }
+        for (; optind < argc; ++optind)
+            op->dev_names.push_back(argv[optind]);
     }
 #ifdef DEBUG
     pr2serr_lk("In DEBUG mode, ");
@@ -2054,12 +2049,16 @@ main(int argc, char * argv[])
     }
 
     try {
-        int sg_ver_num;
+        int k, sg_ver_num;
         unsigned int last_lba;
         unsigned int blk_sz;
         struct stat a_stat;
 
         for (k = 0; k < (int)op->dev_names.size(); ++k) {
+            int res;
+            const char * dev_name;
+            char b[128];
+
             dev_name = op->dev_names[k];
             if (stat(dev_name, &a_stat) < 0) {
                 snprintf(b, sizeof(b), "could not stat() %s", dev_name);
diff --git a/testing/sg_tst_context.cpp b/testing/sg_tst_context.cpp
index a6948c0e..6f95717e 100644
--- a/testing/sg_tst_context.cpp
+++ b/testing/sg_tst_context.cpp
@@ -277,9 +277,7 @@ work_thread(const char * dev_name, int id, int num, bool share,
     int res = 0;
     unsigned int thr_even_notreadys = 0;
     unsigned int thr_odd_notreadys = 0;
-    unsigned int thr_ebusy_count = 0;
     struct sg_pt_base * ptp = NULL;
-    char ebuff[EBUFF_SZ];
 
     {
         lock_guard<mutex> lg(console_mutex);
@@ -289,6 +287,7 @@ work_thread(const char * dev_name, int id, int num, bool share,
     }
     if (! share) {      /* ignore passed ptp, make this thread's own */
         int oflags = O_RDWR;
+        unsigned int thr_ebusy_count = 0;
 
         if (nonblock)
             oflags |= O_NONBLOCK;
@@ -300,6 +299,8 @@ work_thread(const char * dev_name, int id, int num, bool share,
             this_thread::yield();       // give other threads a chance
         }
         if (pt_fd < 0) {
+            char ebuff[EBUFF_SZ];
+
             snprintf(ebuff, EBUFF_SZ, "work_thread id=%d: error opening: %s",
                      id, dev_name);
             perror(ebuff);
@@ -379,7 +380,6 @@ main(int argc, char * argv[])
     bool share = false;
     int num_threads = DEF_NUM_THREADS;
     char * dev_name = NULL;
-    char ebuff[EBUFF_SZ];
 
     for (k = 1; k < argc; ++k) {
         if (0 == memcmp("-e", argv[k], 2))
@@ -446,6 +446,8 @@ main(int argc, char * argv[])
                 sleep(0);                   // process yield ??
             }
             if (pt_fd < 0) {
+                char ebuff[EBUFF_SZ];
+
                 snprintf(ebuff, EBUFF_SZ, "main: error opening: %s",
                          dev_name);
                 perror(ebuff);
diff --git a/testing/sgh_dd.cpp b/testing/sgh_dd.cpp
index 4610caef..c2d1e7ae 100644
--- a/testing/sgh_dd.cpp
+++ b/testing/sgh_dd.cpp
@@ -36,7 +36,7 @@
  * renamed [20181221]
  */
 
-static const char * version_str = "2.12 20210727";
+static const char * version_str = "2.13 20210730";
 
 #define _XOPEN_SOURCE 600
 #ifndef _GNU_SOURCE
@@ -987,7 +987,7 @@ calc_duration_throughput(int contin)
 static void
 print_stats(const char * str)
 {
-    int64_t infull, outfull;
+    int64_t infull;
 
     if (0 != gcoll.out_rem_count.load())
         pr2serr("  remaining block count=%" PRId64 "\n",
@@ -999,7 +999,8 @@ print_stats(const char * str)
     if (gcoll.out_type == FT_DEV_NULL)
         pr2serr("%s0+0 records out\n", str);
     else {
-        outfull = dd_count - gcoll.out_rem_count.load();
+        int64_t outfull = dd_count - gcoll.out_rem_count.load();
+
         pr2serr("%s%" PRId64 "+%d records %s\n", str,
                 outfull - gcoll.out_partial.load(), gcoll.out_partial.load(),
                 (gcoll.verify ? "verified" : "out"));
@@ -1218,7 +1219,6 @@ sig_listen_thread(void * v_clp)
 {
     bool stall_reported = false;
     int prev_pack_id = 0;
-    int sig_number, pack_id;
     struct timespec ts;
     struct timespec * tsp = &ts;
     struct global_collection * clp = (struct global_collection *)v_clp;
@@ -1227,13 +1227,15 @@ sig_listen_thread(void * v_clp)
     tsp->tv_sec = ict_ms / 1000;
     tsp->tv_nsec = (ict_ms % 1000) * 1000 * 1000;   /* DEF_SDT_ICT_MS */
     while (1) {
-        sig_number = sigtimedwait(&signal_set, NULL, tsp);
+        int sig_number = sigtimedwait(&signal_set, NULL, tsp);
+
         if (sig_number < 0) {
             int err = errno;
 
             /* EAGAIN implies a timeout */
             if ((EAGAIN == err) && (clp->sdt_crt > 0)) {
-                pack_id = mono_pack_id.load();
+                int pack_id = mono_pack_id.load();
+
                 if ((pack_id > 0) && (pack_id == prev_pack_id)) {
                     if (! stall_reported) {
                         stall_reported = true;
@@ -1264,37 +1266,6 @@ sig_listen_thread(void * v_clp)
     if (clp->verbose > 1)
         pr2serr_lk("%s: exiting\n", __func__);
 
-
-#if 0
-
-
-            if (EAGAIN == err) { /* timeout */
-                pack_id = mono_pack_id.load();
-                if (pack_id == prev_pack_id) {
-                    if (! stall_reported) {
-                        stall_reported = true;
-                        tsp->tv_sec = 2;
-                        tsp->tv_nsec = 0;
-                        pr2serr_lk("%s: first stall at pack_id=%d "
-                                   "detected\n", __func__, pack_id);
-                    } else
-                        pr2serr_lk("%s: subsequent stall at pack_id=%d\n",
-                                   __func__, pack_id);
-                    system_wrapper("/usr/bin/cat /proc/scsi/sg/debug\n");
-                } else
-                    prev_pack_id = pack_id;
-            } else
-                pr2serr_lk("%s: sigtimedwait() errno=%d\n", __func__, err);
-        }
-        if (SIGINT == sig_number) {
-            pr2serr_lk("%sinterrupted by SIGINT\n", my_name);
-            stop_both(clp);
-            pthread_cond_broadcast(&clp->out_sync_cv);
-        }
-    }
-    if (clp->verbose > 1)
-        pr2serr_lk("%s: exiting\n", __func__);
-#endif
     return NULL;
 }
 
@@ -1524,8 +1495,7 @@ read_write_thread(void * v_tip)
     if (vb > 2)
         pr2serr_lk("%d <-- Starting worker thread\n", rep->id);
     if (! (in_mmap || out_mmap)) {
-        int n = sz;
-
+        n = sz;
         if (clp->unbalanced_mrq)
             n *= clp->nmrqs;
         rep->buffp = sg_memalign(n, 0 /* page align */, &rep->alloc_bp,
@@ -1659,6 +1629,9 @@ read_write_thread(void * v_tip)
                                    "to_do=%u\n", rep->id,
                                    (uint32_t)deferred_arr.first.size());
                     res = sgh_do_deferred_mrq(rep, deferred_arr);
+                    if (res)
+                        pr2serr_lk("%s tid=%d: sgh_do_deferred_mrq failed\n",
+                                   __func__, rep->id);
                 }
                 break;  /* at or beyond end, so leave loop >>>>>>>>>>  */
             } else if ((my_index + clp->bpt) > dd_count)
@@ -1771,6 +1744,9 @@ skip_force_out_sequence:
                     pr2serr_lk("thread=%d: tail-end, to_do=%u\n", rep->id,
                                (uint32_t)deferred_arr.first.size());
                 res = sgh_do_deferred_mrq(rep, deferred_arr);
+                if (res)
+                    pr2serr_lk("%s tid=%d: sgh_do_deferred_mrq failed\n",
+                               __func__, rep->id);
             }
             clp->out_stop = true;
             stop_after_write = true;
@@ -1792,7 +1768,7 @@ skip_force_out_sequence:
 fini:
     if ((1 == rep->mmap_active) && (rep->mmap_len > 0)) {
         if (munmap(rep->buffp, rep->mmap_len) < 0) {
-            int err = errno;
+            err = errno;
             char bb[STRERR_BUFF_LEN + 1];
 
             pr2serr_lk("thread=%d: munmap() failed: %s\n", rep->id,
@@ -1805,8 +1781,8 @@ fini:
     }
     if (rep->alloc_bp) {
         free(rep->alloc_bp);
-	rep->alloc_bp = NULL;
-	rep->buffp = NULL;
+        rep->alloc_bp = NULL;
+        rep->buffp = NULL;
     }
 
     if (sg_version_ge_40045) {
@@ -1862,7 +1838,6 @@ normal_in_rd(Rq_elem * rep, int blocks)
     bool stop_after_write = false;
     bool same_fds = clp->in_flags.same_fds || clp->out_flags.same_fds;
     int res;
-    char strerr_buff[STRERR_BUFF_LEN + 1];
 
     if (clp->verbose > 4)
         pr2serr_lk("%s: tid=%d: iblk=%" PRIu64 ", blocks=%d\n", __func__,
@@ -1904,6 +1879,8 @@ normal_in_rd(Rq_elem * rep, int blocks)
            ((EINTR == errno) || (EAGAIN == errno)))
         std::this_thread::yield();/* another thread may be able to progress */
     if (res < 0) {
+        char strerr_buff[STRERR_BUFF_LEN + 1];
+
         if (clp->in_flags.coe) {
             memset(rep->buffp, 0, rep->num_blks * clp->bs);
             pr2serr_lk("tid=%d: >> substituted zeros for in blk=%" PRId64
@@ -1944,7 +1921,6 @@ normal_out_wr(Rq_elem * rep, int blocks)
 {
     int res;
     struct global_collection * clp = rep->clp;
-    char strerr_buff[STRERR_BUFF_LEN + 1];
 
     /* enters holding out_mutex */
     if (clp->verbose > 4)
@@ -1954,6 +1930,8 @@ normal_out_wr(Rq_elem * rep, int blocks)
             < 0) && ((EINTR == errno) || (EAGAIN == errno)))
         std::this_thread::yield();/* another thread may be able to progress */
     if (res < 0) {
+        char strerr_buff[STRERR_BUFF_LEN + 1];
+
         if (clp->out_flags.coe) {
             pr2serr_lk("tid=%d: >> ignored error for out blk=%" PRId64
                        " for %d bytes, %s\n", rep->id, rep->oblk,
@@ -2068,10 +2046,11 @@ static void
 sg_in_rd_cmd(struct global_collection * clp, Rq_elem * rep,
              mrq_arr_t & def_arr)
 {
-    int res, status, pack_id;
+    int status, pack_id;
 
     while (1) {
-        res = sg_start_io(rep, def_arr, pack_id, NULL);
+        int res = sg_start_io(rep, def_arr, pack_id, NULL);
+
         if (1 == res)
             err_exit(ENOMEM, "sg starting in command");
         else if (res < 0) {
@@ -2419,11 +2398,8 @@ process_mrq_response(Rq_elem * rep, const struct sg_io_v4 * ctl_v4p,
 
             if (sg_scsi_normalize_sense(sbp, slen, &ssh) &&
                 (ssh.response_code >= 0x70)) {
-                char b[256];
-
-                if (ssh.response_code & 0x1) {
+                if (ssh.response_code & 0x1)
                     ok = true;
-                }
                 if (vb) {
                     sg_get_sense_str("  ", sbp, slen, false, blen, b);
                     pr2serr_lk("[%d] a_v4[%d]:\n%s\n", id, k, b);
@@ -2442,9 +2418,8 @@ process_mrq_response(Rq_elem * rep, const struct sg_io_v4 * ctl_v4p,
     }   /* end of request array scan loop */
     if ((n_subm == num_mrq) || (vb < 3))
         goto fini;
-    if (vb)
-        pr2serr_lk("[%d] checking response array _beyond_ number of "
-                   "submissions [%d] to num_mrq:\n", id, k);
+    pr2serr_lk("[%d] checking response array _beyond_ number of "
+               "submissions [%d] to num_mrq:\n", id, k);
     for (all_good = true; k < num_mrq; ++k, ++a_v4p) {
         if (SG_INFO_MRQ_FINI & a_v4p->info) {
             pr2serr_lk("[%d] a_v4[%d]: unexpected SG_INFO_MRQ_FINI set [%s]\n",
@@ -2780,7 +2755,7 @@ static int
 split_def_arr(const mrq_arr_t & def_arr, mrq_arr_t & fd_def_arr,
               mrq_arr_t & o_fd_def_arr)
 {
-    int nrq, k, flags;
+    int nrq, k;
     int res = 0;
     const struct sg_io_v4 * a_v4p;
 
@@ -2788,6 +2763,7 @@ split_def_arr(const mrq_arr_t & def_arr, mrq_arr_t & fd_def_arr,
     nrq = def_arr.first.size();
 
     for (k = 0; k < nrq; ++k) {
+        int flags;
         const struct sg_io_v4 * h4p = a_v4p + k;
 
         flags = h4p->flags;
@@ -3327,8 +3303,12 @@ do_v4:
         def_arr.first.push_back(*h4p);
         def_arr.second.push_back(cdb_arr);
         res = 0;
-        if ((int)def_arr.first.size() >= clp->nmrqs)
+        if ((int)def_arr.first.size() >= clp->nmrqs) {
             res = sgh_do_deferred_mrq(rep, def_arr);
+            if (res)
+                pr2serr_lk("%s tid=%d: sgh_do_deferred_mrq failed\n",
+                           __func__, rep->id);
+        }
         return res;
     }
     while (((res = ioctl(fd, SG_IOSUBMIT, h4p)) < 0) &&
@@ -3853,9 +3833,8 @@ static int
 sg_in_open(struct global_collection *clp, const char *inf, uint8_t **mmpp,
            int * mmap_lenp)
 {
-    int fd, err, n;
+    int fd, n;
     int flags = O_RDWR;
-    char ebuff[EBUFF_SZ];
 
     if (clp->in_flags.direct)
         flags |= O_DIRECT;
@@ -3865,7 +3844,9 @@ sg_in_open(struct global_collection *clp, const char *inf, uint8_t **mmpp,
         flags |= O_SYNC;
 
     if ((fd = open(inf, flags)) < 0) {
-        err = errno;
+        int err = errno;
+        char ebuff[EBUFF_SZ];
+
         snprintf(ebuff, EBUFF_SZ, "%s: could not open %s for sg reading",
                  __func__, inf);
         perror(ebuff);
@@ -3887,9 +3868,8 @@ static int
 sg_out_open(struct global_collection *clp, const char *outf, uint8_t **mmpp,
             int * mmap_lenp)
 {
-    int fd, err, n;
+    int fd, n;
     int flags = O_RDWR;
-    char ebuff[EBUFF_SZ];
 
     if (clp->out_flags.direct)
         flags |= O_DIRECT;
@@ -3899,7 +3879,9 @@ sg_out_open(struct global_collection *clp, const char *outf, uint8_t **mmpp,
         flags |= O_SYNC;
 
     if ((fd = open(outf, flags)) < 0) {
-        err = errno;
+        int err = errno;
+        char ebuff[EBUFF_SZ];
+
         snprintf(ebuff,  EBUFF_SZ, "%s: could not open %s for sg %s",
                  __func__, outf, (clp->verify ? "verifying" : "writing"));
         perror(ebuff);