/* 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 #include #include #include #include #include #include #include #include #define __STDC_FORMAT_MACROS 1 #include #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; }