| /* |
| * Copyright (c) 2004-2020 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 |
| */ |
| |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <getopt.h> |
| #define __STDC_FORMAT_MACROS 1 |
| #include <inttypes.h> |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| #include "sg_lib.h" |
| #include "sg_cmds_basic.h" |
| #include "sg_cmds_extra.h" |
| #include "sg_pr2serr.h" |
| |
| /* A utility program for the Linux OS SCSI subsystem. |
| * |
| * This program issues the SCSI VERIFY(10) or VERIFY(16) command to the given |
| * SCSI block device. |
| * |
| * N.B. This utility should, but doesn't, check the logical block size with |
| * the SCSI READ CAPACITY command. It is up to the user to make sure that |
| * the count of blocks requested and the number of bytes transferred (when |
| * BYTCHK>0) are "in sync". That caclculation is somewhat complicated by |
| * the possibility of protection data (DIF). |
| */ |
| |
| static const char * version_str = "1.27 20201029"; /* sbc4r17 */ |
| |
| #define ME "sg_verify: " |
| |
| #define EBUFF_SZ 256 |
| |
| |
| static struct option long_options[] = { |
| {"0", no_argument, 0, '0'}, |
| {"16", no_argument, 0, 'S'}, |
| {"bpc", required_argument, 0, 'b'}, |
| {"bytchk", required_argument, 0, 'B'}, /* 4 backward compatibility */ |
| {"count", required_argument, 0, 'c'}, |
| {"dpo", no_argument, 0, 'd'}, |
| {"ebytchk", required_argument, 0, 'E'}, /* extended bytchk (2 bits) */ |
| {"group", required_argument, 0, 'g'}, |
| {"help", no_argument, 0, 'h'}, |
| {"in", required_argument, 0, 'i'}, |
| {"lba", required_argument, 0, 'l'}, |
| {"nbo", required_argument, 0, 'n'}, /* misspelling, legacy */ |
| {"ndo", required_argument, 0, 'n'}, |
| {"quiet", no_argument, 0, 'q'}, |
| {"readonly", no_argument, 0, 'r'}, |
| {"verbose", no_argument, 0, 'v'}, |
| {"version", no_argument, 0, 'V'}, |
| {"vrprotect", required_argument, 0, 'P'}, |
| {0, 0, 0, 0}, |
| }; |
| |
| static void |
| usage() |
| { |
| pr2serr("Usage: sg_verify [--0] [--16] [--bpc=BPC] [--count=COUNT] " |
| "[--dpo]\n" |
| " [--ebytchk=BCH] [--ff] [--group=GN] [--help] " |
| "[--in=IF]\n" |
| " [--lba=LBA] [--ndo=NDO] [--quiet] " |
| "[--readonly]\n" |
| " [--verbose] [--version] [--vrprotect=VRP] " |
| "DEVICE\n" |
| " where:\n" |
| " --0|-0 fill buffer with zeros (don't read " |
| "stdin)\n" |
| " --16|-S use VERIFY(16) (def: use " |
| "VERIFY(10) )\n" |
| " --bpc=BPC|-b BPC max blocks per verify command " |
| "(def: 128)\n" |
| " --count=COUNT|-c COUNT count of blocks to verify " |
| "(def: 1).\n" |
| " --dpo|-d disable page out (cache retention " |
| "priority)\n" |
| " --ebytchk=BCH|-E BCH sets BYTCHK value, either 1, 2 " |
| "or 3 (def: 0).\n" |
| " BCH overrides BYTCHK=1 set by " |
| "'--ndo='. If\n" |
| " BCH is 3 then NDO must be the LBA " |
| "size\n" |
| " (plus protection size if DIF " |
| "active)\n" |
| " --ff|-f fill buffer with 0xff bytes (don't read " |
| "stdin)\n" |
| " --group=GN|-g GN set group number field to GN (def: 0)\n" |
| " --help|-h print out usage message\n" |
| " --in=IF|-i IF input from file called IF (def: " |
| "stdin)\n" |
| " only active if --ebytchk=BCH given\n" |
| " --lba=LBA|-l LBA logical block address to start " |
| "verify (def: 0)\n" |
| " --ndo=NDO|-n NDO NDO is number of bytes placed in " |
| "data-out buffer.\n" |
| " These are fetched from IF (or " |
| "stdin) and used\n" |
| " to verify the device data against. " |
| "Forces\n" |
| " --bpc=COUNT. Sets BYTCHK (byte check) " |
| "to 1\n" |
| " --quiet|-q suppress miscompare report to stderr, " |
| "still\n" |
| " causes an exit status of 14\n" |
| " --readonly|-r open DEVICE read-only (def: open it " |
| "read-write)\n" |
| " --verbose|-v increase verbosity\n" |
| " --version|-V print version string and exit\n" |
| " --vrprotect=VRP|-P VRP set vrprotect field to VRP " |
| "(def: 0)\n\n" |
| "Performs one or more SCSI VERIFY(10) or SCSI VERIFY(16) " |
| "commands. sbc3r34\nmade the BYTCHK field two bits wide " |
| "(it was a single bit).\n"); |
| } |
| |
| int |
| main(int argc, char * argv[]) |
| { |
| bool bpc_given = false; |
| bool dpo = false; |
| bool ff_given = false; |
| bool got_stdin = false; |
| bool quiet = false; |
| bool readonly = false; |
| bool verbose_given = false; |
| bool verify16 = false; |
| bool version_given = false; |
| bool zero_given = false; |
| int res, c, num, nread, infd; |
| int sg_fd = -1; |
| int bpc = 128; |
| int group = 0; |
| int bytchk = 0; |
| int ndo = 0; /* number of bytes in data-out buffer */ |
| int verbose = 0; |
| int ret = 0; |
| int vrprotect = 0; |
| unsigned int info = 0; |
| int64_t count = 1; |
| int64_t ll; |
| int64_t orig_count; |
| uint64_t info64 = 0; |
| uint64_t lba = 0; |
| uint64_t orig_lba; |
| uint8_t * ref_data = NULL; |
| uint8_t * free_ref_data = NULL; |
| const char * device_name = NULL; |
| const char * file_name = NULL; |
| const char * vc; |
| char ebuff[EBUFF_SZ]; |
| |
| while (1) { |
| int option_index = 0; |
| |
| c = getopt_long(argc, argv, "0b:B:c:dE:fg:hi:l:n:P:qrSvV", |
| long_options, &option_index); |
| if (c == -1) |
| break; |
| |
| switch (c) { |
| case '0': |
| zero_given = true; |
| break; |
| case 'b': |
| bpc = sg_get_num(optarg); |
| if (bpc < 1) { |
| pr2serr("bad argument to '--bpc'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| bpc_given = true; |
| break; |
| case 'c': |
| count = sg_get_llnum(optarg); |
| if (count < 0) { |
| pr2serr("bad argument to '--count'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'd': |
| dpo = true; |
| break; |
| case 'E': |
| bytchk = sg_get_num(optarg); |
| if ((bytchk < 0) || (bytchk > 3)) { |
| pr2serr("bad argument to '--ebytchk'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'f': |
| ff_given = true; |
| break; |
| case 'g': |
| group = sg_get_num(optarg); |
| if ((group < 0) || (group > 63)) { |
| pr2serr("bad argument to '--group'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'h': |
| case '?': |
| usage(); |
| return 0; |
| case 'i': |
| file_name = optarg; |
| break; |
| case 'l': |
| ll = sg_get_llnum(optarg); |
| if (-1 == ll) { |
| pr2serr("bad argument to '--lba'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| lba = (uint64_t)ll; |
| break; |
| case 'n': /* number of bytes in data-out buffer */ |
| case 'B': /* undocumented, old --bytchk=NDO option */ |
| ndo = sg_get_num(optarg); |
| if (ndo < 1) { |
| pr2serr("bad argument to '--ndo'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'P': |
| vrprotect = sg_get_num(optarg); |
| if (-1 == vrprotect) { |
| pr2serr("bad argument to '--vrprotect'\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| if ((vrprotect < 0) || (vrprotect > 7)) { |
| pr2serr("'--vrprotect' requires a value from 0 to 7 " |
| "(inclusive)\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| break; |
| case 'q': |
| quiet = true; |
| break; |
| case 'r': |
| readonly = true; |
| break; |
| case 'S': |
| verify16 = true; |
| break; |
| case 'v': |
| verbose_given = true; |
| ++verbose; |
| break; |
| case 'V': |
| version_given = true; |
| 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 (ndo > 0) { |
| if (0 == bytchk) |
| bytchk = 1; |
| if (bpc_given && (bpc != count)) |
| pr2serr("'bpc' argument ignored, using --bpc=%" PRIu64 "\n", |
| count); |
| if (count > 0x7fffffffLL) { |
| pr2serr("count exceed 31 bits, way too large\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| #if 0 |
| if ((3 == bytchk) && (1 != count)) { |
| pr2serr("count must be 1 when bytchk=3\n"); |
| return SG_LIB_SYNTAX_ERROR; |
| } |
| // bpc = (int)count; |
| #endif |
| } else if (bytchk > 0) { |
| pr2serr("when the 'ebytchk=BCH' option is given, then '--ndo=NDO' " |
| "must also be given\n"); |
| return SG_LIB_CONTRADICT; |
| } |
| if ((zero_given || ff_given) && file_name) { |
| pr2serr("giving --0 or --ff is not compatible with --if=%s\n", |
| file_name); |
| return SG_LIB_CONTRADICT; |
| } |
| |
| if ((bpc > 0xffff) && (! verify16)) { |
| pr2serr("'%s' exceeds 65535, so use VERIFY(16)\n", |
| (ndo > 0) ? "count" : "bpc"); |
| verify16 = true; |
| } |
| if (((lba + count - 1) > 0xffffffffLLU) && (! verify16)) { |
| pr2serr("'lba' exceed 32 bits, so use VERIFY(16)\n"); |
| verify16 = true; |
| } |
| if ((group > 0) && (! verify16)) |
| pr2serr("group number ignored with VERIFY(10) command, use the --16 " |
| "option\n"); |
| |
| orig_count = count; |
| orig_lba = lba; |
| |
| if (ndo > 0) { |
| ref_data = (uint8_t *)sg_memalign(ndo, 0, &free_ref_data, verbose > 4); |
| if (NULL == ref_data) { |
| pr2serr("failed to allocate %d byte buffer\n", ndo); |
| ret = sg_convert_errno(ENOMEM); |
| goto err_out; |
| } |
| if (ff_given) |
| memset(ref_data, 0xff, ndo); |
| if (zero_given || ff_given) |
| goto skip; |
| if ((NULL == file_name) || (0 == strcmp(file_name, "-"))) { |
| got_stdin = true; |
| infd = STDIN_FILENO; |
| if (sg_set_binary_mode(STDIN_FILENO) < 0) |
| perror("sg_set_binary_mode"); |
| } else { |
| if ((infd = open(file_name, O_RDONLY)) < 0) { |
| ret = sg_convert_errno(errno); |
| snprintf(ebuff, EBUFF_SZ, |
| ME "could not open %s for reading", file_name); |
| perror(ebuff); |
| goto err_out; |
| } else if (sg_set_binary_mode(infd) < 0) |
| perror("sg_set_binary_mode"); |
| } |
| if (verbose && got_stdin) |
| pr2serr("about to wait on STDIN\n"); |
| for (nread = 0; nread < ndo; nread += res) { |
| res = read(infd, ref_data + nread, ndo - nread); |
| if (res <= 0) { |
| ret = sg_convert_errno(errno); |
| pr2serr("reading from %s failed at file offset=%d\n", |
| (got_stdin ? "stdin" : file_name), nread); |
| goto err_out; |
| } |
| } |
| if (! got_stdin) |
| close(infd); |
| } |
| skip: |
| if (NULL == device_name) { |
| pr2serr("missing device name!\n\n"); |
| usage(); |
| ret = SG_LIB_SYNTAX_ERROR; |
| goto err_out; |
| } |
| sg_fd = sg_cmds_open_device(device_name, readonly, verbose); |
| if (sg_fd < 0) { |
| if (verbose) |
| pr2serr(ME "open error: %s: %s\n", device_name, |
| safe_strerror(-sg_fd)); |
| ret = sg_convert_errno(-sg_fd); |
| goto err_out; |
| } |
| |
| vc = verify16 ? "VERIFY(16)" : "VERIFY(10)"; |
| for (; count > 0; count -= bpc, lba += bpc) { |
| num = (count > bpc) ? bpc : count; |
| if (verify16) |
| res = sg_ll_verify16(sg_fd, vrprotect, dpo, bytchk, |
| lba, num, group, ref_data, |
| ndo, &info64, !quiet , verbose); |
| else |
| res = sg_ll_verify10(sg_fd, vrprotect, dpo, bytchk, |
| (unsigned int)lba, num, ref_data, |
| ndo, &info, !quiet, verbose); |
| if (0 != res) { |
| char b[80]; |
| |
| ret = res; |
| switch (res) { |
| case SG_LIB_CAT_ILLEGAL_REQ: |
| pr2serr("bad field in %s cdb, near lba=0x%" PRIx64 "\n", vc, |
| lba); |
| break; |
| case SG_LIB_CAT_MEDIUM_HARD: |
| pr2serr("%s medium or hardware error near lba=0x%" PRIx64 "\n", |
| vc, lba); |
| break; |
| case SG_LIB_CAT_MEDIUM_HARD_WITH_INFO: |
| if (verify16) |
| pr2serr("%s medium or hardware error, reported lba=0x%" |
| PRIx64 "\n", vc, info64); |
| else |
| pr2serr("%s medium or hardware error, reported lba=0x%x\n", |
| vc, info); |
| break; |
| case SG_LIB_CAT_MISCOMPARE: |
| if ((0 == quiet) || verbose) |
| pr2serr("%s MISCOMPARE: started at LBA 0x%" PRIx64 "\n", |
| vc, lba); |
| break; |
| default: |
| sg_get_category_sense_str(res, sizeof(b), b, verbose); |
| pr2serr("%s: %s\n", vc, b); |
| pr2serr(" failed near lba=%" PRIu64 " [0x%" PRIx64 "]\n", |
| lba, lba); |
| break; |
| } |
| break; |
| } |
| } |
| |
| if (verbose && (0 == ret) && (orig_count > 1)) |
| pr2serr("Verified %" PRId64 " [0x%" PRIx64 "] blocks from lba %" PRIu64 |
| " [0x%" PRIx64 "]\n without error\n", orig_count, |
| (uint64_t)orig_count, orig_lba, orig_lba); |
| |
| err_out: |
| if (sg_fd >= 0) { |
| 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 (free_ref_data) |
| free(free_ref_data); |
| if (0 == verbose) { |
| if (! sg_if_can2stderr("sg_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; |
| } |
