/* Returns 1 if no errors found and thus nothing printed; otherwise
prints error/warning (prefix by 'leadin') and returns 0. */
static int
sg_linux_sense_print(const char * leadin, int scsi_status, int host_status,
int driver_status, const unsigned char * sense_buffer,
int sb_len, int raw_sinfo)
{
int done_leadin = 0;
int done_sense = 0;
scsi_status &= 0x7e; /*sanity */
if ((0 == scsi_status) && (0 == host_status) && (0 == driver_status))
return 1; /* No problems */
if (0 != scsi_status) {
if (leadin)
pr2ws("%s: ", leadin);
done_leadin = 1;
pr2ws("SCSI status: ");
sg_print_scsi_status(scsi_status);
pr2ws("\n");
if (sense_buffer && ((scsi_status == SAM_STAT_CHECK_CONDITION) ||
(scsi_status == SAM_STAT_COMMAND_TERMINATED))) {
/* SAM_STAT_COMMAND_TERMINATED is obsolete */
sg_print_sense(0, sense_buffer, sb_len, raw_sinfo);
done_sense = 1;
}
}
if (0 != host_status) {
if (leadin && (! done_leadin))
pr2ws("%s: ", leadin);
if (done_leadin)
pr2ws("plus...: ");
else
done_leadin = 1;
sg_print_host_status(host_status);
pr2ws("\n");
}
if (0 != driver_status) {
if (done_sense &&
(SG_LIB_DRIVER_SENSE == (SG_LIB_DRIVER_MASK & driver_status)))
return 0;
if (leadin && (! done_leadin))
pr2ws("%s: ", leadin);
if (done_leadin)
pr2ws("plus...: ");
else
done_leadin = 1;
sg_print_driver_status(driver_status);
pr2ws("\n");
if (sense_buffer && (! done_sense) &&
(SG_LIB_DRIVER_SENSE == (SG_LIB_DRIVER_MASK & driver_status)))
sg_print_sense(0, sense_buffer, sb_len, raw_sinfo);
}
return 0;
}
static int
do_cmd_sense(int sg_fd, int hex, int quiet, int verbose)
{
int res, resp_len, sk, asc, ascq, progress, something;
unsigned char buff[32];
char b[128];
memset(buff, 0, sizeof(buff));
res = sg_ll_request_sense(sg_fd, 0 /* fixed format */,
buff, sizeof(buff), 1, verbose);
if (0 == res) {
resp_len = buff[7] + 8;
if (resp_len > (int)sizeof(buff))
resp_len = sizeof(buff);
sk = (0xf & buff[2]);
if (hex) {
dStrHex((const char *)buff, resp_len, 1);
return 0;
}
something = 0;
if (verbose) {
fprintf(stderr, "Decode response as sense data:\n");
sg_print_sense(NULL, buff, resp_len, 0);
if (verbose > 1) {
fprintf(stderr, "\nOutput response in hex\n");
dStrHex((const char *)buff, resp_len, 1);
}
something = 1;
}
asc = (resp_len > 12) ? buff[12] : 0;
ascq = (resp_len > 13) ? buff[13] : 0;
if (sg_get_sense_progress_fld(buff, resp_len, &progress)) {
printf("Operation in progress, %d%% done\n",
progress * 100 / 65536);
something = 1;
}
if (0 == sk) { /* NO SENSE */
/* check for hardware threshold exceeded or warning */
if ((0xb == asc) || (0x5d == asc))
printf("%s\n", sg_get_asc_ascq_str(asc, ascq,
(int)sizeof(b), b));
/* check for low power conditions */
if (0x5e == asc)
printf("%s\n", sg_get_asc_ascq_str(asc, ascq,
(int)sizeof(b), b));
return 0;
} else {
if (! (something || verbose || quiet)) {
fprintf(stderr, "Decode response as sense data:\n");
sg_print_sense(NULL, buff, resp_len, 0);
}
return 0;
}
} else if (SG_LIB_CAT_INVALID_OP == res)
fprintf(stderr, "Request Sense command not supported\n");
else if (SG_LIB_CAT_ILLEGAL_REQ == res)
fprintf(stderr, "bad field in Request Sense cdb\n");
else if (SG_LIB_CAT_NOT_READY == res)
fprintf(stderr, "Request Sense failed, device not ready\n");
else if (SG_LIB_CAT_ABORTED_COMMAND == res)
fprintf(stderr, "Request Sense failed, aborted command\n");
else {
fprintf(stderr, "Request Sense command failed\n");
if (0 == verbose)
fprintf(stderr, " try the '-v' option for "
"more information\n");
}
return res;
}
static int
do_read_gplog(int sg_fd, int ata_cmd, unsigned char *inbuff,
const struct opts_t * op)
{
int res, ret;
int extend = 1;
int protocol;
int t_dir = 1; /* 0 -> to device, 1 -> from device */
int byte_block = 1; /* 0 -> bytes, 1 -> 512 byte blocks */
int t_length = 2; /* 0 -> no data transferred, 2 -> sector count */
int t_type = 0; /* 0 -> 512 byte blocks, 1 -> logical sectors */
int resid = 0;
int got_ard = 0; /* got ATA result descriptor */
int sb_sz;
struct sg_scsi_sense_hdr ssh;
unsigned char sense_buffer[64];
unsigned char ata_return_desc[16];
unsigned char apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
{SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0};
unsigned char apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
{SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0};
char cmd_name[32];
snprintf(cmd_name, sizeof(cmd_name), "ATA PASS-THROUGH (%d)",
op->cdb_len);
if (ata_cmd == ATA_READ_LOG_DMA_EXT) {
protocol = 6; /* DMA */
} else {
protocol = 4; /* PIO Data-In */
}
sb_sz = sizeof(sense_buffer);
memset(sense_buffer, 0, sb_sz);
memset(ata_return_desc, 0, sizeof(ata_return_desc));
memset(inbuff, 0, op->count * 512);
if (op->verbose > 1)
pr2serr("Building ATA READ LOG%s EXT command; la=0x%x, pn=0x%x\n",
((ata_cmd == ATA_READ_LOG_DMA_EXT) ? " DMA" : ""), op->la,
op->pn);
if (op->cdb_len == 16) {
/* Prepare ATA PASS-THROUGH COMMAND (16) command */
apt_cdb[14] = ata_cmd;
sg_put_unaligned_be16((uint16_t)op->count, apt_cdb + 5);
apt_cdb[8] = op->la;
sg_put_unaligned_be16((uint16_t)op->pn, apt_cdb + 9);
apt_cdb[1] = (protocol << 1) | extend;
apt_cdb[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
(byte_block << 2) | t_length;
res = sg_ll_ata_pt(sg_fd, apt_cdb, op->cdb_len, DEF_TIMEOUT, inbuff,
NULL, op->count * 512, sense_buffer,
sb_sz, ata_return_desc,
sizeof(ata_return_desc), &resid, op->verbose);
} else {
/* Prepare ATA PASS-THROUGH COMMAND (12) command */
/* Cannot map upper 8 bits of the pn since no LBA (39:32) field */
apt12_cdb[9] = ata_cmd;
apt12_cdb[4] = op->count;
apt12_cdb[5] = op->la;
apt12_cdb[6] = op->pn & 0xff;
/* apt12_cdb[7] = (op->pn >> 8) & 0xff; */
apt12_cdb[1] = (protocol << 1);
apt12_cdb[2] = (op->ck_cond << 5) | (t_type << 4) | (t_dir << 3) |
(byte_block << 2) | t_length;
res = sg_ll_ata_pt(sg_fd, apt12_cdb, op->cdb_len, DEF_TIMEOUT,
inbuff, NULL, op->count * 512, sense_buffer,
sb_sz, ata_return_desc,
sizeof(ata_return_desc), &resid, op->verbose);
}
if (0 == res) {
if (op->verbose > 2)
pr2serr("command completed with SCSI GOOD status\n");
if ((0 == op->hex) || (2 == op->hex))
dWordHex((const unsigned short *)inbuff, op->count * 256, 0,
sg_is_big_endian());
else if (1 == op->hex)
dStrHex((const char *)inbuff, 512, 0);
else if (3 == op->hex) /* '-HHH' suitable for "hdparm --Istdin" */
dWordHex((const unsigned short *)inbuff, 256, -2,
sg_is_big_endian());
else /* '-HHHH' hex bytes only */
dStrHex((const char *)inbuff, 512, -1);
} else if ((res > 0) && (res & SAM_STAT_CHECK_CONDITION)) {
if (op->verbose > 1) {
pr2serr("ATA pass through:\n");
sg_print_sense(NULL, sense_buffer, sb_sz,
((op->verbose > 2) ? 1 : 0));
}
if (sg_scsi_normalize_sense(sense_buffer, sb_sz, &ssh)) {
switch (ssh.sense_key) {
case SPC_SK_ILLEGAL_REQUEST:
if ((0x20 == ssh.asc) && (0x0 == ssh.ascq)) {
ret = SG_LIB_CAT_INVALID_OP;
if (op->verbose < 2)
pr2serr("%s not supported\n", cmd_name);
} else {
ret = SG_LIB_CAT_ILLEGAL_REQ;
if (op->verbose < 2)
pr2serr("%s, bad field in cdb\n", cmd_name);
}
return ret;
case SPC_SK_NO_SENSE:
case SPC_SK_RECOVERED_ERROR:
if ((0x0 == ssh.asc) &&
(ASCQ_ATA_PT_INFO_AVAILABLE == ssh.ascq)) {
if (SAT_ATA_RETURN_DESC != ata_return_desc[0]) {
if (op->verbose)
pr2serr("did not find ATA Return (sense) "
"Descriptor\n");
return SG_LIB_CAT_RECOVERED;
}
got_ard = 1;
break;
} else if (SPC_SK_RECOVERED_ERROR == ssh.sense_key)
return SG_LIB_CAT_RECOVERED;
else {
if ((0x0 == ssh.asc) && (0x0 == ssh.ascq))
break;
return SG_LIB_CAT_SENSE;
}
case SPC_SK_UNIT_ATTENTION:
if (op->verbose < 2)
pr2serr("%s, Unit Attention detected\n", cmd_name);
return SG_LIB_CAT_UNIT_ATTENTION;
case SPC_SK_NOT_READY:
if (op->verbose < 2)
pr2serr("%s, device not ready\n", cmd_name);
return SG_LIB_CAT_NOT_READY;
case SPC_SK_MEDIUM_ERROR:
case SPC_SK_HARDWARE_ERROR:
if (op->verbose < 2)
pr2serr("%s, medium or hardware error\n", cmd_name);
return SG_LIB_CAT_MEDIUM_HARD;
case SPC_SK_ABORTED_COMMAND:
if (0x10 == ssh.asc) {
pr2serr("Aborted command: protection information\n");
return SG_LIB_CAT_PROTECTION;
} else {
pr2serr("Aborted command\n");
return SG_LIB_CAT_ABORTED_COMMAND;
}
case SPC_SK_DATA_PROTECT:
pr2serr("%s: data protect, read only media?\n", cmd_name);
return SG_LIB_CAT_DATA_PROTECT;
default:
if (op->verbose < 2)
pr2serr("%s, some sense data, use '-v' for more "
"information\n", cmd_name);
return SG_LIB_CAT_SENSE;
}
} else {
pr2serr("CHECK CONDITION without response code ??\n");
return SG_LIB_CAT_SENSE;
}
if (0x72 != (sense_buffer[0] & 0x7f)) {
pr2serr("expected descriptor sense format, response "
"code=0x%x\n", sense_buffer[0]);
return SG_LIB_CAT_MALFORMED;
}
} else if (res > 0) {
if (SAM_STAT_RESERVATION_CONFLICT == res) {
pr2serr("SCSI status: RESERVATION CONFLICT\n");
return SG_LIB_CAT_RES_CONFLICT;
} else {
pr2serr("Unexpected SCSI status=0x%x\n", res);
return SG_LIB_CAT_MALFORMED;
}
} else {
pr2serr("%s failed\n", cmd_name);
if (op->verbose < 2)
pr2serr(" try adding '-v' for more information\n");
return -1;
}
if ((SAT_ATA_RETURN_DESC == ata_return_desc[0]) && (0 == got_ard))
pr2serr("Seem to have got ATA Result Descriptor but it was not "
"indicated\n");
if (got_ard) {
if (ata_return_desc[3] & 0x4) {
pr2serr("error indication in returned FIS: aborted "
"command\n");
return SG_LIB_CAT_ABORTED_COMMAND;
}
}
return 0;
}
int main(int argc, char * argv[])
{
int bsg_fd, k, ok;
unsigned char inqCmdBlk[INQ_CMD_LEN] =
{0x12, 0, 0, 0, INQ_REPLY_LEN, 0};
unsigned char sdiagCmdBlk[SDIAG_CMD_LEN] =
{0x1d, 0, 0, 0, 0, 0};
unsigned char inqBuff[16][INQ_REPLY_LEN];
struct sg_io_v4 io_hdr[16];
struct sg_io_v4 rio_hdr;
char * file_name = 0;
char ebuff[EBUFF_SZ];
unsigned char sense_buffer[16][SENSE_BUFFER_LEN];
int q_at_tail = 0;
for (k = 1; k < argc; ++k) {
if (0 == memcmp("-t", argv[k], 2))
++q_at_tail;
else if (*argv[k] == '-') {
printf("Unrecognized switch: %s\n", argv[k]);
file_name = 0;
break;
}
else if (0 == file_name)
file_name = argv[k];
else {
printf("too many arguments\n");
file_name = 0;
break;
}
}
if (0 == file_name) {
printf("Usage: 'bsg_queue_tst [-t] <bsg_device>'\n"
"where:\n -t queue_at_tail (def: q_at_head)\n");
return 1;
}
/* An access mode of O_RDWR is required for write()/read() interface */
if ((bsg_fd = open(file_name, O_RDWR)) < 0) {
snprintf(ebuff, EBUFF_SZ,
"bsg_queue_tst: error opening file: %s", file_name);
perror(ebuff);
return 1;
}
for (k = 0; k < 16; ++k) {
/* Prepare INQUIRY command */
memset(&io_hdr[k], 0, sizeof(struct sg_io_v4));
io_hdr[k].guard = 'Q';
/* io_hdr[k].iovec_count = 0; */ /* memset takes care of this */
if (0 == (k % 3)) {
io_hdr[k].request_len = sizeof(sdiagCmdBlk);
io_hdr[k].request = (uint64_t)(long)sdiagCmdBlk;
} else {
io_hdr[k].request_len = sizeof(inqCmdBlk);
io_hdr[k].request = (uint64_t)(long)inqCmdBlk;
io_hdr[k].din_xfer_len = INQ_REPLY_LEN;
io_hdr[k].din_xferp = (uint64_t)(long)inqBuff[k];
}
io_hdr[k].response = (uint64_t)(long)sense_buffer[k];
io_hdr[k].max_response_len = SENSE_BUFFER_LEN;
io_hdr[k].timeout = 20000; /* 20000 millisecs == 20 seconds */
io_hdr[k].usr_ptr = k;
/* default is to queue at head (in SCSI mid level) */
if (q_at_tail)
io_hdr[k].flags |= BSG_FLAG_Q_AT_TAIL;
else
io_hdr[k].flags |= BSG_FLAG_Q_AT_HEAD;
if (write(bsg_fd, &io_hdr[k], sizeof(struct sg_io_v4)) < 0) {
perror("bsg_queue_tst: bsg write error");
close(bsg_fd);
return 1;
}
}
/* sleep(3); */
for (k = 0; k < 16; ++k) {
memset(&rio_hdr, 0, sizeof(struct sg_io_v4));
rio_hdr.guard = 'Q';
if (read(bsg_fd, &rio_hdr, sizeof(struct sg_io_v4)) < 0) {
perror("bsg_queue_tst: bsg read error");
close(bsg_fd);
return 1;
}
/* now for the error processing */
ok = 0;
if (0 == rio_hdr.device_status)
ok = 1;
else {
switch (sg_err_category_sense((unsigned char *)(long)
rio_hdr.response, rio_hdr.response_len)) {
case SG_LIB_CAT_CLEAN:
ok = 1;
break;
case SG_LIB_CAT_RECOVERED:
printf("Recovered error, continuing\n");
ok = 1;
break;
default: /* won't bother decoding other categories */
fprintf(stderr, "command error:\n");
sg_print_sense(NULL, (unsigned char *)(long)rio_hdr.response,
rio_hdr.response_len, 1);
break;
}
}
if (ok) { /* output result if it is available */
/* if (0 == rio_hdr.pack_id) */
if (0 == (rio_hdr.usr_ptr % 3))
printf("SEND DIAGNOSTIC %d duration=%u\n",
(int)rio_hdr.usr_ptr, rio_hdr.duration);
else
printf("INQUIRY %d duration=%u\n", (int)rio_hdr.usr_ptr,
rio_hdr.duration);
}
}
close(bsg_fd);
return 0;
}
static int
do_identify_dev(int sg_fd, bool do_packet, int cdb_len, bool ck_cond,
bool extend, bool do_ident, int do_hex, bool do_raw,
int verbose)
{
bool t_type = false;/* false -> 512 byte blocks,
true -> device's LB size */
bool t_dir = true; /* false -> to device, true -> from device */
bool byte_block = true; /* false -> bytes, true -> 512 byte blocks (if
t_type=false) */
bool got_ard = false; /* got ATA result descriptor */
bool got_fixsense = false; /* got ATA result in fixed format sense */
bool ok;
int j, res, ret, sb_sz;
/* Following for ATA READ/WRITE MULTIPLE (EXT) cmds, normally 0 */
int multiple_count = 0;
int protocol = 4; /* PIO data-in */
int t_length = 2; /* 0 -> no data transferred, 2 -> sector count */
int resid = 0;
uint64_t ull;
struct sg_scsi_sense_hdr ssh;
uint8_t inBuff[ID_RESPONSE_LEN];
uint8_t sense_buffer[64];
uint8_t ata_return_desc[16];
uint8_t apt_cdb[SAT_ATA_PASS_THROUGH16_LEN] =
{SAT_ATA_PASS_THROUGH16, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0};
uint8_t apt12_cdb[SAT_ATA_PASS_THROUGH12_LEN] =
{SAT_ATA_PASS_THROUGH12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0};
uint8_t apt32_cdb[SAT_ATA_PASS_THROUGH32_LEN];
const unsigned short * usp;
sb_sz = sizeof(sense_buffer);
memset(sense_buffer, 0, sb_sz);
memset(apt32_cdb, 0, sizeof(apt32_cdb));
memset(ata_return_desc, 0, sizeof(ata_return_desc));
ok = false;
switch (cdb_len) {
case SAT_ATA_PASS_THROUGH32_LEN: /* SAT-4 revision 5 or later */
/* Prepare SCSI ATA PASS-THROUGH COMMAND(32) command */
sg_put_unaligned_be16(1, apt32_cdb + 22); /* count=1 */
apt32_cdb[25] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
ATA_IDENTIFY_DEVICE);
apt32_cdb[10] = (multiple_count << 5) | (protocol << 1);
if (extend)
apt32_cdb[10] |= 0x1;
apt32_cdb[11] = t_length;
if (ck_cond)
apt32_cdb[11] |= 0x20;
if (t_type)
apt32_cdb[11] |= 0x10;
if (t_dir)
apt32_cdb[11] |= 0x8;
if (byte_block)
apt32_cdb[11] |= 0x4;
/* following call takes care of all bytes below offset 10 in cdb */
res = sg_ll_ata_pt(sg_fd, apt32_cdb, cdb_len, DEF_TIMEOUT, inBuff,
NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
sb_sz, ata_return_desc,
sizeof(ata_return_desc), &resid, verbose);
break;
case SAT_ATA_PASS_THROUGH16_LEN:
/* Prepare SCSI ATA PASS-THROUGH COMMAND(16) command */
apt_cdb[6] = 1; /* sector count */
apt_cdb[14] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
ATA_IDENTIFY_DEVICE);
apt_cdb[1] = (multiple_count << 5) | (protocol << 1);
if (extend)
apt_cdb[1] |= 0x1;
apt_cdb[2] = t_length;
if (ck_cond)
apt_cdb[2] |= 0x20;
if (t_type)
apt_cdb[2] |= 0x10;
if (t_dir)
apt_cdb[2] |= 0x8;
if (byte_block)
apt_cdb[2] |= 0x4;
res = sg_ll_ata_pt(sg_fd, apt_cdb, cdb_len, DEF_TIMEOUT, inBuff,
NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
sb_sz, ata_return_desc,
sizeof(ata_return_desc), &resid, verbose);
break;
case SAT_ATA_PASS_THROUGH12_LEN:
/* Prepare SCSI ATA PASS-THROUGH COMMAND(12) command */
apt12_cdb[4] = 1; /* sector count */
apt12_cdb[9] = (do_packet ? ATA_IDENTIFY_PACKET_DEVICE :
ATA_IDENTIFY_DEVICE);
apt12_cdb[1] = (multiple_count << 5) | (protocol << 1);
apt12_cdb[2] = t_length;
if (ck_cond)
apt12_cdb[2] |= 0x20;
if (t_type)
apt12_cdb[2] |= 0x10;
if (t_dir)
apt12_cdb[2] |= 0x8;
if (byte_block)
apt12_cdb[2] |= 0x4;
res = sg_ll_ata_pt(sg_fd, apt12_cdb, cdb_len, DEF_TIMEOUT, inBuff,
NULL /* doutp */, ID_RESPONSE_LEN, sense_buffer,
sb_sz, ata_return_desc,
sizeof(ata_return_desc), &resid, verbose);
break;
default:
pr2serr("%s: bad cdb_len=%d\n", __func__, cdb_len);
return -1;
}
if (0 == res) {
ok = true;
if (verbose > 2)
pr2serr("command completed with SCSI GOOD status\n");
} else if ((res > 0) && (res & SAM_STAT_CHECK_CONDITION)) {
if (verbose > 1) {
pr2serr("ATA pass-through:\n");
sg_print_sense(NULL, sense_buffer, sb_sz,
((verbose > 2) ? 1 : 0));
}
if (sg_scsi_normalize_sense(sense_buffer, sb_sz, &ssh)) {
switch (ssh.sense_key) {
case SPC_SK_ILLEGAL_REQUEST:
if ((0x20 == ssh.asc) && (0x0 == ssh.ascq)) {
ret = SG_LIB_CAT_INVALID_OP;
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d) not supported\n",
cdb_len);
} else {
ret = SG_LIB_CAT_ILLEGAL_REQ;
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), bad field in cdb\n",
cdb_len);
}
return ret;
case SPC_SK_NO_SENSE:
case SPC_SK_RECOVERED_ERROR:
if ((0x0 == ssh.asc) &&
(ASCQ_ATA_PT_INFO_AVAILABLE == ssh.ascq)) {
if (0x72 == ssh.response_code) {
if (SAT_ATA_RETURN_DESC != ata_return_desc[0]) {
if (verbose)
pr2serr("did not find ATA Return (sense) "
"Descriptor\n");
return SG_LIB_CAT_RECOVERED;
}
got_ard = true;
break;
} else if (0x70 == ssh.response_code) {
got_fixsense = true;
break;
} else {
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), unexpected "
"response_code=0x%x\n", ssh.response_code,
cdb_len);
return SG_LIB_CAT_RECOVERED;
}
} else if (SPC_SK_RECOVERED_ERROR == ssh.sense_key)
return SG_LIB_CAT_RECOVERED;
else {
if ((0x0 == ssh.asc) && (0x0 == ssh.ascq))
break;
return SG_LIB_CAT_SENSE;
}
case SPC_SK_UNIT_ATTENTION:
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), Unit Attention detected\n",
cdb_len);
return SG_LIB_CAT_UNIT_ATTENTION;
case SPC_SK_NOT_READY:
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), device not ready\n",
cdb_len);
return SG_LIB_CAT_NOT_READY;
case SPC_SK_MEDIUM_ERROR:
case SPC_SK_HARDWARE_ERROR:
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), medium or hardware "
"error\n", cdb_len);
return SG_LIB_CAT_MEDIUM_HARD;
case SPC_SK_ABORTED_COMMAND:
if (0x10 == ssh.asc) {
pr2serr("Aborted command: protection information\n");
return SG_LIB_CAT_PROTECTION;
} else {
pr2serr("Aborted command: try again with%s '-p' option\n",
(do_packet ? "out" : ""));
return SG_LIB_CAT_ABORTED_COMMAND;
}
case SPC_SK_DATA_PROTECT:
pr2serr("ATA PASS-THROUGH (%d): data protect, read only "
"media?\n", cdb_len);
return SG_LIB_CAT_DATA_PROTECT;
default:
if (verbose < 2)
pr2serr("ATA PASS-THROUGH (%d), some sense data, use "
"'-v' for more information\n", cdb_len);
return SG_LIB_CAT_SENSE;
}
} else {
pr2serr("CHECK CONDITION without response code ??\n");
return SG_LIB_CAT_SENSE;
}
if (0x72 != (sense_buffer[0] & 0x7f)) {
pr2serr("expected descriptor sense format, response code=0x%x\n",
sense_buffer[0]);
return SG_LIB_CAT_MALFORMED;
}
} else if (res > 0) {
if (SAM_STAT_RESERVATION_CONFLICT == res) {
pr2serr("SCSI status: RESERVATION CONFLICT\n");
return SG_LIB_CAT_RES_CONFLICT;
} else {
pr2serr("Unexpected SCSI status=0x%x\n", res);
return SG_LIB_CAT_MALFORMED;
}
} else {
pr2serr("ATA pass-through (%d) failed\n", cdb_len);
if (verbose < 2)
pr2serr(" try adding '-v' for more information\n");
return -1;
}
if ((SAT_ATA_RETURN_DESC == ata_return_desc[0]) && (! got_ard))
pr2serr("Seem to have got ATA Result Descriptor but it was not "
"indicated\n");
if (got_ard) {
if (ata_return_desc[3] & 0x4) {
pr2serr("error indication in returned FIS: aborted command\n");
pr2serr(" try again with%s '-p' option\n",
(do_packet ? "out" : ""));
return SG_LIB_CAT_ABORTED_COMMAND;
}
ok = true;
}
if (got_fixsense) {
if (0x4 & sense_buffer[3]) { /* Error is MSB of Info field */
pr2serr("error indication in returned FIS: aborted command\n");
pr2serr(" try again with%s '-p' option\n",
(do_packet ? "out" : ""));
return SG_LIB_CAT_ABORTED_COMMAND;
}
ok = true;
}
if (ok) { /* output result if it is available */
if (do_raw)
dStrRaw(inBuff, 512);
else if (0 == do_hex) {
if (do_ident) {
usp = (const unsigned short *)inBuff;
ull = 0;
for (j = 0; j < 4; ++j) {
if (j > 0)
ull <<= 16;
ull |= usp[108 + j];
}
printf("0x%016" PRIx64 "\n", ull);
} else {
printf("Response for IDENTIFY %sDEVICE ATA command:\n",
(do_packet ? "PACKET " : ""));
dWordHex((const unsigned short *)inBuff, 256, 0,
sg_is_big_endian());
}
} else if (1 == do_hex)
hex2stdout(inBuff, 512, 0);
else if (2 == do_hex)
dWordHex((const unsigned short *)inBuff, 256, 0,
sg_is_big_endian());
else if (3 == do_hex) /* '-HHH' suitable for "hdparm --Istdin" */
dWordHex((const unsigned short *)inBuff, 256, -2,
sg_is_big_endian());
else /* '-HHHH' hex bytes only */
hex2stdout(inBuff, 512, -1);
}
return 0;
}
int main(int argc, char * argv[])
{
int c, n, len;
int verbose = 0;
int ret = 1;
char b[2048];
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "hvV", long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'h':
case '?':
usage();
return 0;
case 'v':
++verbose;
break;
case 'V':
fprintf(stderr, "version: %s\n", version_str);
return 0;
default:
fprintf(stderr, "unrecognised switch code 0x%x ??\n", c);
usage();
return 1;
}
}
if (optind < argc) {
if (optind < argc) {
for (; optind < argc; ++optind)
fprintf(stderr, "Unexpected extra argument: %s\n",
argv[optind]);
usage();
return 1;
}
}
printf("Testing my_snprintf():\n");
sg_print_sense("desc_sense_data test", desc_sense_data, (int)sizeof(desc_sense_data), 1);
printf("\n");
#if 1
sg_get_sense_str("sg_get_sense_str", desc_sense_data, sizeof(desc_sense_data), 1, sizeof(b), b);
printf("sg_get_sense_str: strlen(b)->%zd\n", strlen(b));
printf("%s", b);
printf("\n");
#endif
b[0] = '\0';
len = sizeof(b);
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = -1;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 0;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 1;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 2;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 3;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 4;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 5;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 6;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
b[0] = '\0';
len = 7;
n = my_snprintf(b, len, "%s", "test");
printf("my_snprintf(,%d,,\"test\") -> %d; strlen(b) -> %zd\n",
len, n, strlen(b));
if (strlen(b) > 0)
printf("Resulting string: %s\n", b);
return ret;
}
int main(/* int argc, char * argv[] */)
{
unsigned char err1[] = {0x72, 0x5, 0x4, 0x1, 0, 0, 0, 32,
0x2, 0x6, 0, 0, 0xc8, 0x0, 0x3, 0,
0, 0xa, 0x80, 0, 1, 2, 3, 4,
0xaa, 0xbb, 0xcc, 0xdd,
1, 0xa, 0, 0, 1, 2, 3, 4,
0xaa, 0xbb, 0xee, 0xff};
unsigned char err2[] = {0x72, SPC_SK_MEDIUM_ERROR, 0x4, 0x1, 0x80, 0, 0,
32,
0x2, 0x6, 0, 0, 0xc8, 0x0, 0x3, 0,
0, 0xa, 0x80, 0, 1, 2, 3, 4,
0xaa, 0xbb, 0xcc, 0xdd,
1, 0xa, 0, 0, 1, 2, 3, 4,
0xaa, 0xbb, 0xee, 0xff};
/* Set SDAT_OVFL */
unsigned char err3[] = {0x72, SPC_SK_NO_SENSE, 0x4, 0x1, 0, 0, 0, 8,
0x2, 0x6, 0, 0, 0xc8, 0x0, 0x3, 0};
unsigned char err4[] = {0x73, SPC_SK_COPY_ABORTED, 0x4, 0x1, 0, 0, 0, 22,
0x2, 0x6, 0, 0, 0xc8, 0x0, 0x3, 0,
0x3, 0x2, 0, 0x55,
0x5, 0x2, 0, 0x20,
0x85, 0x4, 0, 0x20, 0x33, 0x44};
/* Set Filemark, EOM, ILI and SDAT_OVFL */
unsigned char err5[] = {0xf1, 0, (0xf0 | SPC_SK_ILLEGAL_REQUEST), 0x11,
0x22, 0x33, 0x44, 0xa,
0x0, 0x0, 0, 0, 0x4, 0x1, 0, 0xcf, 0, 5,};
unsigned char err6[] = {0x72, SPC_SK_NO_SENSE, 0x4, 0x1, 0, 0, 0, 14,
0x9, 0xc, 1, 0, 0x11, 0x22, 0x66, 0x33,
0x77, 0x44, 0x88, 0x55, 0x1, 0x2};
unsigned char err7[] = {0xf1, 0, 0xe5, 0x11, 0x22, 0x33, 0x44, 0xa,
0x0, 0x0, 0x0, 0x0, 0x24, 0x1, 0xbb,
0xc9, 0x0, 0x2};
char leadin[128];
char b[2048];
int k, prev_len;
sg_print_sense("err1 test", err1, sizeof(err1), 1 /* raw_info */);
sg_print_sense("\nerr2 test", err2, sizeof(err2), 1);
sg_print_sense("\nerr3 test", err3, sizeof(err3), 1);
sg_print_sense("\nerr4 test", err4, sizeof(err4), 1);
sg_print_sense("\nerr5 test", err5, sizeof(err5), 1);
sg_print_sense("\nerr6 test", err6, sizeof(err6), 1);
sg_print_sense("\nerr7 test", err7, sizeof(err7), 1);
printf("\n\nTry different output string sizes with "
"sg_get_sense_str(err2):\n");
for (k = 1, prev_len = -1; k < 512; ++k) {
snprintf(leadin, sizeof(leadin), "blen=%d", k);
sg_get_sense_str(leadin, err2, sizeof(err2), 0, k, b);
printf("%s\n", b);
if (prev_len == (int)strlen(b))
break;
else
prev_len = strlen(b);
}
printf("\n\nTry different output string sizes with "
"sg_get_sense_str(err4):\n");
for (k = 1, prev_len = -1; k < 512; ++k) {
snprintf(leadin, sizeof(leadin), "blen=%d", k);
sg_get_sense_str(leadin, err4, sizeof(err4), 0, k, b);
printf("%s\n", b);
if (prev_len == (int)strlen(b))
break;
else
prev_len = strlen(b);
}
return 0;
}
int
main(int argc, char *argv[])
{
int ret = 0;
int res_cat, status, slen, k, ret2;
int sg_fd = -1;
struct sg_pt_base *ptvp = NULL;
unsigned char sense_buffer[32];
unsigned char * dxfer_buffer_in = NULL;
unsigned char * dxfer_buffer_out = NULL;
unsigned char *wrkBuf = NULL;
struct opts_t opts;
struct opts_t * op;
char b[128];
op = &opts;
memset(op, 0, sizeof(opts));
op->timeout = DEFAULT_TIMEOUT;
ret = process_cl(op, argc, argv);
if (ret != 0) {
usage();
goto done;
} else if (op->do_help) {
usage();
goto done;
} else if (op->do_version) {
version();
goto done;
}
sg_fd = scsi_pt_open_device(op->device_name, op->readonly,
op->do_verbose);
if (sg_fd < 0) {
fprintf(stderr, "%s: %s\n", op->device_name, safe_strerror(-sg_fd));
ret = SG_LIB_FILE_ERROR;
goto done;
}
ptvp = construct_scsi_pt_obj();
if (ptvp == NULL) {
fprintf(stderr, "out of memory\n");
ret = SG_LIB_CAT_OTHER;
goto done;
}
if (op->do_verbose) {
fprintf(stderr, " cdb to send: ");
for (k = 0; k < op->cdb_length; ++k)
fprintf(stderr, "%02x ", op->cdb[k]);
fprintf(stderr, "\n");
if (op->do_verbose > 2) {
sg_get_command_name(op->cdb, 0, sizeof(b) - 1, b);
b[sizeof(b) - 1] = '\0';
fprintf(stderr, " Command name: %s\n", b);
}
}
set_scsi_pt_cdb(ptvp, op->cdb, op->cdb_length);
set_scsi_pt_sense(ptvp, sense_buffer, sizeof(sense_buffer));
if (op->do_dataout) {
dxfer_buffer_out = fetch_dataout(op);
if (dxfer_buffer_out == NULL) {
ret = SG_LIB_CAT_OTHER;
goto done;
}
set_scsi_pt_data_out(ptvp, dxfer_buffer_out, op->dataout_len);
}
if (op->do_datain) {
dxfer_buffer_in = my_memalign(op->datain_len, &wrkBuf);
if (dxfer_buffer_in == NULL) {
perror("malloc");
ret = SG_LIB_CAT_OTHER;
goto done;
}
set_scsi_pt_data_in(ptvp, dxfer_buffer_in, op->datain_len);
}
ret = do_scsi_pt(ptvp, sg_fd, op->timeout, op->do_verbose);
if (ret > 0) {
if (SCSI_PT_DO_BAD_PARAMS == ret) {
fprintf(stderr, "do_scsi_pt: bad pass through setup\n");
ret = SG_LIB_CAT_OTHER;
} else if (SCSI_PT_DO_TIMEOUT == ret) {
fprintf(stderr, "do_scsi_pt: timeout\n");
ret = SG_LIB_CAT_TIMEOUT;
} else
ret = SG_LIB_CAT_OTHER;
goto done;
} else if (ret < 0) {
fprintf(stderr, "do_scsi_pt: %s\n", safe_strerror(-ret));
ret = SG_LIB_CAT_OTHER;
goto done;
}
slen = 0;
res_cat = get_scsi_pt_result_category(ptvp);
switch (res_cat) {
case SCSI_PT_RESULT_GOOD:
ret = 0;
break;
case SCSI_PT_RESULT_SENSE:
slen = get_scsi_pt_sense_len(ptvp);
ret = sg_err_category_sense(sense_buffer, slen);
break;
case SCSI_PT_RESULT_TRANSPORT_ERR:
get_scsi_pt_transport_err_str(ptvp, sizeof(b), b);
fprintf(stderr, ">>> transport error: %s\n", b);
ret = SG_LIB_CAT_OTHER;
break;
case SCSI_PT_RESULT_OS_ERR:
get_scsi_pt_os_err_str(ptvp, sizeof(b), b);
fprintf(stderr, ">>> os error: %s\n", b);
ret = SG_LIB_CAT_OTHER;
break;
default:
fprintf(stderr, ">>> unknown pass through result category (%d)\n",
res_cat);
ret = SG_LIB_CAT_OTHER;
break;
}
status = get_scsi_pt_status_response(ptvp);
fprintf(stderr, "SCSI Status: ");
sg_print_scsi_status(status);
fprintf(stderr, "\n\n");
if ((SAM_STAT_CHECK_CONDITION == status) && (! op->no_sense)) {
if (SCSI_PT_RESULT_SENSE != res_cat)
slen = get_scsi_pt_sense_len(ptvp);
if (0 == slen)
fprintf(stderr, ">>> Strange: status is CHECK CONDITION but no "
"Sense Information\n");
else {
fprintf(stderr, "Sense Information:\n");
sg_print_sense(NULL, sense_buffer, slen, (op->do_verbose > 0));
fprintf(stderr, "\n");
}
}
if (SAM_STAT_RESERVATION_CONFLICT == status)
ret = SG_LIB_CAT_RES_CONFLICT;
if (op->do_datain) {
int data_len = op->datain_len - get_scsi_pt_resid(ptvp);
if (ret && !(SG_LIB_CAT_RECOVERED == ret ||
SG_LIB_CAT_NO_SENSE == ret))
fprintf(stderr, "Error %d occurred, no data received\n", ret);
else if (data_len == 0) {
fprintf(stderr, "No data received\n");
} else {
if (op->datain_file == NULL && !op->datain_binary) {
fprintf(stderr, "Received %d bytes of data:\n", data_len);
dStrHexErr((const char *)dxfer_buffer_in, data_len, 0);
} else {
const char * cp = "stdout";
if (op->datain_file &&
! ((1 == strlen(op->datain_file)) &&
('-' == op->datain_file[0])))
cp = op->datain_file;
fprintf(stderr, "Writing %d bytes of data to %s\n", data_len,
cp);
ret2 = write_dataout(op->datain_file, dxfer_buffer_in,
data_len);
if (0 != ret2) {
if (0 == ret)
ret = ret2;
goto done;
}
}
}
}
done:
if (op->do_verbose) {
sg_get_category_sense_str(ret, sizeof(b), b, op->do_verbose - 1);
fprintf(stderr, "%s\n", b);
}
if (wrkBuf)
free(wrkBuf);
if (ptvp)
destruct_scsi_pt_obj(ptvp);
if (sg_fd >= 0)
scsi_pt_close_device(sg_fd);
return ret;
}
