aboutsummaryrefslogtreecommitdiff
path: root/src/sg_write_verify.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/sg_write_verify.c')
-rw-r--r--src/sg_write_verify.c634
1 files changed, 634 insertions, 0 deletions
diff --git a/src/sg_write_verify.c b/src/sg_write_verify.c
new file mode 100644
index 00000000..ee6b12bf
--- /dev/null
+++ b/src/sg_write_verify.c
@@ -0,0 +1,634 @@
+/*
+ * 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.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * This program issues the SCSI command WRITE AND VERIFY to a given SCSI
+ * device. It sends the command with the logical block address passed as the
+ * LBA argument, for the given number of blocks. The number of bytes sent is
+ * supplied separately, either by the size of the given file (IF) or
+ * explicitly with ILEN.
+ *
+ * This code was contributed by Bruno Goncalves
+ */
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <string.h>
+#include <errno.h>
+#include <limits.h>
+#include <getopt.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "sg_lib.h"
+#include "sg_pt.h"
+#include "sg_cmds_basic.h"
+#include "sg_unaligned.h"
+#include "sg_pr2serr.h"
+
+static const char * version_str = "1.21 20220127";
+
+
+#define ME "sg_write_verify: "
+
+#define SENSE_BUFF_LEN 64 /* Arbitrary, could be larger */
+
+#define WRITE_VERIFY10_CMD 0x2e
+#define WRITE_VERIFY10_CMDLEN 10
+#define WRITE_VERIFY16_CMD 0x8e
+#define WRITE_VERIFY16_CMDLEN 16
+
+#define WRPROTECT_MASK (0x7)
+#define WRPROTECT_SHIFT (5)
+
+#define DEF_TIMEOUT_SECS 60
+
+
+static struct option long_options[] = {
+ {"16", no_argument, 0, 'S'},
+ {"bytchk", required_argument, 0, 'b'},
+ {"dpo", no_argument, 0, 'd'},
+ {"group", required_argument, 0, 'g'},
+ {"help", no_argument, 0, 'h'},
+ {"ilen", required_argument, 0, 'I'},
+ {"in", required_argument, 0, 'i'},
+ {"lba", required_argument, 0, 'l'},
+ {"num", required_argument, 0, 'n'},
+ {"repeat", no_argument, 0, 'R'},
+ {"timeout", required_argument, 0, 't'},
+ {"verbose", no_argument, 0, 'v'},
+ {"version", no_argument, 0, 'V'},
+ {"wrprotect", required_argument, 0, 'w'},
+ {0, 0, 0, 0},
+};
+
+
+static void
+usage()
+{
+ pr2serr("Usage: sg_write_verify [--16] [--bytchk=BC] [--dpo] [--group=GN] "
+ "[--help]\n"
+ " [--ilen=IL] [--in=IF] --lba=LBA "
+ "[--num=NUM]\n"
+ " [--repeat] [--timeout=TO] [--verbose] "
+ "[--version]\n"
+ " [--wrprotect=WPR] DEVICE\n"
+ " where:\n"
+ " --16|-S do WRITE AND VERIFY(16) (default: 10)\n"
+ " --bytchk=BC|-b BC set BYTCHK field (default: 0)\n"
+ " --dpo|-d set DPO bit (default: 0)\n"
+ " --group=GN|-g GN GN is group number (default: 0)\n"
+ " --help|-h print out usage message\n"
+ " --ilen=IL| -I IL input (file) length in bytes, becomes "
+ "data-out\n"
+ " buffer length (def: deduced from IF "
+ "size)\n"
+ " --in=IF|-i IF IF is a file containing the data to "
+ "be written\n"
+ " --lba=LBA|-l LBA LBA of the first block to write "
+ "and verify;\n"
+ " no default, must be given\n"
+ " --num=NUM|-n NUM logical blocks to write and verify "
+ "(def: 1)\n"
+ " --repeat|-R while IF still has data to read, send "
+ "another\n"
+ " command, bumping LBA with up to NUM "
+ "blocks again\n"
+ " --timeout=TO|-t TO command timeout in seconds (def: 60)\n"
+ " --verbose|-v increase verbosity\n"
+ " --version|-V print version string then exit\n"
+ " --wrprotect|-w WPR WPR is the WRPROTECT field value "
+ "(def: 0)\n\n"
+ "Performs a SCSI WRITE AND VERIFY (10 or 16) command on DEVICE, "
+ "startings\nat LBA for NUM logical blocks. More commands "
+ "performed only if '--repeat'\noption given. Data to be written "
+ "is fetched from the IF file.\n"
+ );
+}
+
+/* Invokes a SCSI WRITE AND VERIFY according with CDB. Returns 0 -> success,
+ * various SG_LIB_CAT_* positive values or -1 -> other errors */
+static int
+run_scsi_transaction(int sg_fd, const uint8_t *cdbp, int cdb_len,
+ uint8_t *dop, int do_len, int timeout,
+ bool noisy, int verbose)
+{
+ int res, sense_cat, ret;
+ struct sg_pt_base * ptvp;
+ uint8_t sense_b[SENSE_BUFF_LEN] SG_C_CPP_ZERO_INIT;
+ char b[32];
+
+ snprintf(b, sizeof(b), "Write and verify(%d)", cdb_len);
+ if (verbose) {
+ char d[128];
+
+ pr2serr(" %s cdb: %s\n", b,
+ sg_get_command_str(cdbp, cdb_len, false, sizeof(d), d));
+ if ((verbose > 2) && dop && do_len) {
+ pr2serr(" Data out buffer [%d bytes]:\n", do_len);
+ hex2stderr(dop, do_len, -1);
+ }
+ }
+ ptvp = construct_scsi_pt_obj();
+ if (NULL == ptvp) {
+ pr2serr("%s: out of memory\n", b);
+ return -1;
+ }
+ set_scsi_pt_cdb(ptvp, cdbp, cdb_len);
+ set_scsi_pt_sense(ptvp, sense_b, sizeof(sense_b));
+ set_scsi_pt_data_out(ptvp, dop, do_len);
+ res = do_scsi_pt(ptvp, sg_fd, timeout, verbose);
+ ret = sg_cmds_process_resp(ptvp, b, res, noisy, verbose, &sense_cat);
+ if (-1 == ret) {
+ if (get_scsi_pt_transport_err(ptvp))
+ ret = SG_LIB_TRANSPORT_ERROR;
+ else
+ ret = sg_convert_errno(get_scsi_pt_os_err(ptvp));
+ } else if (-2 == ret) {
+ switch (sense_cat) {
+ case SG_LIB_CAT_RECOVERED:
+ case SG_LIB_CAT_NO_SENSE:
+ ret = 0;
+ break;
+ case SG_LIB_CAT_MEDIUM_HARD: /* write or verify failed */
+ {
+ bool valid;
+ int slen;
+ uint64_t ull = 0;
+
+ slen = get_scsi_pt_sense_len(ptvp);
+ valid = sg_get_sense_info_fld(sense_b, slen, &ull);
+ if (valid)
+ pr2serr("Medium or hardware error starting at lba=%"
+ PRIu64 " [0x%" PRIx64 "]\n", ull, ull);
+ }
+ ret = sense_cat;
+ break;
+ case SG_LIB_CAT_ILLEGAL_REQ:
+ if (verbose)
+ sg_print_command_len(cdbp, cdb_len);
+ /* FALL THROUGH */
+ case SG_LIB_CAT_PROTECTION: /* PI failure */
+ case SG_LIB_CAT_MISCOMPARE: /* only in bytchk=1 case */
+ default:
+ ret = sense_cat;
+ break;
+ }
+ } else
+ ret = 0;
+
+ destruct_scsi_pt_obj(ptvp);
+ return ret;
+}
+
+/* Invokes a SCSI WRITE AND VERIFY (10) command (SBC). Returns 0 -> success,
+* various SG_LIB_CAT_* positive values or -1 -> other errors */
+static int
+sg_ll_write_verify10(int sg_fd, int wrprotect, bool dpo, int bytchk,
+ unsigned int lba, int num_lb, int group,
+ uint8_t *dop, int do_len, int timeout,
+ bool noisy, int verbose)
+{
+ int ret;
+ uint8_t wv_cdb[WRITE_VERIFY10_CMDLEN];
+
+ memset(wv_cdb, 0, WRITE_VERIFY10_CMDLEN);
+ wv_cdb[0] = WRITE_VERIFY10_CMD;
+ wv_cdb[1] = ((wrprotect & WRPROTECT_MASK) << WRPROTECT_SHIFT);
+ if (dpo)
+ wv_cdb[1] |= 0x10;
+ if (bytchk)
+ wv_cdb[1] |= ((bytchk & 0x3) << 1);
+
+ sg_put_unaligned_be32((uint32_t)lba, wv_cdb + 2);
+ 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);
+ return ret;
+}
+
+/* Invokes a SCSI WRITE AND VERIFY (16) command (SBC). Returns 0 -> success,
+* various SG_LIB_CAT_* positive values or -1 -> other errors */
+static int
+sg_ll_write_verify16(int sg_fd, int wrprotect, bool dpo, int bytchk,
+ uint64_t llba, int num_lb, int group, uint8_t *dop,
+ int do_len, int timeout, bool noisy, int verbose)
+{
+ int ret;
+ uint8_t wv_cdb[WRITE_VERIFY16_CMDLEN];
+
+
+ memset(wv_cdb, 0, sizeof(wv_cdb));
+ wv_cdb[0] = WRITE_VERIFY16_CMD;
+ wv_cdb[1] = ((wrprotect & WRPROTECT_MASK) << WRPROTECT_SHIFT);
+ if (dpo)
+ wv_cdb[1] |= 0x10;
+ if (bytchk)
+ wv_cdb[1] |= ((bytchk & 0x3) << 1);
+
+ sg_put_unaligned_be64(llba, wv_cdb + 2);
+ sg_put_unaligned_be32((uint32_t)num_lb, wv_cdb + 10);
+ 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;
+}
+
+/* Returns file descriptor ( >= 0) if successful. Else a negated sg3_utils
+ * error code is returned. */
+static int
+open_if(const char * fn, int got_stdin)
+{
+ int fd, err;
+
+ if (got_stdin)
+ fd = STDIN_FILENO;
+ else {
+ fd = open(fn, O_RDONLY);
+ if (fd < 0) {
+ err = errno;
+ pr2serr(ME "open error: %s: %s\n", fn, safe_strerror(err));
+ return -sg_convert_errno(err);
+ }
+ }
+ if (sg_set_binary_mode(fd) < 0) {
+ perror("sg_set_binary_mode");
+ return -SG_LIB_FILE_ERROR;
+ }
+ return fd;
+}
+
+int
+main(int argc, char * argv[])
+{
+ bool do_16 = false;
+ bool dpo = false;
+ bool first_time;
+ bool given_do_16 = false;
+ bool has_filename = false;
+ bool lba_given = false;
+ bool repeat = false;
+ bool verbose_given = false;
+ bool version_given = false;
+ int sg_fd, res, c, n;
+ int bytchk = 0;
+ int group = 0;
+ int ilen = -1;
+ int ifd = -1;
+ int b_p_lb = 512;
+ int ret = 1;
+ int timeout = DEF_TIMEOUT_SECS;
+ int tnum_lb_wr = 0;
+ int verbose = 0;
+ int wrprotect = 0;
+ uint32_t num_lb = 1;
+ uint32_t snum_lb = 1;
+ uint64_t llba = 0;
+ int64_t ll;
+ uint8_t * wvb = NULL;
+ uint8_t * wrkBuff = NULL;
+ uint8_t * free_wrkBuff = NULL;
+ const char * device_name = NULL;
+ const char * ifnp;
+ char cmd_name[32];
+
+ ifnp = ""; /* keep MinGW quiet */
+ while (1) {
+ int option_index = 0;
+
+ c = getopt_long(argc, argv, "b:dg:hi:I:l:n:RSt:w:vV", long_options,
+ &option_index);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'b':
+ /* Only bytchk=0 and =1 are meaningful for this command in
+ * sbc4r02 (not =2 nor =3) but that may change in the future. */
+ bytchk = sg_get_num(optarg);
+ if ((bytchk < 0) || (bytchk > 3)) {
+ pr2serr("argument to '--bytchk' expected to be 0 to 3\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ break;
+ case 'd':
+ dpo = true;
+ break;
+ case 'g':
+ group = sg_get_num(optarg);
+ if ((group < 0) || (group > 63)) {
+ pr2serr("argument to '--group' expected to be 0 to 63\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ break;
+ case 'h':
+ case '?':
+ usage();
+ return 0;
+ case 'i':
+ ifnp = optarg;
+ has_filename = true;
+ break;
+ case 'I':
+ ilen = sg_get_num(optarg);
+ if (-1 == ilen) {
+ pr2serr("bad argument to '--ilen'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ break;
+ case 'l':
+ if (lba_given) {
+ pr2serr("must have one and only one '--lba'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ ll = sg_get_llnum(optarg);
+ if (ll < 0) {
+ pr2serr("bad argument to '--lba'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ llba = (uint64_t)ll;
+ lba_given = true;
+ break;
+ case 'n':
+ n = sg_get_num(optarg);
+ if (-1 == n) {
+ pr2serr("bad argument to '--num'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ num_lb = (uint32_t)n;
+ break;
+ case 'R':
+ repeat = true;
+ break;
+ case 'S':
+ do_16 = true;
+ given_do_16 = true;
+ break;
+ case 't':
+ timeout = sg_get_num(optarg);
+ if (timeout < 1) {
+ pr2serr("bad argument to '--timeout'\n");
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ break;
+ case 'v':
+ verbose_given = true;
+ ++verbose;
+ break;
+ case 'V':
+ version_given = true;
+ break;
+ case 'w':
+ wrprotect = sg_get_num(optarg);
+ if ((wrprotect < 0) || (wrprotect > 7)) {
+ pr2serr("wrprotect (%d) is out of range ( < %d)\n", wrprotect,
+ 7);
+ return SG_LIB_SYNTAX_ERROR;
+ }
+
+ break;
+ default:
+ pr2serr("unrecognised option code 0x%x ??\n", c);
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ }
+ if (optind < argc) {
+ if (NULL == device_name) {
+ device_name = argv[optind];
+ ++optind;
+ }
+ if (optind < argc) {
+ for (; optind < argc; ++optind)
+ pr2serr("Unexpected extra argument: %s\n", argv[optind]);
+ usage();
+ 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;
+ verbose = 0;
+ } else if (! verbose_given) {
+ pr2serr("set '-vv'\n");
+ verbose = 2;
+ } else
+ pr2serr("keep verbose=%d\n", verbose);
+#else
+ if (verbose_given && version_given)
+ pr2serr("Not in DEBUG mode, so '-vV' has no special action\n");
+#endif
+ if (version_given) {
+ pr2serr(ME "version: %s\n", version_str);
+ return 0;
+ }
+
+ if (NULL == device_name) {
+ pr2serr("Missing device name!\n\n");
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (! lba_given) {
+ pr2serr("need a --lba=LBA option\n");
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ if (repeat) {
+ if (! has_filename) {
+ pr2serr("with '--repeat' need '--in=IF' option\n");
+ usage();
+ return SG_LIB_CONTRADICT;
+ }
+ if (ilen < 1) {
+ pr2serr("with '--repeat' need '--ilen=ILEN' option\n");
+ usage();
+ return SG_LIB_CONTRADICT;
+ } else {
+ b_p_lb = ilen / num_lb;
+ if (b_p_lb < 64) {
+ pr2serr("calculated %d bytes per logical block, too small\n",
+ b_p_lb);
+ usage();
+ return SG_LIB_SYNTAX_ERROR;
+ }
+ }
+ }
+
+ sg_fd = sg_cmds_open_device(device_name, false /* rw */, verbose);
+ if (sg_fd < 0) {
+ ret = sg_convert_errno(-sg_fd);
+ pr2serr(ME "open error: %s: %s\n", device_name, safe_strerror(-sg_fd));
+ goto err_out;
+ }
+
+ if ((! do_16) && (llba > UINT_MAX))
+ do_16 = true;
+ if ((! do_16) && (num_lb > 0xffff))
+ do_16 = true;
+ snprintf(cmd_name, sizeof(cmd_name), "Write and verify(%d)",
+ (do_16 ? 16 : 10));
+ if (verbose && (! given_do_16) && do_16)
+ pr2serr("Switching to %s because LBA or NUM too large\n", cmd_name);
+ if (verbose) {
+ pr2serr("Issue %s to device %s\n\tilen=%d", cmd_name, device_name,
+ ilen);
+ if (ilen > 0)
+ pr2serr(" [0x%x]", ilen);
+ pr2serr(", lba=%" PRIu64 " [0x%" PRIx64 "]\n\twrprotect=%d, dpo=%d, "
+ "bytchk=%d, group=%d, repeat=%d\n", llba, llba, wrprotect,
+ (int)dpo, bytchk, group, (int)repeat);
+ }
+
+ first_time = true;
+ do {
+ if (first_time) {
+ //If a file with data to write has been provided
+ if (has_filename) {
+ struct stat a_stat;
+
+ if ((1 == strlen(ifnp)) && ('-' == ifnp[0])) {
+ ifd = STDIN_FILENO;
+ ifnp = "<stdin>";
+ if (verbose > 1)
+ pr2serr("Reading input data from stdin\n");
+ } else {
+ ifd = open_if(ifnp, 0);
+ if (ifd < 0) {
+ ret = -ifd;
+ goto err_out;
+ }
+ }
+ if (ilen < 1) {
+ if (fstat(ifd, &a_stat) < 0) {
+ pr2serr("Could not fstat(%s)\n", ifnp);
+ goto err_out;
+ }
+ if (! S_ISREG(a_stat.st_mode)) {
+ pr2serr("Cannot determine IF size, please give "
+ "'--ilen='\n");
+ goto err_out;
+ }
+ ilen = (int)a_stat.st_size;
+ if (ilen < 1) {
+ pr2serr("%s file size too small\n", ifnp);
+ goto err_out;
+ } else if (verbose)
+ pr2serr("Using file size of %d bytes\n", ilen);
+ }
+ if (NULL == (wrkBuff = (uint8_t *)sg_memalign(ilen, 0,
+ &free_wrkBuff, verbose > 3))) {
+ pr2serr(ME "out of memory\n");
+ ret = sg_convert_errno(ENOMEM);
+ goto err_out;
+ }
+ wvb = (uint8_t *)wrkBuff;
+ res = read(ifd, wvb, ilen);
+ if (res < 0) {
+ pr2serr("Could not read from %s", ifnp);
+ goto err_out;
+ }
+ if (res < ilen) {
+ pr2serr("Read only %d bytes (expected %d) from %s\n", res,
+ ilen, ifnp);
+ if (repeat)
+ pr2serr("Will scale subsequent pieces when "
+ "repeat=true, but this is first\n");
+ goto err_out;
+ }
+ } else {
+ if (ilen < 1) {
+ if (verbose)
+ pr2serr("Default write length to %d*%d=%d bytes\n",
+ num_lb, 512, 512 * num_lb);
+ ilen = 512 * num_lb;
+ }
+ if (NULL == (wrkBuff = (uint8_t *)sg_memalign(ilen, 0,
+ &free_wrkBuff, verbose > 3))) {
+ pr2serr(ME "out of memory\n");
+ ret = sg_convert_errno(ENOMEM);
+ goto err_out;
+ }
+ wvb = (uint8_t *)wrkBuff;
+ /* Not sure about this: default contents to 0xff bytes */
+ memset(wrkBuff, 0xff, ilen);
+ }
+ first_time = false;
+ snum_lb = num_lb;
+ } else { /* repeat=true, first_time=false, must be reading file */
+ llba += snum_lb;
+ res = read(ifd, wvb, ilen);
+ if (res < 0) {
+ pr2serr("Could not read from %s", ifnp);
+ goto err_out;
+ } else {
+ if (verbose > 1)
+ pr2serr("Subsequent read from %s got %d bytes\n", ifnp, res);
+ if (0 == res)
+ break;
+ if (res < ilen) {
+ snum_lb = (uint32_t)(res / b_p_lb);
+ n = res % b_p_lb;
+ if (0 != n)
+ pr2serr(">>> warning: ignoring last %d bytes of %s\n",
+ n, ifnp);
+ if (snum_lb < 1)
+ break;
+ }
+ }
+ }
+ if (do_16)
+ res = sg_ll_write_verify16(sg_fd, wrprotect, dpo, bytchk, llba,
+ snum_lb, group, wvb, ilen, timeout,
+ verbose > 0, verbose);
+ else
+ res = sg_ll_write_verify10(sg_fd, wrprotect, dpo, bytchk,
+ (unsigned int)llba, snum_lb, group,
+ wvb, ilen, timeout, verbose > 0,
+ verbose);
+ ret = res;
+ if (repeat && (0 == ret))
+ tnum_lb_wr += snum_lb;
+ if (ret || (snum_lb != num_lb))
+ break;
+ } while (repeat);
+
+err_out:
+ if (repeat)
+ pr2serr("%d [0x%x] logical blocks written, in total\n", tnum_lb_wr,
+ tnum_lb_wr);
+ if (free_wrkBuff)
+ free(free_wrkBuff);
+ if ((ifd >= 0) && (STDIN_FILENO != ifd))
+ close(ifd);
+ res = sg_cmds_close_device(sg_fd);
+ if (res < 0) {
+ pr2serr("close error: %s\n", safe_strerror(-res));
+ if (0 == ret)
+ ret = sg_convert_errno(-res);
+ }
+ if (ret && (0 == verbose)) {
+ if (! sg_if_can2stderr("sg_write_verify failed: ", ret))
+ pr2serr("Some error occurred, try again with '-v' "
+ "or '-vv' for more information\n");
+ }
+ return (ret >= 0) ? ret : SG_LIB_CAT_OTHER;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-12 17:31:11 +0000