cleanup masks for PDT [0x1f] and group_number [0x3f]

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

16 files changed, 196 insertions, 194 deletions

diff --git a/src/sg_compare_and_write.c b/src/sg_compare_and_write.c
index 0a307003..89bb18b8 100644
--- a/src/sg_compare_and_write.c
+++ b/src/sg_compare_and_write.c
@@ -1,5 +1,5 @@
 /*
-*  Copyright (c) 2012-2021, Kaminario Technologies LTD
+*  Copyright (c) 2012-2022, Kaminario Technologies LTD
 *  All rights reserved.
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
@@ -56,7 +56,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.31 20211114";
+static const char * version_str = "1.32 20220127";
 
 #define DEF_BLOCK_SIZE 512
 #define DEF_NUM_BLOCKS (1)
@@ -339,7 +339,7 @@ sg_build_scsi_cdb(uint8_t * cdbp, unsigned int blocks,
         sg_put_unaligned_be64((uint64_t)start_block, cdbp + 2);
         /* cdbp[10-12] are reserved */
         cdbp[13] = (uint8_t)(blocks & 0xff);
-        cdbp[14] = (uint8_t)(flags.group & 0x1f);
+        cdbp[14] = (uint8_t)(flags.group & GRPNUM_MASK);
         return 0;
 }
 
diff --git a/src/sg_format.c b/src/sg_format.c
index b6620ab2..19d1203a 100644
--- a/src/sg_format.c
+++ b/src/sg_format.c
@@ -6,7 +6,7 @@
  *
  * Copyright (C) 2003  Grant Grundler    grundler at parisc-linux dot org
  * Copyright (C) 2003  James Bottomley       jejb at parisc-linux dot org
- * Copyright (C) 2005-2021  Douglas Gilbert   dgilbert at interlog dot com
+ * Copyright (C) 2005-2022  Douglas Gilbert   dgilbert at interlog dot com
  *
  *   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
@@ -40,7 +40,7 @@
 #include "sg_pr2serr.h"
 #include "sg_pt.h"
 
-static const char * version_str = "1.64 20211114";
+static const char * version_str = "1.65 20220127";
 
 
 #define RW_ERROR_RECOVERY_PAGE 1  /* can give alternate with --mode=MP */
@@ -909,7 +909,7 @@ print_dev_id(int fd, uint8_t * sinq_resp, int max_rlen,
                 n = SAFE_STD_INQ_RESP_LEN;
         memcpy(sinq_resp, b, (n < max_rlen) ? n : max_rlen);
         if (n == SAFE_STD_INQ_RESP_LEN) {
-                pdt = b[0] & 0x1f;
+                pdt = b[0] & PDT_MASK;
                 printf("    %.8s  %.16s  %.4s   peripheral_type: %s [0x%x]\n",
                        (const char *)(b + 8), (const char *)(b + 16),
                        (const char *)(b + 32),
@@ -1586,7 +1586,7 @@ main(int argc, char **argv)
                 } else
                         goto out;
         } else
-                pdt = 0x1f & inq_resp[0];
+                pdt = PDT_MASK & inq_resp[0];
         if (op->format) {
                 if ((PDT_DISK != pdt) && (PDT_OPTICAL != pdt) &&
                     (PDT_RBC != pdt)) {
diff --git a/src/sg_inq.c b/src/sg_inq.c
index 7540797e..38b033b6 100644
--- a/src/sg_inq.c
+++ b/src/sg_inq.c
@@ -1067,7 +1067,7 @@ decode_supported_vpd(uint8_t * buff, int len, int do_hex)
         pr2serr("Supported VPD pages VPD page length too short=%d\n", len);
         return;
     }
-    pdt = 0x1f & buff[0];
+    pdt = PDT_MASK & buff[0];
     rlen = buff[3] + 4;
     if (rlen > len)
         pr2serr("Supported VPD pages VPD page truncated, indicates %d, got "
@@ -2187,7 +2187,7 @@ decode_b0_vpd(uint8_t * buff, int len, int do_hex)
         hex2stdout(buff, len, (1 == do_hex) ? 0 : -1);
         return;
     }
-    pdt = 0x1f & buff[0];
+    pdt = PDT_MASK & buff[0];
     switch (pdt) {
         case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
             if (len < 16) {
@@ -2333,7 +2333,7 @@ decode_b1_vpd(uint8_t * buff, int len, int do_hex)
         hex2stdout(buff, len, (1 == do_hex) ? 0 : -1);
         return;
     }
-    pdt = 0x1f & buff[0];
+    pdt = PDT_MASK & buff[0];
     switch (pdt) {
         case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
             if (len < 64) {
@@ -2408,7 +2408,7 @@ decode_b3_vpd(uint8_t * buff, int len, int do_hex)
         hex2stdout(buff, len, (1 == do_hex) ? 0 : -1);
         return;
     }
-    pdt = 0x1f & buff[0];
+    pdt = PDT_MASK & buff[0];
     switch (pdt) {
         case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
             if (len < 0x10) {
@@ -2811,7 +2811,7 @@ std_inq_decode(const struct opts_t * op, int act_len)
      * [spc-r11a (1997)] bits 6,7: ISO/IEC version; bits 3-5: ECMA
      * version; bits 0-2: SCSI version */
     ansi_version = rp[2] & 0x7;       /* Only take SCSI version */
-    peri_type = rp[0] & 0x1f;
+    peri_type = rp[0] & PDT_MASK;
     if (op->do_export) {
         printf("SCSI_TPGS=%d\n", (rp[5] & 0x30) >> 4);
         cp = sg_get_pdt_str(peri_type, sizeof(buff), buff);
@@ -3194,7 +3194,7 @@ cmddt_process(int sg_fd, const struct opts_t * op)
             res = sg_ll_inquiry(sg_fd, true /* cmddt */, false, k, rsp_buff,
                                 DEF_ALLOC_LEN, true, op->verbose);
             if (0 == res) {
-                peri_type = rsp_buff[0] & 0x1f;
+                peri_type = rsp_buff[0] & PDT_MASK;
                 support_num = rsp_buff[1] & 7;
                 reserved_cmddt = rsp_buff[4];
                 if ((3 == support_num) || (5 == support_num)) {
@@ -3227,7 +3227,7 @@ cmddt_process(int sg_fd, const struct opts_t * op)
         res = sg_ll_inquiry(sg_fd, true /* cmddt */, false, op->page_num,
                             rsp_buff, DEF_ALLOC_LEN, true, op->verbose);
         if (0 == res) {
-            peri_type = rsp_buff[0] & 0x1f;
+            peri_type = rsp_buff[0] & PDT_MASK;
             if (! op->do_raw) {
                 printf("CmdDt INQUIRY, opcode=0x%.2x:  [", op->page_num);
                 sg_get_opcode_name((uint8_t)op->page_num, peri_type,
@@ -3335,7 +3335,7 @@ vpd_mainly_hex(int sg_fd, const struct opts_t * op, int inhex_len)
                 decode_supported_vpd(rp, len, op->do_hex);
             else {
                 if (op->verbose) {
-                    cp = sg_get_pdt_str(rp[0] & 0x1f, sizeof(b), b);
+                    cp = sg_get_pdt_str(rp[0] & PDT_MASK, sizeof(b), b);
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5, cp);
                 }
@@ -3395,7 +3395,7 @@ vpd_decode(int sg_fd, const struct opts_t * op, int inhex_len)
         else if (op->do_hex)
             hex2stdout(rp, len, (1 == op->do_hex) ? 0 : -1);
         else
-            decode_supported_vpd(rp, len, 0x1f & rp[0]);
+            decode_supported_vpd(rp, len, PDT_MASK & rp[0]);
         break;
     case VPD_UNIT_SERIAL_NUM:
         if (! op->do_raw && ! op->do_export && (op->do_hex < 2))
@@ -3538,7 +3538,7 @@ vpd_decode(int sg_fd, const struct opts_t * op, int inhex_len)
     case 0xb0:  /* VPD pages in B0h to BFh range depend on pdt */
         res = vpd_fetch_page_from_dev(sg_fd, rp, pn, mxlen, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             if (! op->do_raw && (op->do_hex < 2)) {
                 switch (pdt) {
                 case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
@@ -3566,7 +3566,7 @@ vpd_decode(int sg_fd, const struct opts_t * op, int inhex_len)
     case 0xb1:  /* VPD pages in B0h to BFh range depend on pdt */
         res = vpd_fetch_page_from_dev(sg_fd, rp, pn, mxlen, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             if (! op->do_raw && (op->do_hex < 2)) {
                 switch (pdt) {
                 case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
@@ -3604,7 +3604,7 @@ vpd_decode(int sg_fd, const struct opts_t * op, int inhex_len)
     case 0xb3:  /* VPD pages in B0h to BFh range depend on pdt */
         res = vpd_fetch_page_from_dev(sg_fd, rp, pn, mxlen, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             if (! op->do_raw && (op->do_hex < 2)) {
                 switch (pdt) {
                 case PDT_DISK: case PDT_WO: case PDT_OPTICAL:
@@ -4230,7 +4230,7 @@ main(int argc, char * argv[])
         op->do_raw = 0;         /* don't want raw on output with --inhex= */
         if (-1 == op->page_num) {       /* may be able to deduce VPD page */
             if (op->page_pdt < 0)
-                op->page_pdt = 0x1f & rsp_buff[0];
+                op->page_pdt = PDT_MASK & rsp_buff[0];
             if ((0x2 == (0xf & rsp_buff[3])) && (rsp_buff[2] > 2)) {
                 if (op->verbose)
                     pr2serr("Guessing from --inhex= this is a standard "
diff --git a/src/sg_logs.c b/src/sg_logs.c
index de5d339e..26e1b477 100644
--- a/src/sg_logs.c
+++ b/src/sg_logs.c
@@ -36,7 +36,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.92 20220114";    /* spc6r06 + sbc5r01 */
+static const char * version_str = "1.93 20220127";    /* spc6r06 + sbc5r01 */
 
 #define MX_ALLOC_LEN (0xfffc)
 #define SHORT_RESP_LEN 128
@@ -5046,6 +5046,7 @@ static bool
 show_zoned_block_dev_stats(const uint8_t * resp, int len,
                            const struct opts_t * op)
 {
+    bool trunc, bad_pl;
     int num, pl, pc;
     const uint8_t * bp;
     char str[PCB_STR_LEN];
@@ -5055,8 +5056,12 @@ show_zoned_block_dev_stats(const uint8_t * resp, int len,
     num = len - 4;
     bp = &resp[0] + 4;
     while (num > 3) {
+        trunc = false;
+        bad_pl = false;
         pc = sg_get_unaligned_be16(bp + 0);
         pl = bp[3] + 4;
+        if (4 == pl)    /* DC HC560 has empty descriptors */
+            goto skip;
         if (op->filter_given) {
             if (pc != op->filter)
                 goto skip;
@@ -5070,166 +5075,135 @@ show_zoned_block_dev_stats(const uint8_t * resp, int len,
         }
         switch (pc) {
         case 0x0:
-            printf("  Maximum open zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Maximum open zones: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x1:
-            printf("  Maximum explicitly open zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Maximum explicitly open zones: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x2:
-            printf("  Maximum implicitly open zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Maximum implicitly open zones: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x3:
-            printf("  Minimum empty zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Minimum empty zones: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x4:
-            printf("  Maximum non-sequential zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Maximum non-sequential zones: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x5:
-            printf("  Zones emptied:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Zones emptied: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x6:
-            printf("  Suboptimal write commands:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Suboptimal write commands: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x7:
-            printf("  Commands exceeding optimal limit:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Commands exceeding optimal limit: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x8:
-            printf("  Failed explicit opens:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Failed explicit opens: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0x9:
-            printf("  Read rule violations:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Read rule violations: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0xa:
-            printf("  Write rule violations:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Write rule violations: %" PRIu32 "\n",
+                       sg_get_unaligned_be32(bp + 8));
             break;
         case 0xb:       /* added zbc2r04 */
-            printf("  Maximum implicitly open or before required zones:");
             if ((pl < 8) || (num < 8)) {
                 if (num < 8)
-                    pr2serr("\n    truncated by response length, expected "
-                            "at least 8 bytes\n");
+                    trunc = true;
                 else
-                    pr2serr("\n    parameter length >= 8 expected, got %d\n",
-                            pl);
-                break;
-            }
-            printf(" %" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
+                    bad_pl = true;
+            } else
+                printf("  Maximum implicitly open or before required zones: "
+                       "%" PRIu32 "\n", sg_get_unaligned_be32(bp + 8));
             break;
         default:
             printf("  Reserved [parameter_code=0x%x]:\n", pc);
             hex2stdout(bp, ((pl < num) ? pl : num), 0);
             break;
         }
+        if (trunc)
+            pr2serr("    truncated by response length, expected at least "
+                    "8 bytes\n");
+        if (bad_pl)
+            pr2serr("    parameter length >= 8 expected, got %d\n", pl);
         if (op->do_pcb)
             printf("        <%s>\n", get_pcb_str(bp[2], str, sizeof(str)));
         if (op->filter_given)
diff --git a/src/sg_opcodes.c b/src/sg_opcodes.c
index 54b90723..944a3e76 100644
--- a/src/sg_opcodes.c
+++ b/src/sg_opcodes.c
@@ -1,5 +1,5 @@
 /* A utility program originally written for the Linux OS SCSI subsystem.
- *  Copyright (C) 2004-2021 D. Gilbert
+ *  Copyright (C) 2004-2022 D. Gilbert
  *  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)
@@ -33,7 +33,7 @@
 
 #include "sg_pt.h"
 
-static const char * version_str = "0.72 20211221";    /* spc6r05 */
+static const char * version_str = "0.73 20220127";    /* spc6r06 */
 
 
 #define SENSE_BUFF_LEN 64       /* Arbitrary, could be larger */
@@ -393,7 +393,7 @@ new_parse_cmd_line(struct opts_t * op, int argc, char * argv[])
                 n = sg_get_num(optarg);
             else if ((2 == strlen(optarg)) && (0 == strcmp("-1", optarg)))
                 n = -1;
-            if ((n < -1) || (n > 0x1f)) {
+            if ((n < -1) || (n > PDT_MAX)) {
                 pr2serr("bad argument to '--pdt=DT', expect -1 to 31\n");
                 return SG_LIB_SYNTAX_ERROR;
             }
@@ -539,7 +539,7 @@ old_parse_cmd_line(struct opts_t * op, int argc, char * argv[])
                 op->opcode = n;
             } else if (0 == strncmp("p=", cp, 2)) {
                 num = sscanf(cp + 2, "%d", &n);
-                if ((1 != num) || (n > 0x1f) || (n < -1)) {
+                if ((1 != num) || (n > PDT_MAX) || (n < -1)) {
                     pr2serr("Bad number after 'p=' option, expect -1 to "
                             "31\n");
                     return SG_LIB_SYNTAX_ERROR;
diff --git a/src/sg_rep_zones.c b/src/sg_rep_zones.c
index 2e719e75..02c8953c 100644
--- a/src/sg_rep_zones.c
+++ b/src/sg_rep_zones.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2021 Douglas Gilbert.
+ * Copyright (c) 2014-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -39,8 +39,9 @@
  * Based on zbc2r10.pdf
  */
 
-static const char * version_str = "1.29 20211117";
+static const char * version_str = "1.30 20220128";
 
+#define WILD_RZONES_BUFF_LEN (1 << 28)
 #define MAX_RZONES_BUFF_LEN (1024 * 1024)
 #define DEF_RZONES_BUFF_LEN (1024 * 8)
 
@@ -54,6 +55,7 @@ static const char * version_str = "1.29 20211117";
 #define DEF_PT_TIMEOUT  60      /* 60 seconds */
 
 struct opts_t {
+    bool do_brief;
     bool do_force;
     bool do_partial;
     bool do_raw;
@@ -76,6 +78,7 @@ struct opts_t {
 
 
 static struct option long_options[] = {
+        {"brief", no_argument, 0, 'b'}, /* only header and last descriptor */
         {"domain", no_argument, 0, 'd'},
         {"domains", no_argument, 0, 'd'},
         {"force", no_argument, 0, 'f'},
@@ -108,10 +111,11 @@ usage(int h)
             "sg_rep_zones  [--domain] [--force] [--help] [--hex] "
             "[--inhex=FN]\n"
             "                     [--locator=LBA] [--maxlen=LEN] "
-            "[--partial] [--raw]\n"
-            "                     [--readonly] [--realm] [--report=OPT] "
-            "[--start=LBA]\n"
-            "                     [--verbose] [--version] DEVICE\n");
+            "[--partial] [--only]\n"
+            "                     [--raw] [--readonly] [--realm] "
+            "[--report=OPT]\n"
+            "                     [--start=LBA] [--verbose] [--version] "
+            "DEVICE\n");
     pr2serr("  where:\n"
             "    --domain|-d        sends a REPORT ZONE DOMAINS command\n"
             "    --force|-f         bypass some sanity checks when decoding "
@@ -128,6 +132,8 @@ usage(int h)
             "                           (def: 0 -> 8192 bytes)\n"
             "    --num=NUM|-n NUM    number of zones to output (def: 0 -> "
             "all)\n"
+            "    --only|-o          output header and starting LBA of "
+            "next\n"
             "    --partial|-p       sets PARTIAL bit in cdb (def: 0 -> "
             "zone list\n"
             "                       length not altered by allocation length "
@@ -317,7 +323,7 @@ decode_rep_zones(const uint8_t * rzBuff, int act_len, uint32_t decod_len,
 {
     uint8_t zt;
     int k, same, zc, num_zd;
-    uint64_t wp;
+    uint64_t wp, ul, ul2, mx_lba;
     const uint8_t * bp;
     char b[80];
 
@@ -334,10 +340,10 @@ decode_rep_zones(const uint8_t * rzBuff, int act_len, uint32_t decod_len,
     } else
         num_zd = (decod_len - 64) / 64;
     same = rzBuff[4] & 0xf;
+    mx_lba = sg_get_unaligned_be64(rzBuff + 8);
     if (! op->wp_only) {
         printf("  Same=%d: %s\n", same, same_desc_arr[same]);
-        printf("  Maximum LBA: 0x%" PRIx64 "\n\n",
-               sg_get_unaligned_be64(rzBuff + 8));
+        printf("  Maximum LBA: 0x%" PRIx64 "\n\n", mx_lba);
         printf("  Reported zone starting LBA granularity: 0x%" PRIx64 "\n\n",
                sg_get_unaligned_be64(rzBuff + 16));     /* zbc2r12 */
     }
@@ -348,6 +354,20 @@ decode_rep_zones(const uint8_t * rzBuff, int act_len, uint32_t decod_len,
                 "value less than %d\n", num_zd);
         return SG_LIB_CAT_MALFORMED;
     }
+    if (op->do_brief && (num_zd > 0)) {
+        bp = rzBuff + 64 + ((num_zd - 1) * 64);
+        printf("From last descriptor in this response:\n");
+        ul = sg_get_unaligned_be64(bp + 16);
+        printf("   Zone start LBA: 0x%" PRIx64 "\n", ul);
+        ul2 = sg_get_unaligned_be64(bp + 8);
+        printf("   Zone Length: 0x%" PRIx64 "\n", ul2);
+        ul = ul + ul2;
+        if (ul > mx_lba)
+            printf("   This zone seems to be the last one\n");
+        else
+            printf("   Probable next Zone start LBA: 0x%" PRIx64 "\n", ul);
+        return 0;
+    }
     for (k = 0, bp = rzBuff + 64; k < num_zd; ++k, bp += 64) {
         if (! op->wp_only)
             printf(" Zone descriptor: %d\n", k);
@@ -356,7 +376,11 @@ decode_rep_zones(const uint8_t * rzBuff, int act_len, uint32_t decod_len,
             continue;
         }
         if (op->wp_only) {
-            printf("0x%" PRIx64 "\n", sg_get_unaligned_be64(bp + 24));
+            wp = sg_get_unaligned_be64(bp + 24);
+            if (sg_all_ffs((const uint8_t *)&wp, sizeof(wp)))
+                printf("-1\n");
+            else
+                printf("0x%" PRIx64 "\n", wp);
             continue;
         }
         zt = bp[0] & 0xf;
@@ -531,12 +555,15 @@ main(int argc, char * argv[])
     while (1) {
         int option_index = 0;
 
-        c = getopt_long(argc, argv, "defhHi:l:m:n:o:prRs:vVw", long_options,
+        c = getopt_long(argc, argv, "bdefhHi:l:m:n:o:prRs:vVw", long_options,
                         &option_index);
         if (c == -1)
             break;
 
         switch (c) {
+        case 'b':
+            op->do_brief = true;
+            break;
         case 'd':
             op->do_zdomains = true;
             serv_act = REPORT_ZONE_DOMAINS_SA;
@@ -744,7 +771,7 @@ start_response:
             goto the_end;
         }
         decod_len = sg_get_unaligned_be32(rzBuff + 0) + 64;
-        if (decod_len > MAX_RZONES_BUFF_LEN) {
+        if (decod_len > WILD_RZONES_BUFF_LEN) {
             if (! op->do_force) {
                 pr2serr("decode length [%u bytes] seems wild, use --force "
                         "override\n", decod_len);
@@ -753,8 +780,9 @@ start_response:
         }
         if (decod_len > (uint32_t)rlen) {
             if ((REPORT_ZONES_SA == serv_act) && (! op->do_partial)) {
-                printf("%u zones available but only %d zones returned\n",
-                       (decod_len - 64) / 64, (rlen - 64) / 64);
+                printf("%u zones starting from LBA 0x%" PRIx64 " available "
+                       "but only %d zones returned\n",
+                       (decod_len - 64) / 64, op->st_lba, (rlen - 64) / 64);
                 decod_len = rlen;
                 act_len = rlen;
             } else {
diff --git a/src/sg_sanitize.c b/src/sg_sanitize.c
index ade9be71..147898fe 100644
--- a/src/sg_sanitize.c
+++ b/src/sg_sanitize.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2021 Douglas Gilbert.
+ * Copyright (c) 2011-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -33,7 +33,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.17 20211114";
+static const char * version_str = "1.18 20220127";
 
 /* Not all environments support the Unix sleep() */
 #if defined(MSC_VER) || defined(__MINGW32__)
@@ -368,7 +368,7 @@ print_dev_id(int fd, uint8_t * sinq_resp, int max_rlen, int verbose)
         n = SAFE_STD_INQ_RESP_LEN;
     memcpy(sinq_resp, b, (n < max_rlen) ? n : max_rlen);
     if (n == SAFE_STD_INQ_RESP_LEN) {
-        pdt = b[0] & 0x1f;
+        pdt = b[0] & PDT_MASK;
         printf("    %.8s  %.16s  %.4s   peripheral_type: %s [0x%x]\n",
                (const char *)(b + 8), (const char *)(b + 16),
                (const char *)(b + 32),
diff --git a/src/sg_scan_linux.c b/src/sg_scan_linux.c
index c04206a1..9fa3374a 100644
--- a/src/sg_scan_linux.c
+++ b/src/sg_scan_linux.c
@@ -452,7 +452,7 @@ int sg3_inq(int sg_fd, uint8_t * inqBuff, bool do_extra)
         printf("    %.8s  %.16s  %.4s ", p + 8, p + 16, p + 32);
         printf("[rmb=%d cmdq=%d pqual=%d pdev=0x%x] ",
                !!(p[1] & 0x80), !!(p[7] & 2), (p[0] & 0xe0) >> 5,
-               (p[0] & 0x1f));
+               (p[0] & PDT_MASK));
         if (do_extra && sg_io)
             printf("dur=%ums\n", io_hdr.duration);
         else
diff --git a/src/sg_scan_win32.c b/src/sg_scan_win32.c
index 4ba59836..06851497 100644
--- a/src/sg_scan_win32.c
+++ b/src/sg_scan_win32.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018 Douglas Gilbert.
+ * Copyright (c) 2006-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -43,7 +43,7 @@
 
 #include "sg_pt_win32.h"
 
-static const char * version_str = "1.22 (win32) 20181110";
+static const char * version_str = "1.23 (win32) 20220127";
 
 #define MAX_SCSI_ELEMS 4096
 #define MAX_ADAPTER_NUM 256
@@ -366,7 +366,7 @@ enum_scsi_adapters(void)
                         printf("%-15s", b);
                         snprintf(b, sizeof(b) - 1, "claimed=%d pdt=%xh %s ",
                                  pid->DeviceClaimed,
-                                 pid->InquiryData[0] % 0x3f,
+                                 pid->InquiryData[0] % PDT_MASK,
                                  ((0 == pid->InquiryData[4]) ? "dubious" :
                                                                ""));
                         printf("%-26s", b);
diff --git a/src/sg_ses.c b/src/sg_ses.c
index 9b16134b..aa545a87 100644
--- a/src/sg_ses.c
+++ b/src/sg_ses.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2004-2021 Douglas Gilbert.
+ * Copyright (c) 2004-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -38,7 +38,7 @@
  * commands tailored for SES (enclosure) devices.
  */
 
-static const char * version_str = "2.54 20211028";    /* ses4r04 */
+static const char * version_str = "2.55 20220127";    /* ses4r04 */
 
 #define MX_ALLOC_LEN ((64 * 1024) - 4)  /* max allowable for big enclosures */
 #define MX_ELEM_HDR 1024
@@ -5750,7 +5750,7 @@ main(int argc, char * argv[])
                     pr2serr("Short INQUIRY response, not looking good\n");
                 printf("  %.8s  %.16s  %.4s\n", inq_rsp + 8, inq_rsp + 16,
                        inq_rsp + 32);
-                pd_type = 0x1f & inq_rsp[0];
+                pd_type = PDT_MASK & inq_rsp[0];
                 cp = sg_get_pdt_str(pd_type, sizeof(buff), buff);
                 if (0xd == pd_type) {
                     if (vb)
diff --git a/src/sg_sync.c b/src/sg_sync.c
index 1a8eebfb..a5d6ce8d 100644
--- a/src/sg_sync.c
+++ b/src/sg_sync.c
@@ -109,7 +109,7 @@ sg_ll_sync_cache_16(int sg_fd, bool sync_nv, bool immed, int group,
     if (immed)
         sc_cdb[1] |= 2;
     sg_put_unaligned_be64(lba, sc_cdb + 2);
-    sc_cdb[14] = group & 0x1f;
+    sc_cdb[14] = group & GRPNUM_MASK;
     sg_put_unaligned_be32((uint32_t)num_lb, sc_cdb + 10);
 
     if (verbose) {
diff --git a/src/sg_vpd.c b/src/sg_vpd.c
index 1a74af52..46b7e603 100644
--- a/src/sg_vpd.c
+++ b/src/sg_vpd.c
@@ -504,7 +504,7 @@ std_inq_decode(uint8_t * b, int len, int verbose)
     else
         printf(" [reserved or vendor specific qualifier [%d]]\n", pqual);
     printf("  PQual=%d  PDT=%d  RMB=%d  LU_CONG=%d  hot_pluggable=%d  "
-           "version=0x%02x ", pqual, b[0] & 0x1f, !!(b[1] & 0x80),
+           "version=0x%02x ", pqual, b[0] & PDT_MASK, !!(b[1] & 0x80),
                !!(b[1] & 0x40), (b[1] >> 4) & 0x3, (unsigned int)b[2]);
     printf(" [%s]\n", sg_ansi_version_arr[b[2] & 0xf]);
     printf("  [AERC=%d]  [TrmTsk=%d]  NormACA=%d  HiSUP=%d "
@@ -1308,8 +1308,8 @@ decode_dev_constit_vpd(const uint8_t * buff, int len, struct opts_t * op)
         else if (bp[2] >= 0x20)
             printf("Reserved [0x%x]\n", bp[2]);
         else
-            printf("%s [0x%x]\n", sg_get_pdt_str(0x1f & bp[2], sizeof(b), b),
-                   bp[2]);
+            printf("%s [0x%x]\n",
+                   sg_get_pdt_str(PDT_MASK & bp[2], sizeof(b), b), bp[2]);
         printf("    Vendor_identification: %.8s\n", bp + 4);
         printf("    Product_identification: %.16s\n", bp + 12);
         printf("    Product_revision_level: %.4s\n", bp + 28);
@@ -2562,11 +2562,11 @@ decode_zbdch_vpd(uint8_t * b, int len, int do_hex)
         return;
     }
     printf("  Peripheral device type: %s\n",
-           sg_get_pdt_str(0x1f & b[0], sizeof(d), d));
+           sg_get_pdt_str(PDT_MASK & b[0], sizeof(d), d));
     printf("  Zoned block device extension: ");
     switch ((b[4] >> 4) & 0xf) {
     case 0:
-        if (PDT_ZBC == (0x1f & b[0]))
+        if (PDT_ZBC == (PDT_MASK & b[0]))
             printf("host managed zoned block device [0, pdt=0x14]\n");
         else
             printf("not reported [0]\n");
@@ -2920,7 +2920,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             else if (op->do_hex)
                 hex2stdout(rp, len, (1 == op->do_hex) ? 0 : -1);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -2967,7 +2967,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             else if (op->do_hex)
                 hex2stdout(rp, len, (1 == op->do_hex) ? 0 : -1);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -2995,7 +2995,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             else if (op->do_hex)
                 hex2stdout(rp, len, (1 == op->do_hex) ? 0 : -1);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3016,7 +3016,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3064,7 +3064,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
                     } else
                         protect = !!(sir.byte_5 & 0x1); /* SPC-3 and later */
                 }
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3085,7 +3085,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3106,7 +3106,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3136,7 +3136,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             else if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3157,7 +3157,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3193,7 +3193,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3216,7 +3216,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             else if (1 == op->do_hex)
                 hex2stdout(rp, len, 0);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3237,7 +3237,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rsp_buff[0] & 0x1f;
+                pdt = rsp_buff[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3258,7 +3258,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3279,7 +3279,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3292,7 +3292,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb0:  /* depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Block limits VPD page (SBC):";
@@ -3314,7 +3314,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3329,7 +3329,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb1:  /* depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Block device characteristics VPD page (SBC):";
@@ -3368,7 +3368,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb2:          /* VPD page depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Logical block provisioning VPD page (SBC):";
@@ -3401,7 +3401,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb3:          /* VPD page depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Referrals VPD page (SBC):";
@@ -3434,7 +3434,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb4:          /* VPD page depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Supported block lengths and protection types VPD page "
@@ -3468,7 +3468,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb5:          /* VPD page depends on pdt */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Block device characteristics extension VPD page (SBC):";
@@ -3501,7 +3501,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case VPD_ZBC_DEV_CHARS:       /* 0xb6 for both pdt=0 and pdt=0x14 */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Zoned block device characteristics VPD page (SBC, "
@@ -3532,7 +3532,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb7:
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Block limits extension VPD page (SBC):";
@@ -3548,7 +3548,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3563,7 +3563,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb8:          /* VPD_FORMAT_PRESETS */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Format presets VPD page (SBC):";
@@ -3579,7 +3579,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
@@ -3594,7 +3594,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
     case 0xb9:          /* VPD_CON_POS_RANGE */
         res = vpd_fetch_page(sg_fd, rp, pn, op->maxlen, qt, vb, &len);
         if (0 == res) {
-            pdt = rp[0] & 0x1f;
+            pdt = rp[0] & PDT_MASK;
             switch (pdt) {
             case PDT_DISK: case PDT_WO: case PDT_OPTICAL: case PDT_ZBC:
                 np = "Concurrent positioning ranges VPD page (SBC):";
@@ -3610,7 +3610,7 @@ svpd_decode_t10(int sg_fd, struct opts_t * op, int subvalue, int off,
             if (op->do_raw)
                 dStrRaw(rp, len);
             else {
-                pdt = rp[0] & 0x1f;
+                pdt = rp[0] & PDT_MASK;
                 if (vb || long_notquiet)
                     printf("   [PQual=%d  Peripheral device type: %s]\n",
                            (rp[0] & 0xe0) >> 5,
diff --git a/src/sg_wr_mode.c b/src/sg_wr_mode.c
index 2a10fb7c..b2dff407 100644
--- a/src/sg_wr_mode.c
+++ b/src/sg_wr_mode.c
@@ -502,7 +502,7 @@ main(int argc, char * argv[])
     if (0 == sg_simple_inquiry(sg_fd, &inq_data, false, verbose))
         pdt = inq_data.peripheral_type;
     else
-        pdt = 0x1f;
+        pdt = PDT_UNKNOWN;
 
     /* do MODE SENSE to fetch current values */
     memset(ref_md, 0, MX_ALLOC_LEN);
diff --git a/src/sg_write_same.c b/src/sg_write_same.c
index e2213fba..011deb99 100644
--- a/src/sg_write_same.c
+++ b/src/sg_write_same.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2021 Douglas Gilbert.
+ * Copyright (c) 2009-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -33,7 +33,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.33 20211114";
+static const char * version_str = "1.34 20220127";
 
 
 #define ME "sg_write_same: "
@@ -209,7 +209,7 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
         if (op->lbdata)
             ws_cdb[1] |= 0x2;
         sg_put_unaligned_be32((uint32_t)op->lba, ws_cdb + 2);
-        ws_cdb[6] = (op->grpnum & 0x1f);
+        ws_cdb[6] = (op->grpnum & GRPNUM_MASK);
         sg_put_unaligned_be16((uint16_t)op->numblocks, ws_cdb + 7);
         break;
     case WRITE_SAME16_LEN:
@@ -227,11 +227,11 @@ do_write_same(int sg_fd, const struct opts_t * op, const void * dataoutp,
             ws_cdb[1] |= 0x1;
         sg_put_unaligned_be64(op->lba, ws_cdb + 2);
         sg_put_unaligned_be32((uint32_t)op->numblocks, ws_cdb + 10);
-        ws_cdb[14] = (op->grpnum & 0x1f);
+        ws_cdb[14] = (op->grpnum & GRPNUM_MASK);
         break;
     case WRITE_SAME32_LEN:
         ws_cdb[0] = VARIABLE_LEN_OP;
-        ws_cdb[6] = (op->grpnum & 0x1f);
+        ws_cdb[6] = (op->grpnum & GRPNUM_MASK);
         ws_cdb[7] = WRITE_SAME32_ADD;
         sg_put_unaligned_be16((uint16_t)WRITE_SAME32_SA, ws_cdb + 8);
         ws_cdb[10] = ((op->wrprotect & 0x7) << 5);
diff --git a/src/sg_write_verify.c b/src/sg_write_verify.c
index 384899b2..e2af4019 100644
--- a/src/sg_write_verify.c
+++ b/src/sg_write_verify.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2021 Douglas Gilbert
+ * Copyright (c) 2014-2022 Douglas Gilbert
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -40,7 +40,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.20 20211114";
+static const char * version_str = "1.21 20220127";
 
 
 #define ME "sg_write_verify: "
@@ -215,7 +215,7 @@ sg_ll_write_verify10(int sg_fd, int wrprotect, bool dpo, int bytchk,
        wv_cdb[1] |= ((bytchk & 0x3) << 1);
 
     sg_put_unaligned_be32((uint32_t)lba, wv_cdb + 2);
-    wv_cdb[6] = group & 0x1f;
+    wv_cdb[6] = group & GRPNUM_MASK;
     sg_put_unaligned_be16((uint16_t)num_lb, wv_cdb + 7);
     ret = run_scsi_transaction(sg_fd, wv_cdb, sizeof(wv_cdb), dop, do_len,
                                timeout, noisy, verbose);
@@ -243,7 +243,7 @@ sg_ll_write_verify16(int sg_fd, int wrprotect, bool dpo, int bytchk,
 
     sg_put_unaligned_be64(llba, wv_cdb + 2);
     sg_put_unaligned_be32((uint32_t)num_lb, wv_cdb + 10);
-    wv_cdb[14] = group & 0x1f;
+    wv_cdb[14] = group & GRPNUM_MASK;
     ret = run_scsi_transaction(sg_fd, wv_cdb, sizeof(wv_cdb), dop, do_len,
                                timeout, noisy, verbose);
     return ret;
diff --git a/src/sg_write_x.c b/src/sg_write_x.c
index 18d1e7ec..81ee1a67 100644
--- a/src/sg_write_x.c
+++ b/src/sg_write_x.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2021 Douglas Gilbert.
+ * Copyright (c) 2017-2022 Douglas Gilbert.
  * All rights reserved.
  * Use of this source code is governed by a BSD-style
  * license that can be found in the BSD_LICENSE file.
@@ -38,7 +38,7 @@
 #include "sg_unaligned.h"
 #include "sg_pr2serr.h"
 
-static const char * version_str = "1.29 20211114";
+static const char * version_str = "1.30 20220127";
 
 /* Protection Information refers to 8 bytes of extra information usually
  * associated with each logical block and is often abbreviated to PI while
@@ -160,7 +160,7 @@ struct opts_t {
                          * DLD0, bit 1 --> DLD1, bit 2 --> DLD2
                          * only WRITE(16) and WRITE SCATTERED(16) */
     int dry_run;        /* temporary write when used more than once */
-    int grpnum;         /* "Group Number", 0 to 0x3f */
+    int grpnum;         /* "Group Number", 0 to 0x3f (GRPNUM_MASK) */
     int help;
     int pi_type;        /* -1: unknown: 0: type 0 (none): 1: type 1 */
     int strict;         /* > 0, report then exit on questionable meta data */
@@ -1062,10 +1062,10 @@ do_write_x(int sg_fd, const void * dataoutp, int dout_len,
     if (16 == cdb_len) {
         if (! op->do_scattered)
             sg_put_unaligned_be64(op->lba, x_cdb + 2);
-        x_cdb[14] = (op->grpnum & 0x1f);
+        x_cdb[14] = (op->grpnum & GRPNUM_MASK);
     } else {
         x_cdb[0] = VARIABLE_LEN_OP;
-        x_cdb[6] = (op->grpnum & 0x1f);
+        x_cdb[6] = (op->grpnum & GRPNUM_MASK);
         x_cdb[7] = WRITE_X_32_ADD;
         if (! op->do_scattered)
             sg_put_unaligned_be64(op->lba, x_cdb + 12);