diff options
Diffstat (limited to 'src/sg_write_long.c')
-rw-r--r-- | src/sg_write_long.c | 331 |
1 files changed, 331 insertions, 0 deletions
diff --git a/src/sg_write_long.c b/src/sg_write_long.c new file mode 100644 index 00000000..af323cc7 --- /dev/null +++ b/src/sg_write_long.c @@ -0,0 +1,331 @@ +/* A utility program for the Linux OS SCSI subsystem. + * Copyright (C) 2004-2018 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) + * any later version. + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * This program issues the SCSI command WRITE LONG to a given SCSI device. + * It sends the command with the logical block address passed as the lba + * argument, and the transfer length set to the xfer_len argument. the + * buffer to be written to the device filled with 0xff, this buffer includes + * the sector data and the ECC bytes. + * + * This code was contributed by Saeed Bishara + */ + +#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 <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" + +static const char * version_str = "1.21 20180723"; + + +#define MAX_XFER_LEN (15 * 1024) + +#define ME "sg_write_long: " + +#define EBUFF_SZ 512 + +static struct option long_options[] = { + {"16", no_argument, 0, 'S'}, + {"cor_dis", no_argument, 0, 'c'}, + {"cor-dis", no_argument, 0, 'c'}, + {"help", no_argument, 0, 'h'}, + {"in", required_argument, 0, 'i'}, + {"lba", required_argument, 0, 'l'}, + {"pblock", no_argument, 0, 'p'}, + {"verbose", no_argument, 0, 'v'}, + {"version", no_argument, 0, 'V'}, + {"wr_uncor", no_argument, 0, 'w'}, + {"wr-uncor", no_argument, 0, 'w'}, + {"xfer_len", required_argument, 0, 'x'}, + {"xfer-len", required_argument, 0, 'x'}, + {0, 0, 0, 0}, +}; + + + +static void +usage() +{ + pr2serr("Usage: sg_write_long [--16] [--cor_dis] [--help] [--in=IF] " + "[--lba=LBA]\n" + " [--pblock] [--verbose] [--version] " + "[--wr_uncor]\n" + " [--xfer_len=BTL] DEVICE\n" + " where:\n" + " --16|-S do WRITE LONG(16) (default: 10)\n" + " --cor_dis|-c set correction disabled bit\n" + " --help|-h print out usage message\n" + " --in=IF|-i IF input from file called IF (default: " + "use\n" + " 0xff bytes as fill)\n" + " --lba=LBA|-l LBA logical block address " + "(default: 0)\n" + " --pblock|-p physical block (default: logical " + "block)\n" + " --verbose|-v increase verbosity\n" + " --version|-V print version string then exit\n" + " --wr_uncor|-w set an uncorrectable error (no " + "data transferred)\n" + " --xfer_len=BTL|-x BTL byte transfer length (< 10000) " + "(default:\n" + " 520 bytes)\n\n" + "Performs a SCSI WRITE LONG (10 or 16) command. Writes a single " + "block\nincluding associated ECC data. That data may be obtained " + "from the\nSCSI READ LONG command. See the sg_read_long utility.\n" + ); +} + +int +main(int argc, char * argv[]) +{ + bool do_16 = false; + bool cor_dis = false; + bool got_stdin; + bool pblock = false; + bool verbose_given = false; + bool version_given = false; + bool wr_uncor = false; + int res, c, infd, offset; + int sg_fd = -1; + int xfer_len = 520; + int ret = 1; + int verbose = 0; + int64_t ll; + uint64_t llba = 0; + const char * device_name = NULL; + uint8_t * writeLongBuff = NULL; + void * rawp = NULL; + uint8_t * free_rawp = NULL; + const char * ten_or; + char file_name[256]; + char b[80]; + char ebuff[EBUFF_SZ]; + + memset(file_name, 0, sizeof file_name); + while (1) { + int option_index = 0; + + c = getopt_long(argc, argv, "chi:l:pSvVwx:", long_options, + &option_index); + if (c == -1) + break; + + switch (c) { + case 'c': + cor_dis = true; + break; + case 'h': + case '?': + usage(); + return 0; + case 'i': + strncpy(file_name, optarg, sizeof(file_name) - 1); + file_name[sizeof(file_name) - 1] = '\0'; + break; + case 'l': + ll = sg_get_llnum(optarg); + if (-1 == ll) { + pr2serr("bad argument to '--lba'\n"); + return SG_LIB_SYNTAX_ERROR; + } + llba = (uint64_t)ll; + break; + case 'p': + pblock = true; + break; + case 'S': + do_16 = true; + break; + case 'v': + verbose_given = true; + ++verbose; + break; + case 'V': + version_given = true; + break; + case 'w': + wr_uncor = true; + break; + case 'x': + xfer_len = sg_get_num(optarg); + if (-1 == xfer_len) { + pr2serr("bad argument to '--xfer_len'\n"); + 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 (wr_uncor) + xfer_len = 0; + else if (xfer_len >= MAX_XFER_LEN) { + pr2serr("xfer_len (%d) is out of range ( < %d)\n", xfer_len, + MAX_XFER_LEN); + usage(); + return SG_LIB_SYNTAX_ERROR; + } + sg_fd = sg_cmds_open_device(device_name, false /* rw */, 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; + } + + if (wr_uncor) { + if ('\0' != file_name[0]) + pr2serr(">>> warning: when '--wr_uncor' given '-in=' is " + "ignored\n"); + } else { + if (NULL == (rawp = sg_memalign(MAX_XFER_LEN, 0, &free_rawp, false))) { + pr2serr(ME "out of memory\n"); + ret = sg_convert_errno(ENOMEM); + goto err_out; + } + writeLongBuff = (uint8_t *)rawp; + memset(rawp, 0xff, MAX_XFER_LEN); + if (file_name[0]) { + got_stdin = (0 == strcmp(file_name, "-")); + if (got_stdin) { + 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) { + 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"); + } + res = read(infd, writeLongBuff, xfer_len); + if (res < 0) { + snprintf(ebuff, EBUFF_SZ, ME "couldn't read from %s", + file_name); + perror(ebuff); + if (! got_stdin) + close(infd); + goto err_out; + } + if (res < xfer_len) { + pr2serr("tried to read %d bytes from %s, got %d bytes\n", + xfer_len, file_name, res); + pr2serr("pad with 0xff bytes and continue\n"); + } + if (! got_stdin) + close(infd); + } + } + if (verbose) + pr2serr(ME "issue write long to device %s\n\t\txfer_len= %d (0x%x), " + "lba=%" PRIu64 " (0x%" PRIx64 ")\n cor_dis=%d, " + "wr_uncor=%d, pblock=%d\n", device_name, xfer_len, xfer_len, + llba, llba, (int)cor_dis, (int)wr_uncor, (int)pblock); + + ten_or = do_16 ? "16" : "10"; + if (do_16) + res = sg_ll_write_long16(sg_fd, cor_dis, wr_uncor, pblock, llba, + writeLongBuff, xfer_len, &offset, true, + verbose); + else + res = sg_ll_write_long10(sg_fd, cor_dis, wr_uncor, pblock, + (unsigned int)llba, writeLongBuff, xfer_len, + &offset, true, verbose); + ret = res; + switch (res) { + case 0: + break; + case SG_LIB_CAT_ILLEGAL_REQ_WITH_INFO: + pr2serr("<<< device indicates 'xfer_len' should be %d >>>\n", + xfer_len - offset); + break; + default: + sg_get_category_sense_str(res, sizeof(b), b, verbose); + pr2serr(" SCSI WRITE LONG (%s): %s\n", ten_or, b); + break; + } + +err_out: + if (free_rawp) + free(free_rawp); + 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 (0 == verbose) { + if (! sg_if_can2stderr("sg_write_long failed: ", ret)) + pr2serr("Some error occurred, try again with '-v' " + "or '-vv' for more information\n"); + } + return (ret >= 0) ? ret : SG_LIB_CAT_OTHER; +} |