github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-06 21:58:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

Merge patch series "Use defined 16-bits ASC/ASCQ combinations"

Browse Source 
Damien Le Moal <dlemoal@kernel.org> says:

This patch series defines as macros all ASC/ASCQ combinations present in
https://www.t10.org/lists/asc-num.txt and converts the SCSI core code and
SCSI low level drivers to use these macros instead of hard-coded
ASC/ASCQs. To do this, struct scsi_sense_hdr and struct scsi_failure are
modified to replace the asc and ascq 8-bits fields with a 16-bits
sense_code field.

This cleans up the code in many places and makes it easier, and self
documented, to test sense codes in the case of errors.

Overall, there should be no functional chnages here.

Note: this series currently applies cleanly only to the scsi-staging tree.
It does not apply to Linus tree as commit 6d81700ad7 ("ata: libata-scsi:
do not raise UA for storage element depopulation and restoration") creates
a conflict with patch 37. The conflict is trivial to resolve, but this
will create a conflict in linux-next. Could you maybe rebase scsi-staging
on rc2 ?

Also please note that sashiko did comment about several pre-existing
issues for different drivers, but I am not addressing these issues in
this series.

[mkp: fixed ufs conflict]

Link: https://patch.msgid.link/20260908090308.1085097-1-dlemoal@kernel.org
Signed-off-by: Martin K. Petersen (Oracle) <mkp@kernel.org>
This commit is contained in:
Martin K. Petersen (Oracle) 2026-09-16 10:44:24 -04:00
commit 670f07403f
72 changed files with 3817 additions and 1995 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
drivers/ata/libata-eh.c
View File

@ -1516,11 +1516,13 @@ static bool ata_eh_request_sense(struct ata_queued_cmd *qc)
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
/* Ignore err_mask; ATA_ERR might be set */
if (tf.status & ATA_SENSE) {
if (ata_scsi_sense_is_valid(tf.lbah, tf.lbam, tf.lbal)) {
u16 sense_code = scsi_sense_code(tf.lbam, tf.lbal);
if (ata_scsi_sense_is_valid(tf.lbah, sense_code)) {
/* Set sense without also setting scsicmd->result */
scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
cmd->sense_buffer, tf.lbah,
tf.lbam, tf.lbal);
scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
cmd->sense_buffer, tf.lbah,
sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
return true;
}
@ -2094,7 +2096,8 @@ static void ata_eh_get_success_sense(struct ata_link *link)
continue;
/* This success command had sense data, but we failed to get. */
ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
ata_eh_done(link, dev, ATA_EH_GET_SUCCESS_SENSE);

20
drivers/ata/libata-sata.c
View File

@ -1588,7 +1588,7 @@ int ata_eh_get_ncq_success_sense(struct ata_link *link)
asc = sense[1];
ascq = sense[2];
if (!ata_scsi_sense_is_valid(sk, asc, ascq)) {
if (!ata_scsi_sense_is_valid(sk, scsi_sense_code(asc, ascq))) {
ret = -EIO;
continue;
}
@ -1605,9 +1605,9 @@ int ata_eh_get_ncq_success_sense(struct ata_link *link)
qc->result_tf.auxiliary = get_unaligned_le32(&sense[16]);
/* Set sense without also setting scsicmd->result */
scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
qc->scsicmd->sense_buffer, sk,
asc, ascq);
scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
qc->scsicmd->sense_buffer, sk,
scsi_sense_code(asc, ascq));
qc->flags |= ATA_QCFLAG_SENSE_VALID;
/*
@ -1684,14 +1684,14 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
* stored the sense data in qc->result_tf.auxiliary.
*/
if (qc->result_tf.auxiliary) {
char sense_key, asc, ascq;
u16 sense_code;
u8 sense_key;
sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
asc = (qc->result_tf.auxiliary >> 8) & 0xff;
ascq = qc->result_tf.auxiliary & 0xff;
if (ata_scsi_sense_is_valid(sense_key, asc, ascq)) {
ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc,
ascq);
sense_code = qc->result_tf.auxiliary & 0xffff;
if (ata_scsi_sense_is_valid(sense_key, sense_code)) {
ata_scsi_set_sense(dev, qc->scsicmd, sense_key,
sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
}

346
drivers/ata/libata-scsi.c
View File

@ -190,28 +190,25 @@ DEVICE_ATTR(unload_heads, S_IRUGO | S_IWUSR,
ata_scsi_park_show, ata_scsi_park_store);
EXPORT_SYMBOL_GPL(dev_attr_unload_heads);
bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq)
bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code)
{
/*
* If sk == NO_SENSE, and asc + ascq == NO ADDITIONAL SENSE INFORMATION,
* then there is no sense data to add.
*/
if (sk == 0 && asc == 0 && ascq == 0)
if (sense_key == NO_SENSE &&
sense_code == NO_ADDITIONAL_SENSE_INFORMATION)
return false;
/* If sk > COMPLETED, sense data is bogus. */
if (sk > COMPLETED)
if (sense_key > COMPLETED)
return false;
return true;
}
void ata_scsi_set_sense(struct ata_device *dev, struct scsi_cmnd *cmd,
u8 sk, u8 asc, u8 ascq)
u8 sk, u16 code)
{
bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE);
scsi_build_sense(cmd, d_sense, sk, asc, ascq);
scsi_set_sense(cmd, d_sense, sk, code);
}
static void ata_scsi_set_sense_information(struct ata_queued_cmd *qc)
@ -316,8 +313,7 @@ static void ata_scsi_set_passthru_sense_fields(struct ata_queued_cmd *qc)
static void ata_scsi_set_invalid_field(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field, u8 bit)
{
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x24, 0x0);
/* "Invalid field in CDB" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, bit, 1);
}
@ -325,8 +321,8 @@ static void ata_scsi_set_invalid_field(struct ata_device *dev,
static void ata_scsi_set_invalid_parameter(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field)
{
/* "Invalid field in parameter list" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x26, 0x0);
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
INVALID_FIELD_IN_PARAMETER_LIST);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, 0xff, 0);
}
@ -525,7 +521,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (scsi_status_is_check_condition(cmd_result)) {
if (sshdr.sense_key == RECOVERED_ERROR &&
sshdr.asc == 0 && sshdr.ascq == 0x1d)
sshdr.sense_code ==
ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@ -613,7 +610,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) {
if (sshdr.sense_key == RECOVERED_ERROR &&
sshdr.asc == 0 && sshdr.ascq == 0x1d)
sshdr.sense_code ==
ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@ -792,79 +790,143 @@ static void ata_qc_set_pc_nbytes(struct ata_queued_cmd *qc)
qc->nbytes = scsi_bufflen(scmd) + qc->extrabytes;
}
struct ata_err_sense {
u8 err_mask;
u8 sense_key;
u16 sense_code;
};
/**
* ata_to_sense_error - convert ATA error to SCSI error
* @drv_stat: value contained in ATA status register
* @drv_err: value contained in ATA error register
* @sk: the sense key we'll fill out
* @asc: the additional sense code we'll fill out
* @ascq: the additional sense code qualifier we'll fill out
* @scode: the additional sense code and its qualifier we'll fill out
*
* Converts an ATA error into a SCSI error. Fill out pointers to
* SK, ASC, and ASCQ bytes for later use in fixed or descriptor
* the sense key and sense code for later use in fixed or descriptor
* format sense blocks.
*
* LOCKING:
* spin_lock_irqsave(host lock)
*/
static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
u8 *ascq)
static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u16 *scode)
{
int i;
/* Based on the 3ware driver translation table */
static const unsigned char sense_table[][4] = {
/* BBD|ECC|ID|MAR */
{0xd1, ABORTED_COMMAND, 0x00, 0x00},
// Device busy Aborted command
/* BBD|ECC|ID */
{0xd0, ABORTED_COMMAND, 0x00, 0x00},
// Device busy Aborted command
/* ECC|MC|MARK */
{0x61, HARDWARE_ERROR, 0x00, 0x00},
// Device fault Hardware error
/* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
{0x84, ABORTED_COMMAND, 0x47, 0x00},
// Data CRC error SCSI parity error
/* MC|ID|ABRT|TRK0|MARK */
{0x37, NOT_READY, 0x04, 0x00},
// Unit offline Not ready
/* MCR|MARK */
{0x09, NOT_READY, 0x04, 0x00},
// Unrecovered disk error Not ready
/* Bad address mark */
{0x01, MEDIUM_ERROR, 0x13, 0x00},
// Address mark not found for data field
/* TRK0 - Track 0 not found */
{0x02, HARDWARE_ERROR, 0x00, 0x00},
// Hardware error
/* Abort: 0x04 is not translated here, see below */
/* Media change request */
{0x08, NOT_READY, 0x04, 0x00},
// FIXME: faking offline
/* SRV/IDNF - ID not found */
{0x10, ILLEGAL_REQUEST, 0x21, 0x00},
// Logical address out of range
/* MC - Media Changed */
{0x20, UNIT_ATTENTION, 0x28, 0x00},
// Not ready to ready change, medium may have changed
/* ECC - Uncorrectable ECC error */
{0x40, MEDIUM_ERROR, 0x11, 0x04},
// Unrecovered read error
/* BBD - block marked bad */
{0x80, MEDIUM_ERROR, 0x11, 0x04},
// Block marked bad Medium error, unrecovered read error
{0xFF, 0xFF, 0xFF, 0xFF}, // END mark
static const struct ata_err_sense sense_table[] = {
{
/* BBD|ECC|ID|MAR - Device busy */
0xd1,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* BBD|ECC|ID - Device busy */
0xd0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* ECC|MC|MARK - Device fault */
0x61,
HARDWARE_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* ICRC|ABRT - Data CRC error */
/* NB: ICRC & !ABRT is BBD */
0x84,
ABORTED_COMMAND,
SCSI_PARITY_ERROR
},
{
/* MC|ID|ABRT|TRK0|MARK - Unit offline */
0x37,
NOT_READY,
LU_NOT_READY
},
{
/* MCR|MARK - Unrecovered disk error */
0x09,
NOT_READY,
LU_NOT_READY
},
{
/* Bad address mark */
0x01,
MEDIUM_ERROR,
ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD
},
{
/* TRK0 - Track 0 not found */
0x02,
HARDWARE_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* Abort: 0x04 is not translated here, see below */
/* Media change request */
0x08,
NOT_READY,
LU_NOT_READY
},
{
/* SRV/IDNF - ID not found */
0x10,
ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE
},
{
/* MC - Media Changed */
0x20,
UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED
},
{
/* ECC - Uncorrectable ECC error */
0x40,
MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
},
{
/* BBD - block marked bad */
0x80,
MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
},
{
/* END mark */
0xFF, 0xFF, 0xFFFF
},
};
static const unsigned char stat_table[][4] = {
/* Busy: must be first because BUSY means no other bits valid */
{ ATA_BUSY, ABORTED_COMMAND, 0x00, 0x00 },
/* Device fault: INTERNAL TARGET FAILURE */
{ ATA_DF, HARDWARE_ERROR, 0x44, 0x00 },
/* Corrected data error */
{ ATA_CORR, RECOVERED_ERROR, 0x00, 0x00 },
{ 0xFF, 0xFF, 0xFF, 0xFF }, /* END mark */
static const struct ata_err_sense stat_table[] = {
{
/*
* Busy: must be first because BUSY means no other bits
* valid.
*/
ATA_BUSY,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* Device fault */
ATA_DF,
HARDWARE_ERROR,
INTERNAL_TARGET_FAILURE
},
{
/* Corrected data error */
ATA_CORR,
RECOVERED_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* END mark */
0xFF, 0xFF, 0xFFFF
},
};
/*
@ -876,13 +938,12 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
if (drv_err) {
/* Look for drv_err */
for (i = 0; sense_table[i][0] != 0xFF; i++) {
for (i = 0; sense_table[i].err_mask != 0xFF; i++) {
/* Look for best matches first */
if ((sense_table[i][0] & drv_err) ==
sense_table[i][0]) {
*sk = sense_table[i][1];
*asc = sense_table[i][2];
*ascq = sense_table[i][3];
if ((sense_table[i].err_mask & drv_err) ==
sense_table[i].err_mask) {
*sk = sense_table[i].sense_key;
*scode = sense_table[i].sense_code;
return;
}
}
@ -893,11 +954,10 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* has only the ABRT bit set, we decode drv_stat. ABRT by itself
* is not descriptive enough.
*/
for (i = 0; stat_table[i][0] != 0xFF; i++) {
if (stat_table[i][0] & drv_stat) {
*sk = stat_table[i][1];
*asc = stat_table[i][2];
*ascq = stat_table[i][3];
for (i = 0; stat_table[i].err_mask != 0xFF; i++) {
if (stat_table[i].err_mask & drv_stat) {
*sk = stat_table[i].sense_key;
*scode = stat_table[i].sense_code;
return;
}
}
@ -907,8 +967,7 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* that won't cause people to do things like return a disk wrongly.
*/
*sk = ABORTED_COMMAND;
*asc = 0x00;
*ascq = 0x00;
*scode = NO_ADDITIONAL_SENSE_INFORMATION;
}
/*
@ -931,40 +990,41 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
u8 sense_key, asc, ascq;
u16 sense_code;
u8 sense_key;
if (!(qc->flags & ATA_QCFLAG_RTF_FILLED)) {
ata_dev_dbg(dev,
"missing result TF: can't generate ATA PT sense data\n");
if (qc->err_mask)
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
return;
}
/*
* Use ata_to_sense_error() to map status register bits
* onto sense key, asc & ascq.
* Use ata_to_sense_error() to map status register bits onto sense key
* and sense code.
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
ata_to_sense_error(tf->status, tf->error,
&sense_key, &asc, &ascq);
ata_scsi_set_sense(qc->dev, cmd, sense_key, asc, ascq);
} else {
/*
* ATA PASS-THROUGH INFORMATION AVAILABLE
*
* Note: we are supposed to call ata_scsi_set_sense(), which
* respects the D_SENSE bit, instead of unconditionally
* generating the sense data in descriptor format. However,
* because hdparm, hddtemp, and udisks incorrectly assume sense
* data in descriptor format, without even looking at the
* RESPONSE CODE field in the returned sense data (to see which
* format the returned sense data is in), we are stuck with
* being bug compatible with older kernels.
*/
scsi_build_sense(cmd, 1, RECOVERED_ERROR, 0, 0x1D);
&sense_key, &sense_code);
ata_scsi_set_sense(qc->dev, cmd, sense_key, sense_code);
return;
}
/*
* Note: we are supposed to call ata_scsi_set_sense(), which respects
* the D_SENSE bit, instead of unconditionally generating the sense data
* in descriptor format. However, because hdparm, hddtemp, and udisks
* incorrectly assume sense data in descriptor format, without even
* looking at the RESPONSE CODE field in the returned sense data (to see
* which format the returned sense data is in), we are stuck with being
* bug compatible with older kernels.
*/
scsi_set_sense(cmd, 1, RECOVERED_ERROR,
ATA_PASS_THROUGH_INFORMATION_AVAILABLE);
}
/**
@ -981,19 +1041,18 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
u8 sense_key, asc, ascq;
if (ata_dev_disabled(dev)) {
/* Device disabled after error recovery */
/* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */
ata_scsi_set_sense(dev, cmd, NOT_READY, 0x04, 0x21);
ata_scsi_set_sense(dev, cmd, NOT_READY,
LU_NOT_READY_HARD_RESET_REQUIRED);
return;
}
if (ata_id_is_locked(dev->id)) {
/* Security locked */
/* LOGICAL UNIT ACCESS NOT AUTHORIZED */
ata_scsi_set_sense(dev, cmd, DATA_PROTECT, 0x74, 0x71);
ata_scsi_set_sense(dev, cmd, DATA_PROTECT,
LU_ACCESS_NOT_AUTHORIZED);
return;
}
@ -1008,9 +1067,12 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
u16 sense_code;
u8 sense_key;
ata_to_sense_error(tf->status, tf->error,
&sense_key, &asc, &ascq);
ata_scsi_set_sense(dev, cmd, sense_key, asc, ascq);
&sense_key, &sense_code);
ata_scsi_set_sense(dev, cmd, sense_key, sense_code);
return;
}
@ -1019,7 +1081,8 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
"Could not decode error 0x%x, status 0x%x (err_mask=0x%x)\n",
tf->error, tf->status, qc->err_mask);
aborted:
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
void ata_scsi_sdev_config(struct scsi_device *sdev)
@ -1273,7 +1336,8 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
/* Ignore IMMED bit (cdb[1] & 0x1), violates sat-r05 */
if (!ata_dev_power_init_tf(qc->dev, &qc->tf, cdb[4] & 0x1)) {
ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
return 1;
}
@ -1501,8 +1565,8 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
/* "Logical Block Address out of range" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@ -1638,8 +1702,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
/* "Logical Block Address out of range" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@ -2015,7 +2079,8 @@ static void ata_scsi_rbuf_fill(struct ata_device *dev, struct scsi_cmnd *cmd,
len = actor(dev, cmd, ata_scsi_rbuf);
if (len) {
if (WARN_ON(len > ATA_SCSI_RBUF_SIZE)) {
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
spin_unlock_irqrestore(&ata_scsi_rbuf_lock, flags);
return;
}
@ -2894,8 +2959,8 @@ static unsigned int ata_scsiop_mode_sense(struct ata_device *dev,
return 0;
saving_not_supp:
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x39, 0x0);
/* "Saving parameters not supported" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
SAVING_PARAMETERS_NOT_SUPPORTED);
return 0;
}
@ -3732,12 +3797,12 @@ static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(dev, scmd, fp, bp);
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
invalid_opcode:
/* "Invalid command operation code" */
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4199,8 +4264,8 @@ static unsigned int ata_scsi_zbc_in_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@ -4277,8 +4342,8 @@ static unsigned int ata_scsi_zbc_out_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@ -4629,8 +4694,8 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
skip:
@ -4789,7 +4854,8 @@ ata_scsi_get_phys_element_status_xlat(struct ata_queued_cmd *qc)
/* ATA_CMD_GET_PHYS_ELEMENT_STATUS is a DMA command. */
if (!(dev->flags & ATA_DFLAG_DEPOP) || !ata_dma_enabled(dev)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4841,7 +4907,7 @@ static void ata_scsi_depop_ua_cap_changed_complete(struct ata_queued_cmd *qc)
*/
if (is_success && !is_ata_passthru)
ata_scsi_set_sense(qc->dev, scmd, UNIT_ATTENTION,
UA_CHANGED_ASC, CAPACITY_CHANGED_ASCQ);
CAPACITY_DATA_HAS_CHANGED);
ata_scsi_qc_complete(qc);
}
@ -4856,7 +4922,8 @@ ata_scsi_remove_element_and_truncate_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4899,7 +4966,8 @@ ata_scsi_remove_element_and_modify_zones_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP_MODIFY)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4927,7 +4995,8 @@ ata_scsi_restore_elements_and_rebuild_xlat(struct ata_queued_cmd *qc)
struct ata_taskfile *tf = &qc->tf;
if (!(dev->flags & ATA_DFLAG_DEPOP_RESTORE)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -5088,7 +5157,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
break;
case REQUEST_SENSE:
ata_scsi_set_sense(dev, cmd, 0, 0, 0);
ata_scsi_set_sense(dev, cmd, NO_SENSE,
NO_ADDITIONAL_SENSE_INFORMATION);
break;
/* if we reach this, then writeback caching is disabled,
@ -5117,8 +5187,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
/* all other commands */
default:
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x20, 0x0);
/* "Invalid command operation code" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
break;
}

5
drivers/ata/libata.h
View File

@ -164,9 +164,10 @@ extern int ata_scsi_add_hosts(struct ata_host *host,
const struct scsi_host_template *sht);
extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
extern bool ata_scsi_offline_dev(struct ata_device *dev);
extern bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq);
extern bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code);
extern void ata_scsi_set_sense(struct ata_device *dev,
struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq);
struct scsi_cmnd *cmd, u8 sense_key,
u16 sense_code);
extern void ata_scsi_media_change_notify(struct ata_device *dev);
extern void ata_scsi_hotplug(struct work_struct *work);
extern void ata_scsi_dev_rescan(struct work_struct *work);

10
drivers/cdrom/cdrom.c
View File

@ -345,9 +345,8 @@ int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
struct packet_command *cgc)
{
if (cgc->sshdr) {
cgc->sshdr->sense_key = 0x05;
cgc->sshdr->asc = 0x20;
cgc->sshdr->ascq = 0x00;
cgc->sshdr->sense_key = ILLEGAL_REQUEST;
cgc->sshdr->sense_code = INVALID_COMMAND_OP_CODE;
}
cgc->stat = -EIO;
@ -2979,9 +2978,8 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
cgc->sshdr = &sshdr;
cgc->data_direction = CGC_DATA_READ;
ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
if (ret && sshdr.sense_key == 0x05 &&
sshdr.asc == 0x20 &&
sshdr.ascq == 0x00) {
if (ret && sshdr.sense_key == ILLEGAL_REQUEST &&
sshdr.sense_code == INVALID_COMMAND_OP_CODE) {
/*
* SCSI-II devices are not required to support
* READ_CD, so let's try switching block size

2
drivers/s390/scsi/zfcp_ext.h
View File

@ -176,7 +176,7 @@ extern void zfcp_scsi_schedule_rport_register(struct zfcp_port *);
extern void zfcp_scsi_schedule_rport_block(struct zfcp_port *);
extern void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *);
extern void zfcp_scsi_set_prot(struct zfcp_adapter *);
extern void zfcp_scsi_dif_sense_error(struct scsi_cmnd *, int);
extern void zfcp_scsi_dif_sense_error(struct scsi_cmnd *, u16);
extern void zfcp_scsi_shost_update_config_data(
struct zfcp_adapter *const adapter,
const struct fsf_qtcb_bottom_config *const bottom,

9
drivers/s390/scsi/zfcp_fsf.c
View File

@ -2485,13 +2485,16 @@ static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
set_host_byte(scpnt, DID_ERROR);
goto skip_fsfstatus;
case FSF_BLOCK_GUARD_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x1);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
goto skip_fsfstatus;
case FSF_APP_TAG_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x2);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
goto skip_fsfstatus;
case FSF_REF_TAG_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x3);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
goto skip_fsfstatus;
}
BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext) > FSF_FCP_RSP_SIZE);

6
drivers/s390/scsi/zfcp_scsi.c
View File

@ -849,14 +849,14 @@ void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
/**
* zfcp_scsi_dif_sense_error - Report DIF/DIX error as driver sense error
* @scmd: The SCSI command to report the error for
* @ascq: The ASCQ to put in the sense buffer
* @sense_code: The combined ASC and ASCQ to put in the sense buffer
*
* See the error handling in sd_done for the sense codes used here.
* Set DID_SOFT_ERROR to retry the request, if possible.
*/
void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, int ascq)
void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, u16 sense_code)
{
scsi_build_sense(scmd, 1, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(scmd, 1, ILLEGAL_REQUEST, sense_code);
set_host_byte(scmd, DID_SOFT_ERROR);
}

3
drivers/scsi/3w-xxxx.c
View File

@ -1977,7 +1977,8 @@ static enum scsi_qc_status tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
tw_dev->state[request_id] = TW_S_COMPLETED;
tw_state_request_finish(tw_dev, request_id);
scsi_build_sense(SCpnt, 1, ILLEGAL_REQUEST, 0x20, 0);
scsi_set_sense(SCpnt, 1, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
done(SCpnt);
retval = 0;
}

55
drivers/scsi/ch.c
View File

@ -123,38 +123,32 @@ static DEFINE_IDR(ch_index_idr);
static DEFINE_SPINLOCK(ch_index_lock);
static const struct {
unsigned char sense;
unsigned char asc;
unsigned char ascq;
int errno;
u8 sense_key;
u16 sense_code;
int errno;
} ch_err[] = {
/* Just filled in what looks right. Hav'nt checked any standard paper for
these errno assignments, so they may be wrong... */
{
.sense = ILLEGAL_REQUEST,
.asc = 0x21,
.ascq = 0x01,
.errno = EBADSLT, /* Invalid element address */
.sense_key = ILLEGAL_REQUEST,
.sense_code = INVALID_ELEMENT_ADDRESS,
.errno = EBADSLT,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x28,
.ascq = 0x01,
.errno = EBADE, /* Import or export element accessed */
.sense_key = ILLEGAL_REQUEST,
.sense_code = IMPORT_OR_EXPORT_ELEMENT_ACCESSED,
.errno = EBADE,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x3B,
.ascq = 0x0D,
.errno = EXFULL, /* Medium destination element full */
.sense_key = ILLEGAL_REQUEST,
.sense_code = MEDIUM_DESTINATION_ELEMENT_FULL,
.errno = EXFULL,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x3B,
.ascq = 0x0E,
.errno = EBADE, /* Medium source element empty */
.sense_key = ILLEGAL_REQUEST,
.sense_code = MEDIUM_SOURCE_ELEMENT_EMPTY,
.errno = EBADE,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x20,
.ascq = 0x00,
.errno = EBADRQC, /* Invalid command operation code */
.sense_key = ILLEGAL_REQUEST,
.sense_code = INVALID_COMMAND_OP_CODE,
.errno = EBADRQC,
},{
/* end of list */
}
@ -167,12 +161,10 @@ static int ch_find_errno(struct scsi_sense_hdr *sshdr)
int i,errno = 0;
/* Check to see if additional sense information is available */
if (scsi_sense_valid(sshdr) &&
sshdr->asc != 0) {
if (scsi_sense_valid(sshdr) && scsi_sense_asc(sshdr) != 0) {
for (i = 0; ch_err[i].errno != 0; i++) {
if (ch_err[i].sense == sshdr->sense_key &&
ch_err[i].asc == sshdr->asc &&
ch_err[i].ascq == sshdr->ascq) {
if (ch_err[i].sense_key == sshdr->sense_key &&
ch_err[i].sense_code == sshdr->sense_code) {
errno = -ch_err[i].errno;
break;
}
@ -191,9 +183,8 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
struct scsi_sense_hdr sshdr;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 3,
.result = SAM_STAT_CHECK_CONDITION,
},

61
drivers/scsi/constants.c
View File

@ -292,7 +292,7 @@ bool scsi_opcode_sa_name(int opcode, int service_action,
}
struct error_info {
unsigned short code12; /* 0x0302 looks better than 0x03,0x02 */
unsigned short code; /* 0x0302 looks better than 0x03,0x02 */
unsigned short size;
};
@ -318,20 +318,46 @@ static const char *additional_text =
;
struct error_info2 {
unsigned char code1, code2_min, code2_max;
const char * str;
const char * fmt;
u8 asc;
u8 ascq_min;
u8 ascq_max;
const char *str;
const char *fmt;
};
static const struct error_info2 additional2[] =
{
{0x40, 0x00, 0x7f, "Ram failure", ""},
{0x40, 0x80, 0xff, "Diagnostic failure on component", ""},
{0x41, 0x00, 0xff, "Data path failure", ""},
{0x42, 0x00, 0xff, "Power-on or self-test failure", ""},
{0x4D, 0x00, 0xff, "Tagged overlapped commands", "task tag "},
{0x70, 0x00, 0xff, "Decompression exception", "short algorithm id of "},
{0, 0, 0, NULL, NULL}
{
ASC_RAM_FAILURE,
0x00, 0x7f,
"Ram failure", ""
},
{
ASC_RAM_FAILURE,
0x80, 0xff,
"Diagnostic failure on component", ""
},
{
ASC_DATA_PATH_FAILURE,
0x00, 0xff,
"Data path failure", ""
},
{
ASC_POWER_ON_OR_SELFTEST_FAILURE,
0x00, 0xff,
"Power-on or self-test failure", ""
},
{
ASC_TAGGED_OVERLAPPED_COMMANDS,
0x00, 0xff,
"Tagged overlapped commands", "task tag "
},
{
ASC_DECOMPRESSION_EXCEPTION_SHORT_ALGORITHM_ID,
0x00, 0xff,
"Decompression exception", "short algorithm id of "
},
{ 0, 0, 0, NULL, NULL }
};
/* description of the sense key values */
@ -375,22 +401,21 @@ EXPORT_SYMBOL(scsi_sense_key_string);
* This string may contain a "%x" and should be printed with ascq as arg.
*/
const char *
scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr, const char **fmt)
{
int i;
unsigned short code = ((asc << 8) | ascq);
unsigned offset = 0;
int i;
*fmt = NULL;
for (i = 0; i < ARRAY_SIZE(additional); i++) {
if (additional[i].code12 == code)
if (additional[i].code == sshdr->sense_code)
return additional_text + offset;
offset += additional[i].size;
}
for (i = 0; additional2[i].fmt; i++) {
if (additional2[i].code1 == asc &&
ascq >= additional2[i].code2_min &&
ascq <= additional2[i].code2_max) {
if (additional2[i].asc == scsi_sense_asc(sshdr) &&
scsi_sense_ascq(sshdr) >= additional2[i].ascq_min &&
scsi_sense_ascq(sshdr) <= additional2[i].ascq_max) {
*fmt = additional2[i].fmt;
return additional2[i].str;
}

55
drivers/scsi/device_handler/scsi_dh_alua.c
View File

@ -433,61 +433,43 @@ static enum scsi_disposition alua_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
/*
* LUN Not Accessible - ALUA state transition
*/
if (sense_hdr->sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
/*
* LUN Not Accessible - ALUA state transition
*/
if (sense_hdr->sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED) {
/*
* Power On, Reset, or Bus Device Reset.
* Might have obscured a state transition,
* so schedule a recheck.
*/
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
/*
* Device internal reset
*/
if (sense_hdr->sense_code == DEVICE_INTERNAL_RESET)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
/*
* Mode Parameters Changed
*/
if (sense_hdr->sense_code == MODE_PARAMETERS_CHANGED)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
/*
* ALUA state changed
*/
if (sense_hdr->sense_code == ASYMMETRIC_ACCESS_STATE_CHANGED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
/*
* Implicit ALUA state transition failed
*/
if (sense_hdr->sense_code ==
IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
/*
* Inquiry data has changed
*/
if (sense_hdr->sense_code == INQUIRY_DATA_HAS_CHANGED)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
if (sense_hdr->sense_code == REPORTED_LUNS_DATA_HAS_CHANGED)
/*
* REPORTED_LUNS_DATA_HAS_CHANGED is reported
* when switching controllers on targets like
@ -517,12 +499,12 @@ static int alua_tur(struct scsi_device *sdev)
ALUA_FAILOVER_RETRIES, &sense_hdr);
if ((sense_hdr.sense_key == NOT_READY ||
sense_hdr.sense_key == UNIT_ATTENTION) &&
sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
sense_hdr.sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION)
return SCSI_DH_RETRY;
else if (retval)
if (retval)
return SCSI_DH_IO;
else
return SCSI_DH_OK;
return SCSI_DH_OK;
}
/*
@ -619,7 +601,8 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
* transition. So set the state to 'transitioning' directly.
*/
if (sense_hdr.sense_key == NOT_READY &&
sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a) {
sense_hdr.sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
transitioning_sense = true;
goto skip_rtpg;
}

28
drivers/scsi/device_handler/scsi_dh_emc.c
View File

@ -105,10 +105,10 @@ static int trespass_endio(struct scsi_device *sdev,
sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, "
"0x%2x, 0x%2x while sending CLARiiON trespass "
"command.\n", CLARIION_NAME, sshdr->sense_key,
sshdr->asc, sshdr->ascq);
scsi_sense_asc(sshdr), scsi_sense_ascq(sshdr));
if (sshdr->sense_key == 0x05 && sshdr->asc == 0x04 &&
sshdr->ascq == 0x00) {
if (sshdr->sense_key == ILLEGAL_REQUEST &&
sshdr->sense_code == LU_NOT_READY) {
/*
* Array based copy in progress -- do not send
* mode_select or copy will be aborted mid-stream.
@ -117,18 +117,18 @@ static int trespass_endio(struct scsi_device *sdev,
"progress while sending CLARiiON trespass "
"command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
} else if (sshdr->sense_key == 0x02 && sshdr->asc == 0x04 &&
sshdr->ascq == 0x03) {
/*
* LUN Not Ready - Manual Intervention Required
* indicates in-progress ucode upgrade (NDU).
*/
} else if (sshdr->sense_key == NOT_READY &&
sshdr->sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
/* Indicates in-progress ucode upgrade (NDU). */
sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress "
"ucode upgrade NDU operation while sending "
"CLARiiON trespass command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
} else
} else {
err = SCSI_DH_DEV_FAILED;
}
return err;
}
@ -288,7 +288,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x03)
if (sense_hdr->sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED)
/*
* LUN Not Ready - Manual Intervention Required
* indicates this is a passive path.
@ -305,7 +306,7 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case ILLEGAL_REQUEST:
if (sense_hdr->asc == 0x25 && sense_hdr->ascq == 0x01)
if (sense_hdr->sense_code == scsi_sense_code(0x25, 0x01))
/*
* An array based copy is in progress. Do not
* fail the path, do not bypass to another PG,
@ -319,7 +320,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Unit Attention Code. This is the first IO
* to the new path, so just retry.

29
drivers/scsi/device_handler/scsi_dh_hp_sw.c
View File

@ -47,7 +47,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
switch (sshdr->sense_key) {
case NOT_READY:
if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
if (sshdr->sense_code ==
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED) {
/*
* LUN not ready - Initialization command required
*
@ -61,8 +62,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
default:
sdev_printk(KERN_WARNING, sdev,
"%s: sending tur failed, sense %x/%x/%x\n",
HP_SW_NAME, sshdr->sense_key, sshdr->asc,
sshdr->ascq);
HP_SW_NAME, sshdr->sense_key,
scsi_sense_asc(sshdr), scsi_sense_ascq(sshdr));
break;
}
return ret;
@ -84,9 +85,8 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -133,14 +133,9 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
/*
* LUN not ready - manual intervention required
*
* Switch-over in progress, retry.
*/
.sense = NOT_READY,
.asc = 0x04,
.ascq = 0x03,
/* Switch-over in progress, retry. */
.sense_key = NOT_READY,
.sense_code = LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED,
.allowed = HP_SW_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -167,7 +162,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
switch (sshdr.sense_key) {
case NOT_READY:
if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
if (sshdr.sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
rc = SCSI_DH_RETRY;
break;
}
@ -176,7 +172,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
sdev_printk(KERN_WARNING, sdev,
"%s: sending start_stop_unit failed, "
"sense %x/%x/%x\n", HP_SW_NAME,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key, scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
rc = SCSI_DH_IO;
}

55
drivers/scsi/device_handler/scsi_dh_rdac.c
View File

@ -493,7 +493,8 @@ static int mode_select_handle_sense(struct scsi_device *sdev,
RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
"MODE_SELECT returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
sense_hdr->sense_key, scsi_sense_asc(sense_hdr),
scsi_sense_ascq(sense_hdr));
return SCSI_DH_IO;
}
@ -514,35 +515,29 @@ static void send_mode_select(struct work_struct *work)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
.sense = NO_SENSE,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = NO_SENSE,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = ABORTED_COMMAND,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = ABORTED_COMMAND,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* LUN Not Ready and is in the Process of Becoming Ready */
{
.sense = NOT_READY,
.asc = 0x04,
.ascq = 0x01,
.sense_key = NOT_READY,
.sense_code = LU_IS_IN_PROCESS_OF_BECOMING_READY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Command Lock contention */
/* Command Lock contention (not a standard sense code) */
{
.sense = ILLEGAL_REQUEST,
.asc = 0x91,
.ascq = 0x36,
.sense_key = ILLEGAL_REQUEST,
.sense_code = scsi_sense_code(0x91, 0x36),
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -674,33 +669,34 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
{
struct rdac_dh_data *h = sdev->handler_data;
RDAC_LOG(RDAC_LOG_SENSE, sdev, "array %s, ctlr %d, "
"I/O returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
RDAC_LOG(RDAC_LOG_SENSE, sdev,
"array %s, ctlr %d, I/O returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, scsi_sense_asc(sense_hdr),
scsi_sense_ascq(sense_hdr));
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
if (sense_hdr->sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY)
/* LUN Not Ready - Logical Unit Not Ready and is in
* the process of becoming ready
* Just retry.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
if (sense_hdr->sense_code == scsi_sense_code(0x04, 0x81))
/* LUN Not Ready - Storage firmware incompatible
* Manual code synchonisation required.
*
* Nothing we can do here. Try to bypass the path.
*/
return SUCCESS;
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
if (sense_hdr->sense_code == scsi_sense_code(0x04, 0xA1))
/* LUN Not Ready - Quiescense in progress
*
* Just retry and wait.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0xA1 && sense_hdr->ascq == 0x02)
if (sense_hdr->sense_code == scsi_sense_code(0xA1, 0x02))
/* LUN Not Ready - Quiescense in progress
* or has been achieved
* Just retry.
@ -708,7 +704,7 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
return ADD_TO_MLQUEUE;
break;
case ILLEGAL_REQUEST:
if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
if (sense_hdr->sense_code == scsi_sense_code(0x94, 0x01)) {
/* Invalid Request - Current Logical Unit Ownership.
* Controller is not the current owner of the LUN,
* Fail the path, so that the other path be used.
@ -718,12 +714,13 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
}
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Power On, Reset, or Bus Device Reset, just retry.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
if (sense_hdr->sense_code == scsi_sense_code(0x8b, 0x02))
/*
* Quiescence in progress , just retry.
*/

69
drivers/scsi/hpsa.c
View File

@ -353,14 +353,13 @@ static inline bool hpsa_is_cmd_idle(struct CommandList *c)
/* extract sense key, asc, and ascq from sense data. -1 means invalid. */
static void decode_sense_data(const u8 *sense_data, int sense_data_len,
u8 *sense_key, u8 *asc, u8 *ascq)
u8 *sense_key, u16 *sense_code)
{
struct scsi_sense_hdr sshdr;
bool rc;
*sense_key = -1;
*asc = -1;
*ascq = -1;
*sense_code = -1;
if (sense_data_len < 1)
return;
@ -368,15 +367,15 @@ static void decode_sense_data(const u8 *sense_data, int sense_data_len,
rc = scsi_normalize_sense(sense_data, sense_data_len, &sshdr);
if (rc) {
*sense_key = sshdr.sense_key;
*asc = sshdr.asc;
*ascq = sshdr.ascq;
*sense_code = sshdr.sense_code;
}
}
static int check_for_unit_attention(struct ctlr_info *h,
struct CommandList *c)
{
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
if (c->err_info->SenseLen > sizeof(c->err_info->SenseInfo))
@ -385,34 +384,35 @@ static int check_for_unit_attention(struct ctlr_info *h,
sense_len = c->err_info->SenseLen;
decode_sense_data(c->err_info->SenseInfo, sense_len,
&sense_key, &asc, &ascq);
if (sense_key != UNIT_ATTENTION || asc == 0xff)
&sense_key, &sense_code);
if (sense_key != UNIT_ATTENTION ||
scsi_sense_code_asc(sense_code) == 0xff)
return 0;
switch (asc) {
case STATE_CHANGED:
switch (scsi_sense_code_asc(sense_code)) {
case ASC_PARAMETERS_CHANGED:
dev_warn(&h->pdev->dev,
"%s: a state change detected, command retried\n",
h->devname);
break;
case LUN_FAILED:
case ASC_LU_HAS_NOT_SELF_CONFIGURED_YET:
dev_warn(&h->pdev->dev,
"%s: LUN failure detected\n", h->devname);
break;
case REPORT_LUNS_CHANGED:
case ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED:
dev_warn(&h->pdev->dev,
"%s: report LUN data changed\n", h->devname);
/*
* Note: this REPORT_LUNS_CHANGED condition only occurs on the external
* target (array) devices.
* Note: this ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED condition
* only occurs on the external target (array) devices.
*/
break;
case POWER_OR_RESET:
case ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED:
dev_warn(&h->pdev->dev,
"%s: a power on or device reset detected\n",
h->devname);
break;
case UNIT_ATTENTION_CLEARED:
case ASC_COMMANDS_CLEARED_BY_ANOTHER_INITIATOR:
dev_warn(&h->pdev->dev,
"%s: unit attention cleared by another initiator\n",
h->devname);
@ -2562,10 +2562,8 @@ static void complete_scsi_command(struct CommandList *cp)
struct ErrorInfo *ei;
struct hpsa_scsi_dev_t *dev;
struct io_accel2_cmd *c2;
u8 sense_key;
u8 asc; /* additional sense code */
u8 ascq; /* additional sense code qualifier */
u16 sense_code;
unsigned long sense_data_size;
ei = cp->err_info;
@ -2666,18 +2664,19 @@ static void complete_scsi_command(struct CommandList *cp)
memcpy(cmd->sense_buffer, ei->SenseInfo, sense_data_size);
if (ei->ScsiStatus)
decode_sense_data(ei->SenseInfo, sense_data_size,
&sense_key, &asc, &ascq);
&sense_key, &sense_code);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
switch (sense_key) {
case ABORTED_COMMAND:
cmd->result |= DID_SOFT_ERROR << 16;
break;
case UNIT_ATTENTION:
if (asc == 0x3F && ascq == 0x0E)
if (sense_code ==
REPORTED_LUNS_DATA_HAS_CHANGED)
h->drv_req_rescan = 1;
break;
case ILLEGAL_REQUEST:
if (asc == 0x25 && ascq == 0x00) {
if (sense_code == LU_NOT_SUPPORTED) {
dev->removed = 1;
cmd->result = DID_NO_CONNECT << 16;
}
@ -2693,7 +2692,9 @@ static void complete_scsi_command(struct CommandList *cp)
"Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
"Returning result: 0x%x\n",
cp, ei->ScsiStatus,
sense_key, asc, ascq,
sense_key,
scsi_sense_code_asc(sense_code),
scsi_sense_code_ascq(sense_code),
cmd->result);
} else { /* scsi status is zero??? How??? */
dev_warn(&h->pdev->dev, "cp %p SCSI status was 0. "
@ -2919,7 +2920,8 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
{
const struct ErrorInfo *ei = cp->err_info;
struct device *d = &cp->h->pdev->dev;
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
switch (ei->CommandStatus) {
@ -2928,12 +2930,13 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
sense_len = sizeof(ei->SenseInfo);
else
sense_len = ei->SenseLen;
decode_sense_data(ei->SenseInfo, sense_len,
&sense_key, &asc, &ascq);
decode_sense_data(ei->SenseInfo, sense_len, &sense_key,
&sense_code);
hpsa_print_cmd(h, "SCSI status", cp);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION)
dev_warn(d, "SCSI Status = 02, Sense key = 0x%02x, ASC = 0x%02x, ASCQ = 0x%02x\n",
sense_key, asc, ascq);
sense_key, scsi_sense_code_asc(sense_code),
scsi_sense_code_ascq(sense_code));
else
dev_warn(d, "SCSI Status = 0x%02x\n", ei->ScsiStatus);
if (ei->ScsiStatus == 0)
@ -3868,12 +3871,10 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
{
struct CommandList *c;
unsigned char *sense;
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
int rc, ldstat = 0;
#define ASC_LUN_NOT_READY 0x04
#define ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS 0x04
#define ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ 0x02
c = cmd_alloc(h);
@ -3889,7 +3890,7 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
sense_len = sizeof(c->err_info->SenseInfo);
else
sense_len = c->err_info->SenseLen;
decode_sense_data(sense, sense_len, &sense_key, &asc, &ascq);
decode_sense_data(sense, sense_len, &sense_key, &sense_code);
cmd_free(h, c);
/* Determine the reason for not ready state */
@ -3912,8 +3913,8 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
/* If VPD status page isn't available,
* use ASC/ASCQ to determine state
*/
if ((ascq == ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS) ||
(ascq == ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ))
if (sense_code == LU_NOT_READY_FORMAT_IN_PROGRESS ||
sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return ldstat;
break;
default:

23
drivers/scsi/hpsa_cmd.h
View File

@ -63,29 +63,6 @@
#define CISS_TMF_WRONG_LUN 0x09
#define CISS_TMF_OVERLAPPED_TAG 0x0a
/* Unit Attentions ASC's as defined for the MSA2012sa */
#define POWER_OR_RESET 0x29
#define STATE_CHANGED 0x2a
#define UNIT_ATTENTION_CLEARED 0x2f
#define LUN_FAILED 0x3e
#define REPORT_LUNS_CHANGED 0x3f
/* Unit Attentions ASCQ's as defined for the MSA2012sa */
/* These ASCQ's defined for ASC = POWER_OR_RESET */
#define POWER_ON_RESET 0x00
#define POWER_ON_REBOOT 0x01
#define SCSI_BUS_RESET 0x02
#define MSA_TARGET_RESET 0x03
#define CONTROLLER_FAILOVER 0x04
#define TRANSCEIVER_SE 0x05
#define TRANSCEIVER_LVD 0x06
/* These ASCQ's defined for ASC = STATE_CHANGED */
#define RESERVATION_PREEMPTED 0x03
#define ASYM_ACCESS_CHANGED 0x06
#define LUN_CAPACITY_CHANGED 0x09
/* transfer direction */
#define XFER_NONE 0x00
#define XFER_WRITE 0x01

5
drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
View File

@ -3757,9 +3757,8 @@ static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)
dev_err(&vscsi->dev, "srp_transfer_data failed: %d\n", rc);
se_cmd->scsi_sense_length = 18;
memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);
/* Logical Unit Communication Time-out asc/ascq = 0x0801 */
scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
0x08, 0x01);
scsi_set_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
LU_COMMUNICATION_TIMEOUT);
}
srp_build_response(vscsi, cmd, &len);

7
drivers/scsi/leapraid/leapraid_func.h
View File

@ -113,7 +113,6 @@
#define DESC_FORMAT_THRESHOLD 0x72
#define SENSE_KEY_MASK 0x0F
#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
#define ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED 0x5D
#define LEAPRAID_LARGE_DISK_THRESHOLD 0x200000UL
#define LEAPRAID_LARGE_DISK_HEADS 255
#define LEAPRAID_LARGE_DISK_SECTORS 63
@ -126,12 +125,6 @@
#define LEAPRAID_SCSI_HOST_SHIFT 16
#define LEAPRAID_SCSI_DRIVER_SHIFT 24
/* SCSI ASC/ASCQ definitions. */
#define LEAPRAID_SCSI_ASCQ_DEFAULT 0x00
#define LEAPRAID_SCSI_ASC_POWER_ON_RESET 0x29
#define LEAPRAID_SCSI_ASC_INVALID_CMD_CODE 0x20
#define LEAPRAID_SCSI_ASCQ_POWER_ON_RESET 0x07
/* VPD Page 0x89 (ATA Information). */
#define LEAPRAID_VPD_PAGE_ATA_INFO 0x89
#define LEAPRAID_VPD_PG89_MAX_LEN 255

15
drivers/scsi/leapraid/leapraid_os.c
View File

@ -382,9 +382,8 @@ static void leapraid_handle_data_underrun(
} else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
scsiio_rep->scsi_state = LEAPRAID_SCSI_STATE_AUTOSENSE_VALID;
scsiio_rep->scsi_status = SAM_STAT_CHECK_CONDITION;
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
LEAPRAID_SCSI_ASC_INVALID_CMD_CODE,
LEAPRAID_SCSI_ASCQ_DEFAULT);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
}
}
@ -515,8 +514,9 @@ static void leapraid_scsiio_done_dispatch(
&sshdr))
dev_warn(&adapter->pdev->dev,
"Sense: key=0x%x asc=0x%x ascq=0x%x\n",
sshdr.sense_key, sshdr.asc,
sshdr.ascq);
sshdr.sense_key,
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
else
dev_warn(&adapter->pdev->dev,
"Sense: Invalid sense data\n");
@ -810,9 +810,8 @@ static bool leapraid_should_queuecommand(struct leapraid_adapter *adapter,
if (sdev_priv->block &&
scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION,
LEAPRAID_SCSI_ASC_POWER_ON_RESET,
LEAPRAID_SCSI_ASCQ_POWER_ON_RESET);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
goto scsiio_done;
}

3
drivers/scsi/libiscsi.c
View File

@ -892,7 +892,8 @@ static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
ascq = session->tt->check_protection(task, &sector);
if (ascq) {
scsi_build_sense(sc, 1, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(sc, 1, ILLEGAL_REQUEST,
scsi_sense_code(ASC_ID_CRC_OR_ECC_ERROR, ascq));
scsi_set_sense_information(sc->sense_buffer,
SCSI_SENSE_BUFFERSIZE,
sector);

18
drivers/scsi/lpfc/lpfc_scsi.c
View File

@ -2848,7 +2848,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
}
out:
if (err_type == BGS_GUARD_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2857,7 +2858,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
sum, guard_tag);
} else if (err_type == BGS_REFTAG_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
@ -2867,7 +2869,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
ref_tag, start_ref_tag);
} else if (err_type == BGS_APPTAG_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
@ -2970,7 +2973,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_guard_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2983,7 +2987,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_reftag_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2996,7 +3001,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_apptag_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,

8
drivers/scsi/megaraid.c
View File

@ -1592,9 +1592,11 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
epthru->reqsensearea, 14);
cmd->result = SAM_STAT_CHECK_CONDITION;
} else
scsi_build_sense(cmd, 0,
ABORTED_COMMAND, 0, 0);
} else {
scsi_set_sense(cmd, 0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
}
break;

2
drivers/scsi/megaraid/mega_common.h
View File

@ -37,8 +37,6 @@
#define PCI_CONF_AMISIG64 0xa4
#define MEGA_SCSI_INQ_EVPD 1
#define MEGA_INVALID_FIELD_IN_CDB 0x24
/**
* scb_t - scsi command control block

12
drivers/scsi/megaraid/megaraid_mbox.c
View File

@ -1577,8 +1577,8 @@ megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp,
}
if (scp->cmnd[1] & MEGA_SCSI_INQ_EVPD) {
scsi_build_sense(scp, 0, ILLEGAL_REQUEST,
MEGA_INVALID_FIELD_IN_CDB, 0);
scsi_set_sense(scp, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
return NULL;
}
@ -2311,9 +2311,11 @@ megaraid_mbox_dpc(unsigned long devp)
epthru->reqsensearea, 14);
scp->result = SAM_STAT_CHECK_CONDITION;
} else
scsi_build_sense(scp, 0,
ABORTED_COMMAND, 0, 0);
} else {
scsi_set_sense(scp, 0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
}
break;

3
drivers/scsi/mpi3mr/mpi3mr_fw.c
View File

@ -419,7 +419,8 @@ static void mpi3mr_process_admin_reply_desc(struct mpi3mr_ioc *mrioc,
scsi_normalize_sense(sense_buf, sense_count,
&sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
}
mpi3mr_reply_trigger(mrioc, masked_ioc_status, ioc_loginfo);

50
drivers/scsi/mpi3mr/mpi3mr_os.c
View File

@ -3367,8 +3367,7 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* @desc: Sense type
* @buf: Sense buffer to populate
* @key: Sense key
* @asc: Additional sense code
* @ascq: Additional sense code qualifier
* @code: Additional sense code and its qualifier
*
* Maps the given sense information into either descriptor or
* fixed format sense data.
@ -3376,20 +3375,20 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* Return: Nothing
*/
static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
u8 asc, u8 ascq)
u16 code)
{
if (desc) {
buf[0] = 0x72; /* descriptor, current */
buf[1] = key;
buf[2] = asc;
buf[3] = ascq;
buf[2] = scsi_sense_code_asc(code);
buf[3] = scsi_sense_code_ascq(code);
buf[7] = 0;
} else {
buf[0] = 0x70; /* fixed, current */
buf[2] = key;
buf[7] = 0xa;
buf[12] = asc;
buf[13] = ascq;
buf[12] = scsi_sense_code_asc(code);
buf[13] = scsi_sense_code_ascq(code);
}
}
@ -3406,25 +3405,25 @@ static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
static void mpi3mr_map_eedp_error(struct scsi_cmnd *scmd,
u16 ioc_status)
{
u8 ascq = 0;
u16 sense_code;
switch (ioc_status) {
case MPI3_IOCSTATUS_EEDP_GUARD_ERROR:
ascq = 0x01;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_APP_TAG_ERROR:
ascq = 0x02;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_REF_TAG_ERROR:
ascq = 0x03;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
ascq = 0x00;
sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
mpi3mr_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x10, ascq);
sense_code);
scmd->result = (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
}
@ -3509,7 +3508,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
if (sense_buf) {
scsi_normalize_sense(sense_buf, sense_count, &sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
mpi3mr_reply_trigger(mrioc, ioc_status, ioc_loginfo);
break;
@ -3696,7 +3696,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
ioc_info(mrioc,
"%s :sense_count 0x%x, sense_key 0x%x ASC 0x%x, ASCQ 0x%x\n",
__func__, sense_count, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
}
out_success:
@ -5103,8 +5104,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x1A, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@ -5114,8 +5115,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len, scsi_bufflen(scmd));
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x1A, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@ -5123,8 +5124,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
if (!buf) {
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x55, 0x03);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
INSUFFICIENT_RESOURCES);
scsi_done(scmd);
return true;
}
@ -5137,8 +5138,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, desc_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x26, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
INVALID_FIELD_IN_PARAMETER_LIST);
scsi_done(scmd);
kfree(buf);
return true;
@ -5238,7 +5239,8 @@ static enum scsi_qc_status mpi3mr_qcmd(struct Scsi_Host *shost,
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY &&
(stgt_priv_data->dev_removed || (dev_handle == MPI3MR_INVALID_DEV_HANDLE))) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
goto out;
}

69
drivers/scsi/mpt3sas/mpt3sas_scsih.c
View File

@ -5401,23 +5401,23 @@ _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
static void
_scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
{
u8 ascq;
u16 sense_code;
switch (ioc_status) {
case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
ascq = 0x01;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
ascq = 0x02;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
ascq = 0x03;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
ascq = 0x00;
sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, sense_code);
set_host_byte(scmd, DID_ABORT);
}
@ -5474,7 +5474,8 @@ static enum scsi_qc_status scsih_qcmd(struct Scsi_Host *shost,
if (handle == MPT3SAS_INVALID_DEVICE_HANDLE || sas_device_priv_data->block) {
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
return 0;
}
@ -5986,7 +5987,7 @@ _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
event_reply->EventData;
event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
event_data->ASC = 0x5D;
event_data->ASC = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
event_data->DevHandle = cpu_to_le16(handle);
event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
mpt3sas_ctl_add_to_event_log(ioc, event_reply);
@ -6109,8 +6110,7 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
le32_to_cpu(mpi_reply->SenseCount));
memcpy(scmd->sense_buffer, sense_data, sz);
_scsih_normalize_sense(scmd->sense_buffer, &data);
/* failure prediction threshold exceeded */
if (data.asc == 0x5D)
if (data.asc == ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED)
_scsih_smart_predicted_fault(ioc,
le16_to_cpu(mpi_reply->DevHandle));
mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
@ -6199,8 +6199,8 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
0x20, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
}
break;
@ -7691,38 +7691,41 @@ _scsih_determine_disposition(struct MPT3SAS_ADAPTER *ioc,
if (check_sense) {
_scsih_normalize_sense(transfer_packet->sense, &sense_info);
if (sense_info.skey == UNIT_ATTENTION)
if (sense_info.skey == UNIT_ATTENTION) {
rc = DEVICE_RETRY_UA;
else if (sense_info.skey == NOT_READY) {
/* medium isn't present */
if (sense_info.asc == 0x3a)
} else if (sense_info.skey == NOT_READY) {
if (sense_info.asc == ASC_MEDIUM_NOT_PRESENT) {
rc = DEVICE_READY;
/* LOGICAL UNIT NOT READY */
else if (sense_info.asc == 0x04) {
if (sense_info.ascq == 0x03 ||
sense_info.ascq == 0x0b ||
sense_info.ascq == 0x0c) {
} else if (sense_info.asc == ASC_LU_NOT_READY) {
u16 scode = scsi_sense_code(sense_info.asc,
sense_info.ascq);
if (scode ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED ||
scode ==
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE ||
scode ==
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE)
rc = DEVICE_ERROR;
} else
else
rc = DEVICE_START_UNIT;
}
/* LOGICAL UNIT HAS NOT SELF-CONFIGURED YET */
else if (sense_info.asc == 0x3e && !sense_info.ascq)
} else if (sense_info.asc ==
ASC_LU_HAS_NOT_SELF_CONFIGURED_YET &&
!sense_info.ascq) {
rc = DEVICE_START_UNIT;
}
} else if (sense_info.skey == ILLEGAL_REQUEST &&
transfer_packet->cdb[0] == REPORT_LUNS) {
transfer_packet->cdb[0] == REPORT_LUNS) {
rc = DEVICE_READY;
} else if (sense_info.skey == MEDIUM_ERROR) {
/* medium is corrupt, lets add the device so
* users can collect some info as needed
/*
* medium is corrupt, lets add the device so users can
* collect some info as needed
*/
if (sense_info.asc == 0x31)
if (sense_info.asc == ASC_MEDIUM_FORMAT_CORRUPTED)
rc = DEVICE_READY;
} else if (sense_info.skey == HARDWARE_ERROR) {
/* Defect List Error, still add the device */
if (sense_info.asc == 0x19)
if (sense_info.asc == ASC_DEFECT_LIST_ERROR)
rc = DEVICE_READY;
}
}

2
drivers/scsi/mvumi.c
View File

@ -2067,7 +2067,7 @@ static unsigned char mvumi_build_frame(struct mvumi_hba *mhba,
return 0;
error:
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return -1;
}

67
drivers/scsi/myrb.c
View File

@ -314,17 +314,19 @@ static void myrb_get_event(struct myrb_hba *cb, unsigned int event)
scsi_normalize_sense(ev_buf->sense, 32, &sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
sshdr.asc == 0x80 &&
sshdr.ascq < ARRAY_SIZE(myrb_event_msg))
scsi_sense_asc(&sshdr) == 0x80 &&
scsi_sense_ascq(&sshdr) < ARRAY_SIZE(myrb_event_msg))
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: %s\n",
ev_buf->channel, ev_buf->target,
myrb_event_msg[sshdr.ascq]);
myrb_event_msg[scsi_sense_ascq(&sshdr)]);
else
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: Sense: %X/%02X/%02X\n",
ev_buf->channel, ev_buf->target,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key,
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_log_entry),
@ -1398,7 +1400,7 @@ myrb_mode_sense(struct myrb_hba *cb, struct scsi_cmnd *scmd,
static void myrb_request_sense(struct myrb_hba *cb,
struct scsi_cmnd *scmd)
{
scsi_build_sense(scmd, 0, NO_SENSE, 0, 0);
scsi_set_sense(scmd, 0, NO_SENSE, NO_ADDITIONAL_SENSE_INFORMATION);
scsi_sg_copy_from_buffer(scmd, scmd->sense_buffer,
SCSI_SENSE_BUFFERSIZE);
}
@ -1446,8 +1448,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case INQUIRY:
if (scmd->cmnd[1] & 1) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrb_inquiry(cb, scmd);
scmd->result = (DID_OK << 16);
@ -1461,8 +1463,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case MODE_SENSE:
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrb_mode_sense(cb, scmd, ldev_info);
scmd->result = (DID_OK << 16);
@ -1472,15 +1474,15 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case READ_CAPACITY:
if ((scmd->cmnd[1] & 1) ||
(scmd->cmnd[8] & 1)) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
lba = get_unaligned_be32(&scmd->cmnd[2]);
if (lba) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
@ -1493,8 +1495,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case SEND_DIAGNOSTIC:
if (scmd->cmnd[1] != 0x04) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
/* Assume good status */
scmd->result = (DID_OK << 16);
@ -1503,8 +1505,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case READ_6:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1517,8 +1519,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_10:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1531,8 +1533,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_12:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1544,8 +1546,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
break;
default:
/* Illegal request, invalid opcode */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
}
@ -2328,20 +2330,19 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
dev_dbg(&scmd->device->sdev_gendev,
"Bad Data Encountered\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
/* Unrecovered read error */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
UNRECOVERED_READ_ERROR);
else
/* Write error */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0);
scsi_set_sense(scmd, 0, MEDIUM_ERROR, SSC_WRITE_ERROR);
break;
case MYRB_STATUS_IRRECOVERABLE_DATA_ERROR:
scmd_printk(KERN_ERR, scmd, "Irrecoverable Data Error\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
/* Unrecovered read error, auto-reallocation failed */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0x04);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED);
else
/* Write error, auto-reallocation failed */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0x02);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
WRITE_ERROR_AUTO_REALLOCATION_FAILED);
break;
case MYRB_STATUS_LDRV_NONEXISTENT_OR_OFFLINE:
dev_dbg(&scmd->device->sdev_gendev,
@ -2351,8 +2352,8 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
case MYRB_STATUS_ACCESS_BEYOND_END_OF_LDRV:
dev_dbg(&scmd->device->sdev_gendev,
"Attempt to Access Beyond End of Logical Drive");
/* Logical block address out of range */
scsi_build_sense(scmd, 0, NOT_READY, 0x21, 0);
scsi_set_sense(scmd, 0, NOT_READY,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
break;
case MYRB_STATUS_DEVICE_NONRESPONSIVE:
dev_dbg(&scmd->device->sdev_gendev, "Device nonresponsive\n");

23
drivers/scsi/myrs.c
View File

@ -816,7 +816,7 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
struct Scsi_Host *shost = cs->host;
struct scsi_device *sdev;
struct scsi_sense_hdr sshdr = {0};
unsigned char sense_info[4];
unsigned char asc, sense_info[4];
unsigned char cmd_specific[4];
if (ev->ev_code == 0x1C) {
@ -829,9 +829,11 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
memcpy(cmd_specific, &ev->sense_data[7], 4);
}
}
asc = scsi_sense_asc(&sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
(sshdr.asc == 0x80 || sshdr.asc == 0x81))
ev->ev_code = ((sshdr.asc - 0x80) << 8 | sshdr.ascq);
(asc == 0x80 || asc == 0x81))
ev->ev_code = scsi_sense_code(asc - 0x80,
scsi_sense_ascq(&sshdr));
while (true) {
ev_code = myrs_ev_list[ev_idx].ev_code;
if (ev_code == ev->ev_code || ev_code == 0)
@ -891,8 +893,9 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
case 'S':
if (sshdr.sense_key == NO_SENSE ||
(sshdr.sense_key == NOT_READY &&
sshdr.asc == 0x04 && (sshdr.ascq == 0x01 ||
sshdr.ascq == 0x02)))
(sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY ||
sshdr.sense_code ==
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)))
break;
shost_printk(KERN_INFO, shost,
"event %d: Physical Device %d:%d %s\n",
@ -900,7 +903,8 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Key = %X, ASC = %02X, ASCQ = %02X\n",
ev->channel, ev->target,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key, scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Information = %02X%02X%02X%02X %02X%02X%02X%02X\n",
ev->channel, ev->target,
@ -1603,7 +1607,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
switch (scmd->cmnd[0]) {
case REPORT_LUNS:
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0x0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
case MODE_SENSE:
@ -1612,8 +1617,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrs_mode_sense(cs, scmd, ldev_info);
scmd->result = (DID_OK << 16);

5
drivers/scsi/ps3rom.c
View File

@ -233,7 +233,8 @@ static enum scsi_qc_status ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
}
if (res) {
scsi_build_sense(cmd, 0, ILLEGAL_REQUEST, 0, 0);
scsi_set_sense(cmd, 0, ILLEGAL_REQUEST,
NO_ADDITIONAL_SENSE_INFORMATION);
cmd->result = res;
priv->curr_cmd = NULL;
scsi_done(cmd);
@ -316,7 +317,7 @@ static irqreturn_t ps3rom_interrupt(int irq, void *data)
goto done;
}
scsi_build_sense(cmd, 0, sense_key, asc, ascq);
scsi_set_sense(cmd, 0, sense_key, scsi_sense_code(asc, ascq));
done:
priv->curr_cmd = NULL;

9
drivers/scsi/qla2xxx/qla_isr.c
View File

@ -3263,21 +3263,24 @@ qla2x00_handle_dif_error(srb_t *sp, void *pkt)
/* check guard */
if (e_guard != a_guard) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check ref tag */
if (e_ref_tag != a_ref_tag) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check appl tag */
if (e_app_tag != a_app_tag) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}

99
drivers/scsi/qla2xxx/qla_target.c
View File

@ -2243,18 +2243,20 @@ void qlt_free_ul_mcmd(struct qla_hw_data *ha, struct qla_tgt_mgmt_cmd *mcmd)
* ha->hardware_lock supposed to be held on entry. Might drop it, then
* reacquire
*/
void qlt_send_resp_ctio(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t scsi_status, uint8_t sense_key, uint8_t asc, uint8_t ascq)
static void qlt_send_resp_ctio(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t scsi_status, uint8_t sense_key, uint16_t sense_code)
{
struct atio_from_isp *atio = &cmd->atio;
struct ctio7_to_24xx *ctio;
uint16_t temp;
struct scsi_qla_host *vha = cmd->vha;
uint8_t asc = scsi_sense_code_asc(sense_code);
uint8_t ascq = scsi_sense_code_ascq(sense_code);
ql_dbg(ql_dbg_tgt_dif, vha, 0x3066,
"Sending response CTIO7 (vha=%p, atio=%p, scsi_status=%02x, "
"sense_key=%02x, asc=%02x, ascq=%02x",
vha, atio, scsi_status, sense_key, asc, ascq);
vha, atio, scsi_status, sense_key, asc, ascq);
ctio = (struct ctio7_to_24xx *)qla2x00_alloc_iocbs(vha, NULL);
if (!ctio) {
@ -2677,44 +2679,47 @@ static void qlt_print_dif_err(struct qla_tgt_prm *prm)
{
struct qla_tgt_cmd *cmd;
struct scsi_qla_host *vha;
u16 scode;
/* asc 0x10=dif error */
if (prm->sense_buffer && (prm->sense_buffer[12] == 0x10)) {
cmd = prm->cmd;
vha = cmd->vha;
/* ASCQ */
switch (prm->sense_buffer[13]) {
case 1:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00b,
"BE detected Guard TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case 2:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00c,
"BE detected APP TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case 3:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00f,
"BE detected REF TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
default:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe010,
"BE detected Dif ERR: lba[%llx|%lld] len[%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
}
ql_dump_buffer(ql_dbg_tgt_dif, vha, 0xe011, cmd->cdb, 16);
if (!prm->sense_buffer ||
prm->sense_buffer[12] != ASC_ID_CRC_OR_ECC_ERROR)
return;
cmd = prm->cmd;
vha = cmd->vha;
scode = scsi_sense_code(prm->sense_buffer[12], prm->sense_buffer[13]);
switch (scode) {
case LOGICAL_BLOCK_GUARD_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00b,
"BE detected Guard TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00c,
"BE detected APP TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00f,
"BE detected REF TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
default:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe010,
"BE detected Dif ERR: lba[%llx|%lld] len[%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
}
ql_dump_buffer(ql_dbg_tgt_dif, vha, 0xe011, cmd->cdb, 16);
}
/*
@ -3467,7 +3472,8 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t *ap = &sts->actual_dif[0];
uint8_t *ep = &sts->expected_dif[0];
uint64_t lba = cmd->se_cmd.t_task_lba;
uint8_t scsi_status, sense_key, asc, ascq;
uint8_t scsi_status, sense_key;
uint16_t sense_code = 0;
struct scsi_qla_host *vha = cmd->vha;
cmd->trc_flags |= TRC_DIF_ERR;
@ -3483,7 +3489,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
ql_dbg(ql_dbg_tgt_dif, vha, 0xf075,
"%s: aborted %d state %d\n", __func__, cmd->aborted, cmd->state);
scsi_status = sense_key = asc = ascq = 0;
scsi_status = sense_key = 0;
/* check appl tag */
if (cmd->e_app_tag != cmd->a_app_tag) {
@ -3497,8 +3503,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_APP;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x2;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
}
/* check ref tag */
@ -3513,8 +3518,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_REF;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x3;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
goto out;
}
@ -3530,8 +3534,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_GRD;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x1;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
}
out:
switch (cmd->state) {
@ -3547,8 +3550,8 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
break;
}
qlt_send_resp_ctio(qpair, cmd, scsi_status, sense_key, asc,
ascq);
qlt_send_resp_ctio(qpair, cmd, scsi_status, sense_key,
sense_code);
/* assume scsi status gets out on the wire.
* Will not wait for completion.
*/

3
drivers/scsi/qla2xxx/qla_target.h
View File

@ -1178,7 +1178,4 @@ extern irqreturn_t qla83xx_msix_atio_q(int, void *);
extern void qlt_logo_completion_handler(fc_port_t *, int);
extern void qlt_do_generation_tick(struct scsi_qla_host *, int *);
void qlt_send_resp_ctio(struct qla_qpair *, struct qla_tgt_cmd *, uint8_t,
uint8_t, uint8_t, uint8_t);
#endif /* __QLA_TARGET_H */

3
drivers/scsi/scsi.c
View File

@ -606,7 +606,8 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
return result;
if (result && scsi_sense_valid(&sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
(sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
(sshdr.sense_code == INVALID_COMMAND_OP_CODE ||
sshdr.sense_code == INVALID_FIELD_IN_CDB))
return -EINVAL;
if ((buffer[1] & 3) == 3) /* Command supported */

24
drivers/scsi/scsi_common.c
View File

@ -191,6 +191,8 @@ EXPORT_SYMBOL(int_to_scsilun);
bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
struct scsi_sense_hdr *sshdr)
{
u8 asc = 0, ascq = 0;
memset(sshdr, 0, sizeof(struct scsi_sense_hdr));
if (!sense_buffer || !sb_len)
@ -208,9 +210,9 @@ bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
if (sb_len > 1)
sshdr->sense_key = (sense_buffer[1] & 0xf);
if (sb_len > 2)
sshdr->asc = sense_buffer[2];
asc = sense_buffer[2];
if (sb_len > 3)
sshdr->ascq = sense_buffer[3];
ascq = sense_buffer[3];
if (sb_len > 7)
sshdr->additional_length = sense_buffer[7];
} else {
@ -222,12 +224,14 @@ bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
if (sb_len > 7) {
sb_len = min(sb_len, sense_buffer[7] + 8);
if (sb_len > 12)
sshdr->asc = sense_buffer[12];
asc = sense_buffer[12];
if (sb_len > 13)
sshdr->ascq = sense_buffer[13];
ascq = sense_buffer[13];
}
}
sshdr->sense_code = scsi_sense_code(asc, ascq);
return true;
}
EXPORT_SYMBOL(scsi_normalize_sense);
@ -272,17 +276,19 @@ const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
EXPORT_SYMBOL(scsi_sense_desc_find);
/**
* scsi_build_sense_buffer - build sense data in a buffer
* scsi_set_sense_buffer - build sense data in a buffer
* @desc: Sense format (non-zero == descriptor format,
* 0 == fixed format)
* @buf: Where to build sense data
* @key: Sense key
* @asc: Additional sense code
* @ascq: Additional sense code qualifier
* @code: Additional sense code and sense code qualifier
*
**/
void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq)
void scsi_set_sense_buffer(int desc, u8 *buf, u8 key, u16 code)
{
u8 asc = scsi_sense_code_asc(code);
u8 ascq = scsi_sense_code_ascq(code);
if (desc) {
buf[0] = 0x72; /* descriptor, current */
buf[1] = key;
@ -297,7 +303,7 @@ void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq)
buf[13] = ascq;
}
}
EXPORT_SYMBOL(scsi_build_sense_buffer);
EXPORT_SYMBOL(scsi_set_sense_buffer);
/**
* scsi_set_sense_information - set the information field in a

332
drivers/scsi/scsi_debug.c
View File

@ -68,9 +68,6 @@ static const char *sdebug_version_date = "20210520";
#define MY_NAME "scsi_debug"
/* Additional Sense Code Qualifier (ASCQ) */
#define ACK_NAK_TO 0x3
/* Default values for driver parameters */
#define DEF_NUM_HOST 1
#define DEF_NUM_TGTS 1
@ -1410,9 +1407,13 @@ static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
sdev_printk(KERN_ERR, scp->device, "sense_buffer is NULL\n");
return;
}
asc = c_d ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST;
if (c_d)
asc = ASC_INVALID_FIELD_IN_CDB;
else
asc = ASC_INVALID_FIELD_IN_PARAMETER_LIST;
memset(sbuff, 0, SCSI_SENSE_BUFFERSIZE);
scsi_build_sense(scp, sdebug_dsense, ILLEGAL_REQUEST, asc, 0);
scsi_set_sense(scp, sdebug_dsense, ILLEGAL_REQUEST,
scsi_sense_code(asc, 0));
memset(sks, 0, sizeof(sks));
sks[0] = 0x80;
if (c_d)
@ -1436,7 +1437,7 @@ static void mk_sense_invalid_fld(struct scsi_cmnd *scp,
my_name, asc, c_d ? 'C' : 'D', in_byte, in_bit);
}
static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
static void mk_sense_buffer(struct scsi_cmnd *scp, u8 key, u16 code)
{
if (!scp->sense_buffer) {
sdev_printk(KERN_ERR, scp->device, "sense_buffer is NULL\n");
@ -1444,16 +1445,16 @@ static void mk_sense_buffer(struct scsi_cmnd *scp, int key, int asc, int asq)
}
memset(scp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
scsi_build_sense(scp, sdebug_dsense, key, asc, asq);
scsi_set_sense(scp, sdebug_dsense, key, code);
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
my_name, key, asc, asq);
"%s: [sense_key,sense_code]: [0x%02x,0x%04x]\n",
my_name, key, code);
}
/* Sense data that has information fields for tapes */
static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
static void mk_sense_info_tape(struct scsi_cmnd *scp, u8 key, u16 code,
unsigned int information, unsigned char tape_flags)
{
if (!scp->sense_buffer) {
@ -1462,7 +1463,7 @@ static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
}
memset(scp->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
scsi_build_sense(scp, /* sdebug_dsense */ 0, key, asc, asq);
scsi_set_sense(scp, /* sdebug_dsense */ 0, key, code);
/* only fixed format so far */
scp->sense_buffer[0] |= 0x80; /* valid */
@ -1471,13 +1472,13 @@ static void mk_sense_info_tape(struct scsi_cmnd *scp, int key, int asc, int asq,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: [sense_key,asc,ascq]: [0x%x,0x%x,0x%x]\n",
my_name, key, asc, asq);
"%s: [sense_key,sense_code]: [0x%02x,0x%04x]\n",
my_name, key, code);
}
static void mk_sense_invalid_opcode(struct scsi_cmnd *scp)
{
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_OPCODE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_COMMAND_OP_CODE);
}
static int scsi_debug_ioctl(struct scsi_device *dev, unsigned int cmd,
@ -1574,46 +1575,43 @@ static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
switch (k) {
case SDEBUG_UA_POR:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
POWER_ON_RESET_ASCQ);
mk_sense_buffer(scp, UNIT_ATTENTION,
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED);
if (sdebug_verbose)
cp = "power on reset";
break;
case SDEBUG_UA_POOCCUR:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
POWER_ON_OCCURRED_ASCQ);
mk_sense_buffer(scp, UNIT_ATTENTION, POWER_ON_OCCURRED);
if (sdebug_verbose)
cp = "power on occurred";
break;
case SDEBUG_UA_BUS_RESET:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_RESET_ASC,
BUS_RESET_ASCQ);
mk_sense_buffer(scp, UNIT_ATTENTION,
SCSI_BUS_RESET_OCCURRED);
if (sdebug_verbose)
cp = "bus reset";
break;
case SDEBUG_UA_MODE_CHANGED:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
MODE_CHANGED_ASCQ);
mk_sense_buffer(scp, UNIT_ATTENTION,
MODE_PARAMETERS_CHANGED);
if (sdebug_verbose)
cp = "mode parameters changed";
break;
case SDEBUG_UA_CAPACITY_CHANGED:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_CHANGED_ASC,
CAPACITY_CHANGED_ASCQ);
mk_sense_buffer(scp, UNIT_ATTENTION,
CAPACITY_DATA_HAS_CHANGED);
if (sdebug_verbose)
cp = "capacity data changed";
break;
case SDEBUG_UA_MICROCODE_CHANGED:
mk_sense_buffer(scp, UNIT_ATTENTION,
TARGET_CHANGED_ASC,
MICROCODE_CHANGED_ASCQ);
MICROCODE_HAS_BEEN_CHANGED);
if (sdebug_verbose)
cp = "microcode has been changed";
break;
case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
mk_sense_buffer(scp, UNIT_ATTENTION,
TARGET_CHANGED_ASC,
MICROCODE_CHANGED_WO_RESET_ASCQ);
MICROCODE_HAS_BEEN_CHANGED_WITHOUT_RESET);
if (sdebug_verbose)
cp = "microcode has been changed without reset";
break;
@ -1629,14 +1627,13 @@ static int make_ua(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (sdebug_scsi_level >= 6) /* SPC-4 and above */
clear_luns_changed_on_target(devip);
mk_sense_buffer(scp, UNIT_ATTENTION,
TARGET_CHANGED_ASC,
LUNS_CHANGED_ASCQ);
REPORTED_LUNS_DATA_HAS_CHANGED);
if (sdebug_verbose)
cp = "reported luns data has changed";
break;
case SDEBUG_UA_NOT_READY_TO_READY:
mk_sense_buffer(scp, UNIT_ATTENTION, UA_READY_ASC,
0);
mk_sense_buffer(scp, UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED);
if (sdebug_verbose)
cp = "not ready to ready transition/media change";
break;
@ -2274,14 +2271,14 @@ static int resp_requests(struct scsi_cmnd *scp,
if (dsense) {
arr[0] = 0x72;
arr[1] = NOT_READY;
arr[2] = LOGICAL_UNIT_NOT_READY;
arr[2] = ASC_LU_NOT_READY;
arr[3] = (stopped_state == 2) ? 0x1 : 0x2;
len = 8;
} else {
arr[0] = 0x70;
arr[2] = NOT_READY; /* NO_SENSE in sense_key */
arr[7] = 0xa; /* 18 byte sense buffer */
arr[12] = LOGICAL_UNIT_NOT_READY;
arr[12] = ASC_LU_NOT_READY;
arr[13] = (stopped_state == 2) ? 0x1 : 0x2;
}
} else if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
@ -2289,14 +2286,14 @@ static int resp_requests(struct scsi_cmnd *scp,
if (dsense) {
arr[0] = 0x72;
arr[1] = 0x0; /* NO_SENSE in sense_key */
arr[2] = THRESHOLD_EXCEEDED;
arr[2] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[3] = 0xff; /* Failure prediction(false) */
len = 8;
} else {
arr[0] = 0x70;
arr[2] = 0x0; /* NO_SENSE in sense_key */
arr[7] = 0xa; /* 18 byte sense buffer */
arr[12] = THRESHOLD_EXCEEDED;
arr[12] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[13] = 0xff; /* Failure prediction(false) */
}
} else { /* nothing to report */
@ -2547,8 +2544,7 @@ static int resp_rsup_opcodes(struct scsi_cmnd *scp,
a_len = alloc_len;
arr = kzalloc((a_len < 256) ? 320 : a_len + 64, GFP_ATOMIC);
if (NULL == arr) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
INSUFF_RES_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
switch (reporting_opts) {
@ -3014,8 +3010,9 @@ static int resp_mode_sense(struct scsi_cmnd *scp,
else
bd_len = 0;
alloc_len = msense_6 ? cmd[4] : get_unaligned_be16(cmd + 7);
if (0x3 == pcontrol) { /* Saving values not supported */
mk_sense_buffer(scp, ILLEGAL_REQUEST, SAVING_PARAMS_UNSUP, 0);
if (0x3 == pcontrol) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
SAVING_PARAMETERS_NOT_SUPPORTED);
return check_condition_result;
}
target_dev_id = ((devip->sdbg_host->shost->host_no + 1) * 2000) +
@ -3264,7 +3261,7 @@ static int resp_mode_select(struct scsi_cmnd *scp,
(arr[off + 1] + 2);
if ((pg_len + off) > param_len) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERR, 0);
PARAMETER_LIST_LENGTH_ERROR);
return check_condition_result;
}
switch (mpage) {
@ -3346,7 +3343,7 @@ static int resp_ie_l_pg(unsigned char *arr)
memcpy(arr, ie_l_pg, sizeof(ie_l_pg));
if (iec_m_pg[2] & 0x4) { /* TEST bit set */
arr[4] = THRESHOLD_EXCEEDED;
arr[4] = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
arr[5] = 0xff;
}
return sizeof(ie_l_pg);
@ -3503,7 +3500,8 @@ static int resp_locate(struct scsi_cmnd *scp,
break;
if (i < pos) {
devip->tape_location[partition] = i;
mk_sense_buffer(scp, BLANK_CHECK, 0x05, 0);
mk_sense_buffer(scp, BLANK_CHECK,
LU_DOES_NOT_RESPOND_TO_SELECTION);
return check_condition_result;
}
devip->tape_location[partition] = pos;
@ -3528,8 +3526,9 @@ static int resp_write_filemarks(struct scsi_cmnd *scp,
for (i = 0, pos = devip->tape_location[partition]; i < count; i++, pos++) {
if (pos >= devip->tape_eop[partition] - 1) { /* don't overwrite EOD */
devip->tape_location[partition] = devip->tape_eop[partition] - 1;
mk_sense_info_tape(scp, VOLUME_OVERFLOW, NO_ADDITIONAL_SENSE,
EOP_EOM_DETECTED_ASCQ, count, SENSE_FLAG_EOM);
mk_sense_info_tape(scp, VOLUME_OVERFLOW,
END_OF_PARTITION_MEDIUM_DETECTED,
count, SENSE_FLAG_EOM);
return check_condition_result;
}
(devip->tape_blocks[partition] + pos)->fl_size = data;
@ -3630,31 +3629,28 @@ static int resp_space(struct scsi_cmnd *scp,
is_fm:
devip->tape_location[partition] = pos;
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
FILEMARK_DETECTED_ASCQ, count - i,
SENSE_FLAG_FILEMARK);
mk_sense_info_tape(scp, NO_SENSE, FILEMARK_DETECTED,
count - i, SENSE_FLAG_FILEMARK);
return check_condition_result;
is_eod:
devip->tape_location[partition] = pos;
mk_sense_info_tape(scp, BLANK_CHECK, NO_ADDITIONAL_SENSE,
EOD_DETECTED_ASCQ, count - i,
0);
mk_sense_info_tape(scp, BLANK_CHECK, END_OF_DATA_DETECTED,
count - i, 0);
return check_condition_result;
is_bop:
devip->tape_location[partition] = 0;
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
BEGINNING_OF_P_M_DETECTED_ASCQ, count - i,
SENSE_FLAG_EOM);
mk_sense_info_tape(scp, NO_SENSE,
BEGINNING_OF_PARTITION_MEDIUM_DETECTED,
count - i, SENSE_FLAG_EOM);
devip->tape_location[partition] = 0;
return check_condition_result;
is_eop:
devip->tape_location[partition] = devip->tape_eop[partition] - 1;
mk_sense_info_tape(scp, MEDIUM_ERROR, NO_ADDITIONAL_SENSE,
EOP_EOM_DETECTED_ASCQ, (unsigned int)i,
SENSE_FLAG_EOM);
mk_sense_info_tape(scp, MEDIUM_ERROR, END_OF_PARTITION_MEDIUM_DETECTED,
(unsigned int)i, SENSE_FLAG_EOM);
return check_condition_result;
}
@ -3942,8 +3938,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* For host-managed, reads cannot cross zone types boundaries */
if (zsp->z_type != zsp_end->z_type) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LBA_OUT_OF_RANGE,
READ_INVDATA_ASCQ);
ATTEMPT_TO_READ_INVALID_DATA);
return check_condition_result;
}
return 0;
@ -3951,8 +3946,8 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* Writing into a gap zone is not allowed */
if (zbc_zone_is_gap(zsp)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE,
ATTEMPT_ACCESS_GAP);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
ATTEMPT_TO_ACCESS_GAP_ZONE);
return check_condition_result;
}
@ -3960,8 +3955,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
if (zbc_zone_is_conv(zsp)) {
if (!zbc_zone_is_conv(zsp_end)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LBA_OUT_OF_RANGE,
WRITE_BOUNDARY_ASCQ);
WRITE_BOUNDARY_VIOLATION);
return check_condition_result;
}
return 0;
@ -3971,21 +3965,19 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
/* Writes cannot cross sequential zone boundaries */
if (zsp_end != zsp) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LBA_OUT_OF_RANGE,
WRITE_BOUNDARY_ASCQ);
WRITE_BOUNDARY_VIOLATION);
return check_condition_result;
}
/* Cannot write full zones */
if (zsp->z_cond == ZC5_FULL) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB, 0);
INVALID_FIELD_IN_CDB);
return check_condition_result;
}
/* Writes must be aligned to the zone WP */
if (lba != zsp->z_wp) {
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LBA_OUT_OF_RANGE,
UNALIGNED_WRITE_ASCQ);
UNALIGNED_WRITE_COMMAND);
return check_condition_result;
}
}
@ -3995,8 +3987,7 @@ static int check_zbc_access_params(struct scsi_cmnd *scp,
if (devip->max_open &&
devip->nr_exp_open >= devip->max_open) {
mk_sense_buffer(scp, DATA_PROTECT,
INSUFF_RES_ASC,
INSUFF_ZONE_ASCQ);
INSUFFICIENT_ZONE_RESOURCES);
return check_condition_result;
}
zbc_open_zone(devip, zsp, false);
@ -4013,17 +4004,18 @@ static inline int check_device_access_params
struct sdebug_dev_info *devip = (struct sdebug_dev_info *)sdp->hostdata;
if (lba + num > sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
/* transfer length excessive (tie in to block limits VPD page) */
if (num > sdebug_store_sectors) {
/* needs work to find which cdb byte 'num' comes from */
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
if (write && unlikely(sdebug_wp)) {
mk_sense_buffer(scp, DATA_PROTECT, WRITE_PROTECTED, 0x2);
mk_sense_buffer(scp, DATA_PROTECT, LU_SOFTWARE_WRITE_PROTECTED);
return check_condition_result;
}
if (sdebug_dev_is_zoned(devip))
@ -4532,17 +4524,17 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
i++, pos++, blp++) {
devip->tape_location[partition] = pos + 1;
if (IS_TAPE_BLOCK_FM(blp->fl_size)) {
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
FILEMARK_DETECTED_ASCQ, fixed ? num - i : size,
SENSE_FLAG_FILEMARK);
mk_sense_info_tape(scp, NO_SENSE, FILEMARK_DETECTED,
fixed ? num - i : size,
SENSE_FLAG_FILEMARK);
scsi_set_resid(scp, (num - i) * size);
return check_condition_result;
}
/* Assume no REW */
if (IS_TAPE_BLOCK_EOD(blp->fl_size)) {
mk_sense_info_tape(scp, BLANK_CHECK, NO_ADDITIONAL_SENSE,
EOD_DETECTED_ASCQ, fixed ? num - i : size,
0);
mk_sense_info_tape(scp, BLANK_CHECK,
END_OF_DATA_DETECTED,
fixed ? num - i : size, 0);
devip->tape_location[partition] = pos;
scsi_set_resid(scp, (num - i) * size);
return check_condition_result;
@ -4554,9 +4546,9 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (fixed) {
if (blp->fl_size != devip->tape_blksize) {
scsi_set_resid(scp, (num - i) * size);
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
0, num - i,
SENSE_FLAG_ILI);
mk_sense_info_tape(scp, NO_SENSE,
NO_ADDITIONAL_SENSE_INFORMATION,
num - i, SENSE_FLAG_ILI);
return check_condition_result;
}
} else {
@ -4564,18 +4556,19 @@ static int resp_read_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (blp->fl_size < size)
scsi_set_resid(scp, size - blp->fl_size);
if (!sili) {
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
0, size - blp->fl_size,
SENSE_FLAG_ILI);
mk_sense_info_tape(scp, NO_SENSE,
NO_ADDITIONAL_SENSE_INFORMATION,
size - blp->fl_size,
SENSE_FLAG_ILI);
return check_condition_result;
}
}
}
}
if (pos >= devip->tape_eop[partition]) {
mk_sense_info_tape(scp, NO_SENSE, NO_ADDITIONAL_SENSE,
EOP_EOM_DETECTED_ASCQ, fixed ? num - i : size,
SENSE_FLAG_EOM);
mk_sense_info_tape(scp, NO_SENSE,
END_OF_PARTITION_MEDIUM_DETECTED,
fixed ? num - i : size, SENSE_FLAG_EOM);
devip->tape_location[partition] = pos - 1;
return check_condition_result;
}
@ -4662,8 +4655,7 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((SDEBUG_OPT_MEDIUM_ERR & sdebug_opts) &&
(lba <= (sdebug_medium_error_start + sdebug_medium_error_count - 1)) &&
((lba + num) > sdebug_medium_error_start))) {
/* claim unrecoverable read error */
mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERR, 0);
mk_sense_buffer(scp, MEDIUM_ERROR, UNRECOVERED_READ_ERROR);
/* set info field and valid bit for fixed descriptor */
if (0x70 == (scp->sense_buffer[0] & 0x7f)) {
scp->sense_buffer[0] |= 0x80; /* Valid bit */
@ -4687,22 +4679,26 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
case 1: /* Guard tag error */
if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
sdeb_meta_read_unlock(sip);
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return check_condition_result;
} else if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
sdeb_meta_read_unlock(sip);
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return illegal_condition_result;
}
break;
case 3: /* Reference tag error */
if (cmd[1] >> 5 != 3) { /* RDPROTECT != 3 */
sdeb_meta_read_unlock(sip);
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return check_condition_result;
} else if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
sdeb_meta_read_unlock(sip);
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return illegal_condition_result;
}
break;
@ -4720,16 +4716,18 @@ static int resp_read_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
mk_sense_buffer(scp, RECOVERED_ERROR,
FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
return check_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
/* Logical block guard check failed */
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
} else if (SDEBUG_OPT_DIX_ERR & sdebug_opts) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
}
@ -4936,16 +4934,14 @@ static int resp_write_tape(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
blp->fl_size = TAPE_BLOCK_EOD_FLAG;
if (pos >= devip->tape_eop[partition] - 1) {
mk_sense_info_tape(scp, VOLUME_OVERFLOW,
NO_ADDITIONAL_SENSE, EOP_EOM_DETECTED_ASCQ,
fixed ? num - i : transfer,
SENSE_FLAG_EOM);
END_OF_PARTITION_MEDIUM_DETECTED,
fixed ? num - i : transfer, SENSE_FLAG_EOM);
return check_condition_result;
}
if (ew) { /* early warning */
mk_sense_info_tape(scp, NO_SENSE,
NO_ADDITIONAL_SENSE, EOP_EOM_DETECTED_ASCQ,
fixed ? num - i : transfer,
SENSE_FLAG_EOM);
END_OF_PARTITION_MEDIUM_DETECTED,
fixed ? num - i : transfer, SENSE_FLAG_EOM);
return check_condition_result;
}
@ -5043,8 +5039,7 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely(sdebug_opts & SDEBUG_OPT_UNALIGNED_WRITE &&
atomic_read(&sdeb_inject_pending))) {
atomic_set(&sdeb_inject_pending, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE,
UNALIGNED_WRITE_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST, UNALIGNED_WRITE_COMMAND);
return check_condition_result;
}
@ -5125,22 +5120,26 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
case 1: /* Guard tag error */
if (scp->prot_flags & SCSI_PROT_GUARD_CHECK) {
sdeb_meta_write_unlock(sip);
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return illegal_condition_result;
} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
sdeb_meta_write_unlock(sip);
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
return check_condition_result;
}
break;
case 3: /* Reference tag error */
if (scp->prot_flags & SCSI_PROT_REF_CHECK) {
sdeb_meta_write_unlock(sip);
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 3);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return illegal_condition_result;
} else if (scp->cmnd[1] >> 5 != 3) { /* WRPROTECT != 3 */
sdeb_meta_write_unlock(sip);
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 3);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
return check_condition_result;
}
break;
@ -5168,16 +5167,18 @@ static int resp_write_dt0(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
mk_sense_buffer(scp, RECOVERED_ERROR,
FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
return check_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
/* Logical block guard check failed */
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
return illegal_condition_result;
}
@ -5240,7 +5241,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: LB Data Offset field bad\n", my_name);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return illegal_condition_result;
}
lbdof_blen = lbdof * lb_size;
@ -5248,7 +5249,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (sdebug_verbose)
sdev_printk(KERN_INFO, scp->device,
"%s: LBA range descriptors don't fit\n", my_name);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return illegal_condition_result;
}
lrdp = kzalloc(lbdof_blen, GFP_ATOMIC | __GFP_NOWARN);
@ -5289,8 +5290,7 @@ static int resp_write_scat(struct scsi_cmnd *scp,
sdev_printk(KERN_INFO, scp->device,
"%s: sum of blocks > data provided\n",
my_name);
mk_sense_buffer(scp, ILLEGAL_REQUEST, WRITE_ERROR_ASC,
0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, SSC_WRITE_ERROR);
ret = illegal_condition_result;
goto err_out_unlock;
}
@ -5301,8 +5301,9 @@ static int resp_write_scat(struct scsi_cmnd *scp,
ei_lba);
if (prot_ret) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10,
prot_ret);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
scsi_sense_code(ASC_ID_CRC_OR_ECC_ERROR,
prot_ret));
ret = illegal_condition_result;
goto err_out_unlock;
}
@ -5329,18 +5330,20 @@ static int resp_write_scat(struct scsi_cmnd *scp,
if (unlikely((sdebug_opts & SDEBUG_OPT_RECOV_DIF_DIX) &&
atomic_read(&sdeb_inject_pending))) {
if (sdebug_opts & SDEBUG_OPT_RECOVERED_ERR) {
mk_sense_buffer(scp, RECOVERED_ERROR, THRESHOLD_EXCEEDED, 0);
mk_sense_buffer(scp, RECOVERED_ERROR,
FAILURE_PREDICTION_THRESHOLD_EXCEEDED);
atomic_set(&sdeb_inject_pending, 0);
ret = check_condition_result;
goto err_out_unlock;
} else if (sdebug_opts & SDEBUG_OPT_DIF_ERR) {
/* Logical block guard check failed */
mk_sense_buffer(scp, ABORTED_COMMAND, 0x10, 1);
mk_sense_buffer(scp, ABORTED_COMMAND,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
ret = illegal_condition_result;
goto err_out_unlock;
} else if (sdebug_opts & SDEBUG_OPT_DIX_ERR) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, 0x10, 1);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
atomic_set(&sdeb_inject_pending, 0);
ret = illegal_condition_result;
goto err_out_unlock;
@ -5559,8 +5562,7 @@ static int resp_comp_write(struct scsi_cmnd *scp,
dnum = 2 * num;
arr = kcalloc(lb_size, dnum, GFP_ATOMIC);
if (NULL == arr) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
INSUFF_RES_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@ -5576,7 +5578,8 @@ static int resp_comp_write(struct scsi_cmnd *scp,
sdeb_data_write_lock(sip);
sdeb_meta_write_lock(sip);
if (!comp_write_worker(sip, lba, num, arr, false)) {
mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
mk_sense_buffer(scp, MISCOMPARE,
MISCOMPARE_DURING_VERIFY_OPERATION);
retval = check_condition_result;
goto cleanup_unlock;
}
@ -5619,8 +5622,7 @@ static int resp_unmap(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
buf = kzalloc(scsi_bufflen(scp), GFP_ATOMIC);
if (!buf) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
INSUFF_RES_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@ -5758,7 +5760,8 @@ static int resp_sync_cache(struct scsi_cmnd *scp,
num_blocks = get_unaligned_be32(cmd + 10);
}
if (lba + num_blocks > sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
if (!write_since_sync || (cmd[1] & 0x2))
@ -5796,7 +5799,8 @@ static int resp_pre_fetch(struct scsi_cmnd *scp,
nblks = get_unaligned_be32(cmd + 10);
}
if (lba + nblks > sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
if (!fsp)
@ -5967,8 +5971,7 @@ static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
arr = kcalloc(lb_size, vnum, GFP_ATOMIC | __GFP_NOWARN);
if (!arr) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
INSUFF_RES_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFFICIENT_RESOURCES);
return check_condition_result;
}
/* Not changing store, so only need read access */
@ -5989,7 +5992,8 @@ static int resp_verify(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
}
ret = 0;
if (!comp_write_worker(sip, lba, vnum, arr, true)) {
mk_sense_buffer(scp, MISCOMPARE, MISCOMPARE_VERIFY_ASC, 0);
mk_sense_buffer(scp, MISCOMPARE,
MISCOMPARE_DURING_VERIFY_OPERATION);
ret = check_condition_result;
goto cleanup;
}
@ -6028,7 +6032,8 @@ static int resp_report_zones(struct scsi_cmnd *scp,
partial = cmd[14] & 0x80;
if (zs_lba >= sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return check_condition_result;
}
@ -6039,8 +6044,8 @@ static int resp_report_zones(struct scsi_cmnd *scp,
arr = kzalloc(arr_len, GFP_ATOMIC | __GFP_NOWARN);
if (!arr) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
INSUFF_RES_ASCQ);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
INSUFFICIENT_RESOURCES);
return check_condition_result;
}
@ -6105,8 +6110,7 @@ static int resp_report_zones(struct scsi_cmnd *scp,
continue;
break;
default:
mk_sense_buffer(scp, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
ret = check_condition_result;
goto fini;
}
@ -6171,13 +6175,13 @@ static int resp_atomic_write(struct scsi_cmnd *scp,
if (sdebug_atomic_wr_align &&
do_div(lba_tmp, sdebug_atomic_wr_align)) {
/* Does not meet alignment requirement */
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
if (sdebug_atomic_wr_gran && len % sdebug_atomic_wr_gran) {
/* Does not meet alignment requirement */
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return check_condition_result;
}
@ -6238,8 +6242,8 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
/* Check if all closed zones can be open */
if (devip->max_open &&
devip->nr_exp_open + devip->nr_closed > devip->max_open) {
mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
INSUFF_ZONE_ASCQ);
mk_sense_buffer(scp, DATA_PROTECT,
INSUFFICIENT_ZONE_RESOURCES);
res = check_condition_result;
goto fini;
}
@ -6251,19 +6255,20 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
/* Open the specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@ -6273,8 +6278,7 @@ static int resp_open_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
goto fini;
if (devip->max_open && devip->nr_exp_open >= devip->max_open) {
mk_sense_buffer(scp, DATA_PROTECT, INSUFF_RES_ASC,
INSUFF_ZONE_ASCQ);
mk_sense_buffer(scp, DATA_PROTECT, INSUFFICIENT_ZONE_RESOURCES);
res = check_condition_result;
goto fini;
}
@ -6318,19 +6322,20 @@ static int resp_close_zone(struct scsi_cmnd *scp,
/* Close specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@ -6390,19 +6395,20 @@ static int resp_finish_zone(struct scsi_cmnd *scp,
/* Finish the specified zone */
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@ -6469,19 +6475,20 @@ static int resp_rwp_zone(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
z_id = get_unaligned_be64(cmd + 2);
if (z_id >= sdebug_capacity) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, LBA_OUT_OF_RANGE, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
res = check_condition_result;
goto fini;
}
zsp = zbc_zone(devip, z_id);
if (z_id != zsp->z_start) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
if (zbc_zone_is_conv(zsp)) {
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB, 0);
mk_sense_buffer(scp, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
res = check_condition_result;
goto fini;
}
@ -7354,7 +7361,7 @@ static int schedule_resp(struct scsi_cmnd *cmnd, struct sdebug_dev_info *devip,
cmnd->result = scsi_result;
if (cmnd->result == 0 && unlikely(sdebug_opts & SDEBUG_OPT_TRANSPORT_ERR)) {
if (atomic_read(&sdeb_inject_pending)) {
mk_sense_buffer(cmnd, ABORTED_COMMAND, TRANSPORT_PROBLEM, ACK_NAK_TO);
mk_sense_buffer(cmnd, ABORTED_COMMAND, ACK_NAK_TIMEOUT);
atomic_set(&sdeb_inject_pending, 0);
cmnd->result = check_condition_result;
}
@ -9147,7 +9154,8 @@ static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
return 0;
}
}
mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x1);
mk_sense_buffer(scp, NOT_READY,
LU_IS_IN_PROCESS_OF_BECOMING_READY);
if (sdebug_verbose)
sdev_printk(KERN_INFO, sdp,
"%s: Not ready: in process of becoming ready\n", my_name);
@ -9165,7 +9173,8 @@ static int resp_not_ready(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
return check_condition_result;
}
}
mk_sense_buffer(scp, NOT_READY, LOGICAL_UNIT_NOT_READY, 0x2);
mk_sense_buffer(scp, NOT_READY,
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED);
if (sdebug_verbose)
sdev_printk(KERN_INFO, sdp, "%s: Not ready: initializing command required\n",
my_name);
@ -9362,7 +9371,8 @@ static int sdebug_fail_cmd(struct scsi_cmnd *cmnd, int *retval,
out_handle:
if (err->cnt < 0)
err->cnt++;
mk_sense_buffer(cmnd, err->sense_key, err->asc, err->asq);
mk_sense_buffer(cmnd, err->sense_key,
scsi_sense_code(err->asc, err->asq));
result = err->status_byte | err->host_byte << 16 | err->driver_byte << 24;
*info = *err;
*retval = schedule_resp(cmnd, devip, result, NULL, 0, 0);

94
drivers/scsi/scsi_error.c
View File

@ -490,24 +490,27 @@ static void scsi_report_sense(struct scsi_device *sdev,
enum scsi_device_event evt_type = SDEV_EVT_MAXBITS; /* i.e. none */
if (sshdr->sense_key == UNIT_ATTENTION) {
if (sshdr->asc == 0x3f && sshdr->ascq == 0x03) {
if (sshdr->sense_code == INQUIRY_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_INQUIRY_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Inquiry data has changed");
} else if (sshdr->asc == 0x3f && sshdr->ascq == 0x0e) {
} else if (sshdr->sense_code == REPORTED_LUNS_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_LUN_CHANGE_REPORTED;
scsi_report_lun_change(sdev);
sdev_printk(KERN_WARNING, sdev,
"LUN assignments on this target have "
"changed. The Linux SCSI layer does not "
"automatically remap LUN assignments.\n");
} else if (sshdr->asc == 0x3f)
} else if (scsi_sense_asc(sshdr) ==
ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED) {
sdev_printk(KERN_WARNING, sdev,
"Operating parameters on this target have "
"changed. The Linux SCSI layer does not "
"automatically adjust these parameters.\n");
}
if (sshdr->asc == 0x38 && sshdr->ascq == 0x07) {
if (sshdr->sense_code ==
THIN_PROVISIONING_SOFT_THRESHOLD_REACHED) {
evt_type = SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Warning! Received an indication that the "
@ -515,7 +518,8 @@ static void scsi_report_sense(struct scsi_device *sdev,
"threshold.\n");
}
if (sshdr->asc == 0x29) {
if (scsi_sense_asc(sshdr) ==
ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED) {
evt_type = SDEV_EVT_POWER_ON_RESET_OCCURRED;
/*
* Do not print message if it is an expected side-effect
@ -526,21 +530,22 @@ static void scsi_report_sense(struct scsi_device *sdev,
"Power-on or device reset occurred\n");
}
if (sshdr->asc == 0x2a && sshdr->ascq == 0x01) {
if (sshdr->sense_code == MODE_PARAMETERS_CHANGED) {
evt_type = SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Mode parameters changed");
} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x06) {
} else if (sshdr->sense_code == ASYMMETRIC_ACCESS_STATE_CHANGED) {
evt_type = SDEV_EVT_ALUA_STATE_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Asymmetric access state changed");
} else if (sshdr->asc == 0x2a && sshdr->ascq == 0x09) {
} else if (sshdr->sense_code == CAPACITY_DATA_HAS_CHANGED) {
evt_type = SDEV_EVT_CAPACITY_CHANGE_REPORTED;
sdev_printk(KERN_WARNING, sdev,
"Capacity data has changed");
} else if (sshdr->asc == 0x2a)
} else if (scsi_sense_asc(sshdr) == ASC_PARAMETERS_CHANGED) {
sdev_printk(KERN_WARNING, sdev,
"Parameters changed");
}
}
if (evt_type != SDEV_EVT_MAXBITS) {
@ -582,9 +587,11 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* that all ULDs interested in these can see that those have
* happened, even if someone else gets the sense data.
*/
if (sshdr.asc == 0x28)
if (scsi_sense_asc(&sshdr) ==
ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED)
atomic_inc(&sdev->ua_new_media_ctr);
else if (sshdr.asc == 0x29)
else if (scsi_sense_asc(&sshdr) ==
ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
atomic_inc(&sdev->ua_por_ctr);
}
@ -636,7 +643,8 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
return /* soft_error */ SUCCESS;
case ABORTED_COMMAND:
if (sshdr.asc == 0x10) /* DIF */
if (scsi_sense_asc(&sshdr) == ASC_ID_CRC_OR_ECC_ERROR)
/* DIF */
return SUCCESS;
/*
@ -647,18 +655,20 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY
* additional sense code qualifiers.
*/
if (sshdr.asc == 0x2e &&
sshdr.ascq >= 0x01 && sshdr.ascq <= 0x03) {
if (sshdr.sense_code >= COMMAND_TIMEOUT_BEFORE_PROCESSING &&
sshdr.sense_code <=
COMMAND_TIMEOUT_DURING_PROCESSING_DUE_TO_ERROR_RECOVERY) {
set_scsi_ml_byte(scmd, SCSIML_STAT_DL_TIMEOUT);
req->cmd_flags |= REQ_FAILFAST_DEV;
req->rq_flags |= RQF_QUIET;
return SUCCESS;
}
if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF)
if ((sdev->sdev_bflags & BLIST_RETRY_ITF) &&
scsi_sense_asc(&sshdr) == ASC_INTERNAL_TARGET_FAILURE)
return ADD_TO_MLQUEUE;
if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
sdev->sdev_bflags & BLIST_RETRY_ASC_C1)
if ((sdev->sdev_bflags & BLIST_RETRY_ASC_C1) &&
sshdr.sense_code == scsi_sense_code(0xc1, 0x01))
return ADD_TO_MLQUEUE;
return NEEDS_RETRY;
@ -672,12 +682,13 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
*/
if (scmd->device->expecting_cc_ua) {
/*
* Because some device does not queue unit
* attentions correctly, we carefully check
* additional sense code and qualifier so as
* not to squash media change unit attention.
* Because some devices do not queue unit attentions
* correctly, we carefully check additional sense code
* and qualifier so as not to squash media change unit
* attention.
*/
if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
if (sshdr.sense_code !=
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
scmd->device->expecting_cc_ua = 0;
return NEEDS_RETRY;
}
@ -688,21 +699,23 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* REPORTED LUNS DATA HAS CHANGED.
*/
if (scmd->device->sdev_target->expecting_lun_change &&
sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
sshdr.sense_code == REPORTED_LUNS_DATA_HAS_CHANGED)
return NEEDS_RETRY;
/*
* if the device is in the process of becoming ready, we
* should retry.
*/
if ((sshdr.asc == 0x04) &&
(sshdr.ascq == 0x01 || sshdr.ascq == 0x0a))
if (sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY ||
sshdr.sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION)
return NEEDS_RETRY;
/*
* if the device is not started, we need to wake
* the error handler to start the motor
*/
if (scmd->device->allow_restart &&
(sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
sshdr.sense_code ==
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return FAILED;
/*
* Pass the UA upwards for a determination in the completion
@ -712,7 +725,7 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
/* these are not supported */
case DATA_PROTECT:
if (sshdr.asc == 0x27 && sshdr.ascq == 0x07) {
if (sshdr.sense_code == SPACE_ALLOCATION_FAILED_WRITE_PROTECT) {
/* Thin provisioning hard threshold reached */
set_scsi_ml_byte(scmd, SCSIML_STAT_NOSPC);
return SUCCESS;
@ -726,11 +739,14 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
return SUCCESS;
case MEDIUM_ERROR:
if (sshdr.asc == 0x11 || /* UNRECOVERED READ ERR */
sshdr.asc == 0x13 || /* AMNF DATA FIELD */
sshdr.asc == 0x14) { /* RECORD NOT FOUND */
switch (scsi_sense_asc(&sshdr)) {
case ASC_UNRECOVERED_READ_ERROR:
case ASC_ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD:
case ASC_RECORDED_ENTITY_NOT_FOUND:
set_scsi_ml_byte(scmd, SCSIML_STAT_MED_ERROR);
return SUCCESS;
default:
break;
}
return NEEDS_RETRY;
@ -742,13 +758,17 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
fallthrough;
case ILLEGAL_REQUEST:
if (sshdr.asc == 0x20 || /* Invalid command operation code */
sshdr.asc == 0x21 || /* Logical block address out of range */
sshdr.asc == 0x22 || /* Invalid function */
sshdr.asc == 0x24 || /* Invalid field in cdb */
sshdr.asc == 0x26 || /* Parameter value invalid */
sshdr.asc == 0x27) { /* Write protected */
switch (scsi_sense_asc(&sshdr)) {
case ASC_INVALID_COMMAND_OP_CODE:
case ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE:
case ASC_ILLEGAL_FUNCTION:
case ASC_INVALID_FIELD_IN_CDB:
case ASC_INVALID_FIELD_IN_PARAMETER_LIST:
case ASC_WRITE_PROTECTED:
set_scsi_ml_byte(scmd, SCSIML_STAT_TGT_FAILURE);
break;
default:
break;
}
return SUCCESS;
@ -760,7 +780,7 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
* that the command was in fact aborted because it exceeded its
* duration limit. Never retry these commands.
*/
if (sshdr.asc == 0x55 && sshdr.ascq == 0x0a) {
if (sshdr.sense_code == DATA_CURRENTLY_UNAVAILABLE) {
set_scsi_ml_byte(scmd, SCSIML_STAT_DL_TIMEOUT);
req->cmd_flags |= REQ_FAILFAST_DEV;
req->rq_flags |= RQF_QUIET;

3
drivers/scsi/scsi_ioctl.c
View File

@ -96,7 +96,8 @@ static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
"ioctl_internal_command: "
"ILLEGAL REQUEST "
"asc=0x%x ascq=0x%x\n",
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
break;
case NOT_READY: /* This happens if there is no disc in drive */
if (sdev->removable)

133
drivers/scsi/scsi_lib.c
View File

@ -243,23 +243,23 @@ static int scsi_check_passthrough(struct scsi_cmnd *scmd,
continue;
if (status_byte(failure->result) != SAM_STAT_CHECK_CONDITION ||
failure->sense == SCMD_FAILURE_SENSE_ANY)
failure->sense_key == SCMD_FAILURE_SENSE_KEY_ANY)
goto maybe_retry;
if (!scsi_command_normalize_sense(scmd, &sshdr))
return 0;
if (failure->sense != sshdr.sense_key)
if (failure->sense_key != sshdr.sense_key)
continue;
if (failure->asc == SCMD_FAILURE_ASC_ANY)
if (scsi_failure_asc(failure) == SCMD_FAILURE_ASC_ANY)
goto maybe_retry;
if (failure->asc != sshdr.asc)
if (scsi_failure_asc(failure) != scsi_sense_asc(&sshdr))
continue;
if (failure->ascq == SCMD_FAILURE_ASCQ_ANY ||
failure->ascq == sshdr.ascq)
if (scsi_failure_ascq(failure) == SCMD_FAILURE_ASCQ_ANY ||
scsi_failure_ascq(failure) == scsi_sense_ascq(&sshdr))
goto maybe_retry;
}
@ -839,6 +839,8 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
*/
action = ACTION_RETRY;
} else if (sense_valid && sense_current) {
u8 asc = scsi_sense_asc(&sshdr);
switch (sshdr.sense_key) {
case UNIT_ATTENTION:
if (cmd->device->removable) {
@ -865,64 +867,72 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
* where READ CAPACITY failed, we may have
* read past the end of the disk.
*/
if ((cmd->device->use_10_for_rw &&
sshdr.asc == 0x20 && sshdr.ascq == 0x00) &&
if (cmd->device->use_10_for_rw &&
sshdr.sense_code == INVALID_COMMAND_OP_CODE &&
(cmd->cmnd[0] == READ_10 ||
cmd->cmnd[0] == WRITE_10)) {
/* This will issue a new 6-byte command. */
cmd->device->use_10_for_rw = 0;
action = ACTION_REPREP;
} else if (sshdr.asc == 0x10) /* DIX */ {
break;
}
if (asc == ASC_ID_CRC_OR_ECC_ERROR) {
/* DIX */
action = ACTION_FAIL;
blk_stat = BLK_STS_PROTECTION;
/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
} else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
break;
}
if (asc == ASC_INVALID_COMMAND_OP_CODE ||
asc == ASC_INVALID_FIELD_IN_CDB) {
action = ACTION_FAIL;
blk_stat = BLK_STS_TARGET;
} else
action = ACTION_FAIL;
break;
}
action = ACTION_FAIL;
break;
case ABORTED_COMMAND:
action = ACTION_FAIL;
if (sshdr.asc == 0x10) /* DIF */
if (asc == ASC_ID_CRC_OR_ECC_ERROR) /* DIF */
blk_stat = BLK_STS_PROTECTION;
break;
case NOT_READY:
/* If the device is in the process of becoming
* ready, or has a temporary blockage, retry.
*/
if (sshdr.asc == 0x04) {
switch (sshdr.ascq) {
case 0x01: /* becoming ready */
case 0x04: /* format in progress */
case 0x05: /* rebuild in progress */
case 0x06: /* recalculation in progress */
case 0x07: /* operation in progress */
case 0x08: /* Long write in progress */
case 0x09: /* self test in progress */
case 0x11: /* notify (enable spinup) required */
case 0x14: /* space allocation in progress */
case 0x1a: /* start stop unit in progress */
case 0x1b: /* sanitize in progress */
case 0x1d: /* configuration in progress */
action = ACTION_DELAYED_RETRY;
break;
case 0x0a: /* ALUA state transition */
action = ACTION_DELAYED_REPREP;
break;
/*
* Depopulation might take many hours,
* thus it is not worthwhile to retry.
*/
case 0x24: /* depopulation in progress */
case 0x25: /* depopulation restore in progress */
fallthrough;
default:
action = ACTION_FAIL;
break;
}
} else
if (asc != ASC_LU_NOT_READY) {
action = ACTION_FAIL;
break;
}
switch (sshdr.sense_code) {
case LU_IS_IN_PROCESS_OF_BECOMING_READY:
case LU_NOT_READY_FORMAT_IN_PROGRESS:
case LU_NOT_READY_REBUILD_IN_PROGRESS:
case LU_NOT_READY_RECALCULATION_IN_PROGRESS:
case LU_NOT_READY_OP_IN_PROGRESS:
case LU_NOT_READY_LONG_WRITE_IN_PROGRESS:
case LU_NOT_READY_SELFTEST_IN_PROGRESS:
case LU_NOT_READY_NOTIFY_REQUIRED:
case LU_NOT_READY_SPACE_ALLOCATION_IN_PROGRESS:
case LU_NOT_READY_START_STOP_UNIT_COMMAND_IN_PROGRESS:
case LU_NOT_READY_SANITIZE_IN_PROGRESS:
case LU_NOT_READY_CONFIG_IN_PROGRESS:
action = ACTION_DELAYED_RETRY;
break;
case LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION:
action = ACTION_DELAYED_REPREP;
break;
/*
* Depopulation might take many hours, thus it is not
* worthwhile to retry.
*/
case DEPOPULATION_IN_PROGRESS:
case DEPOPULATION_RESTORATION_IN_PROGRESS:
fallthrough;
default:
action = ACTION_FAIL;
break;
}
break;
case VOLUME_OVERFLOW:
/* See SSC3rXX or current. */
@ -930,11 +940,14 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
break;
case DATA_PROTECT:
action = ACTION_FAIL;
if ((sshdr.asc == 0x0C && sshdr.ascq == 0x12) ||
(sshdr.asc == 0x55 &&
(sshdr.ascq == 0x0E || sshdr.ascq == 0x0F))) {
/* Insufficient zone resources */
switch (sshdr.sense_code) {
case WRITE_ERROR_INSUFFICIENT_ZONE_RESOURCES:
case INSUFFICIENT_ZONE_RESOURCES:
case INSUFFICIENT_ZONE_RESOURCES_TO_COMPLETE_WRITE:
blk_stat = BLK_STS_ZONE_OPEN_RESOURCE;
break;
default:
break;
}
break;
case COMPLETED:
@ -1041,7 +1054,7 @@ static int scsi_io_completion_nz_result(struct scsi_cmnd *cmd, int result,
* skip print since caller wants ATA registers. Only occurs
* on SCSI ATA PASS_THROUGH commands when CK_COND=1
*/
if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
if (sshdr.sense_code == ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
do_print = false;
else if (req->rq_flags & RQF_QUIET)
do_print = false;
@ -2372,9 +2385,8 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage,
struct scsi_sense_hdr my_sshdr;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = retries,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -2432,8 +2444,8 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage,
if (!scsi_status_is_good(result)) {
if (scsi_sense_valid(sshdr)) {
if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
(sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
if (sshdr->sense_key == ILLEGAL_REQUEST &&
sshdr->sense_code == INVALID_COMMAND_OP_CODE) {
/*
* Invalid command operation code: retry using
* MODE SENSE(6) if this was a MODE SENSE(10)
@ -3573,21 +3585,20 @@ int scsi_vpd_tpg_id(struct scsi_device *sdev, int *rel_id)
EXPORT_SYMBOL(scsi_vpd_tpg_id);
/**
* scsi_build_sense - build sense data for a command
* scsi_set_sense - build sense data for a command
* @scmd: scsi command for which the sense should be formatted
* @desc: Sense format (non-zero == descriptor format,
* 0 == fixed format)
* @key: Sense key
* @asc: Additional sense code
* @ascq: Additional sense code qualifier
* @code: Additional sense code and sense code qualifier
*
**/
void scsi_build_sense(struct scsi_cmnd *scmd, int desc, u8 key, u8 asc, u8 ascq)
void scsi_set_sense(struct scsi_cmnd *scmd, int desc, u8 key, u16 code)
{
scsi_build_sense_buffer(desc, scmd->sense_buffer, key, asc, ascq);
scsi_set_sense_buffer(desc, scmd->sense_buffer, key, code);
scmd->result = SAM_STAT_CHECK_CONDITION;
}
EXPORT_SYMBOL_GPL(scsi_build_sense);
EXPORT_SYMBOL_GPL(scsi_set_sense);
#ifdef CONFIG_SCSI_LIB_KUNIT_TEST
#include "scsi_lib_test.c"

95
drivers/scsi/scsi_lib_test.c
View File

@ -17,42 +17,43 @@ static void scsi_lib_test_multiple_sense(struct kunit *test)
{
struct scsi_failure multiple_sense_failure_defs[] = {
{
.sense = DATA_PROTECT,
.asc = 0x1,
.ascq = 0x1,
.sense_key = DATA_PROTECT,
.sense_code =
scsi_sense_code(ASC_NO_INDEX_SECTOR_SIGNAL,
0x1),
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = UNIT_ATTENTION,
.asc = 0x11,
.ascq = 0x0,
.sense_key = UNIT_ATTENTION,
.sense_code = UNRECOVERED_READ_ERROR,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = NOT_READY,
.asc = 0x11,
.ascq = 0x22,
.sense_key = NOT_READY,
.sense_code =
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR,
0x22),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = ABORTED_COMMAND,
.asc = 0x11,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = ABORTED_COMMAND,
.sense_code =
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR,
SCMD_FAILURE_ASCQ_ANY),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = HARDWARE_ERROR,
.asc = SCMD_FAILURE_ASC_ANY,
.sense_key = HARDWARE_ERROR,
.sense_code = scsi_sense_code(SCMD_FAILURE_ASC_ANY, 0),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = ILLEGAL_REQUEST,
.asc = 0x91,
.ascq = 0x36,
.sense_key = ILLEGAL_REQUEST,
.sense_code = scsi_sense_code(0x91, 0x36),
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -72,32 +73,36 @@ static void scsi_lib_test_multiple_sense(struct kunit *test)
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
/* Command failed but caller did not pass in a failures array */
scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
scsi_set_sense(&sc, 0, ILLEGAL_REQUEST, scsi_sense_code(0x91, 0x36));
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
/* Match end of array */
scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
scsi_set_sense(&sc, 0, ILLEGAL_REQUEST, scsi_sense_code(0x91, 0x36));
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
/* Basic match in array */
scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x11, 0x0);
scsi_set_sense(&sc, 0, UNIT_ATTENTION, UNRECOVERED_READ_ERROR);
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
/* No matching sense entry */
scsi_build_sense(&sc, 0, MISCOMPARE, 0x11, 0x11);
scsi_set_sense(&sc, 0, MISCOMPARE, READ_ERROR_LOSS_OF_STREAMING);
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
/* Match using SCMD_FAILURE_ASCQ_ANY */
scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x11, 0x22);
scsi_set_sense(&sc, 0, ABORTED_COMMAND,
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR, 0x22));
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
/* Fail to match */
scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x22, 0x22);
scsi_set_sense(&sc, 0, ABORTED_COMMAND,
scsi_sense_code(ASC_ILLEGAL_FUNCTION, 0x22));
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
/* Match using SCMD_FAILURE_ASC_ANY */
scsi_build_sense(&sc, 0, HARDWARE_ERROR, 0x11, 0x22);
scsi_set_sense(&sc, 0, HARDWARE_ERROR,
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR, 0x22));
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
/* No matching status entry */
sc.result = SAM_STAT_RESERVATION_CONFLICT;
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
/* Test hitting allowed limit */
scsi_build_sense(&sc, 0, NOT_READY, 0x11, 0x22);
scsi_set_sense(&sc, 0, NOT_READY,
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR, 0x22));
for (i = 0; i < SCSI_LIB_TEST_MAX_ALLOWED; i++)
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
&failures));
@ -108,7 +113,8 @@ static void scsi_lib_test_multiple_sense(struct kunit *test)
scsi_failures_reset_retries(&failures);
/* Test no retries allowed */
scsi_build_sense(&sc, 0, DATA_PROTECT, 0x1, 0x1);
scsi_set_sense(&sc, 0, DATA_PROTECT,
scsi_sense_code(ASC_NO_INDEX_SECTOR_SIGNAL, 0x1));
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
}
@ -116,8 +122,9 @@ static void scsi_lib_test_any_sense(struct kunit *test)
{
struct scsi_failure any_sense_failure_defs[] = {
{
.result = SCMD_FAILURE_SENSE_ANY,
.sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
.result = SAM_STAT_CHECK_CONDITION,
},
{}
};
@ -129,9 +136,10 @@ static void scsi_lib_test_any_sense(struct kunit *test)
.sense_buffer = sense,
};
/* Match using SCMD_FAILURE_SENSE_ANY */
/* Match using SCMD_FAILURE_SENSE_KEY_ANY */
failures.failure_definitions = any_sense_failure_defs;
scsi_build_sense(&sc, 0, MEDIUM_ERROR, 0x11, 0x22);
scsi_set_sense(&sc, 0, MEDIUM_ERROR,
scsi_sense_code(ASC_UNRECOVERED_READ_ERROR, 0x22));
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
}
@ -215,14 +223,13 @@ static void scsi_lib_test_total_allowed(struct kunit *test)
{
struct scsi_failure total_allowed_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
{
.sense = SCMD_FAILURE_SENSE_ANY,
.sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry any other errors not listed above */
@ -245,7 +252,8 @@ static void scsi_lib_test_total_allowed(struct kunit *test)
scsi_failures_reset_retries(&failures);
failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;
scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
scsi_set_sense(&sc, 0, UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED);
for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
/* Retry since we under the total_allowed limit */
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
@ -259,13 +267,15 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
{
struct scsi_failure mixed_total_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = 0x28,
.sense_key = UNIT_ATTENTION,
.sense_code =
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = UNIT_ATTENTION,
.asc = 0x29,
.sense_key = UNIT_ATTENTION,
.sense_code =
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
@ -291,7 +301,8 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
scsi_failures_reset_retries(&failures);
failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;
scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
scsi_set_sense(&sc, 0, UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED);
for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
/* Retry since we under the total_allowed limit */
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
@ -300,7 +311,8 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
scsi_failures_reset_retries(&failures);
scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
scsi_set_sense(&sc, 0, UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED);
for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
/* Retry since we under the total_allowed limit */
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
@ -308,7 +320,8 @@ static void scsi_lib_test_mixed_total(struct kunit *test)
sc.result = DID_TIME_OUT << 16;
/* Retry because this failure has a per failure limit */
KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x29, 0x0);
scsi_set_sense(&sc, 0, UNIT_ATTENTION,
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED);
/* total_allowed is now hit so no more retries */
KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
}

22
drivers/scsi/scsi_logging.c
View File

@ -238,29 +238,32 @@ EXPORT_SYMBOL(scsi_print_command);
static size_t
scsi_format_extd_sense(char *buffer, size_t buf_len,
unsigned char asc, unsigned char ascq)
const struct scsi_sense_hdr *sshdr)
{
size_t off = 0;
const char *extd_sense_fmt = NULL;
const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
&extd_sense_fmt);
const char *extd_sense_str =
scsi_extd_sense_format(sshdr, &extd_sense_fmt);
if (extd_sense_str) {
off = scnprintf(buffer, buf_len, "Add. Sense: %s",
extd_sense_str);
if (extd_sense_fmt)
off += scnprintf(buffer + off, buf_len - off,
"(%s%x)", extd_sense_fmt, ascq);
"(%s%x)", extd_sense_fmt,
scsi_sense_ascq(sshdr));
} else {
if (asc >= 0x80)
if (scsi_sense_asc(sshdr) >= 0x80)
off = scnprintf(buffer, buf_len, "<<vendor>>");
off += scnprintf(buffer + off, buf_len - off,
"ASC=0x%x ", asc);
if (ascq >= 0x80)
"ASC=0x%x ",
scsi_sense_asc(sshdr));
if (scsi_sense_ascq(sshdr) >= 0x80)
off += scnprintf(buffer + off, buf_len - off,
"<<vendor>>");
off += scnprintf(buffer + off, buf_len - off,
"ASCQ=0x%x ", ascq);
"ASCQ=0x%x ",
scsi_sense_ascq(sshdr));
}
return off;
}
@ -333,8 +336,7 @@ scsi_log_print_sense_hdr(const struct scsi_device *sdev, const char *name,
if (!logbuf)
return;
off = sdev_format_header(logbuf, logbuf_len, name, tag);
off += scsi_format_extd_sense(logbuf + off, logbuf_len - off,
sshdr->asc, sshdr->ascq);
off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, sshdr);
dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
scsi_log_release_buffer(logbuf);
}

22
drivers/scsi/scsi_scan.c
View File

@ -652,19 +652,18 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
int pass, count, result, resid;
struct scsi_failure failure_defs[] = {
/*
* not-ready to ready transition [asc/ascq=0x28/0x0] or
* power-on, reset [asc/ascq=0x29/0x0], continue. INQUIRY
* should not yield UNIT_ATTENTION but many buggy devices do
* so anyway.
* not-ready to ready transition or power-on, reset, continue.
* INQUIRY should not yield UNIT_ATTENTION but many buggy
* devices do so anyway.
*/
{
.sense = UNIT_ATTENTION,
.asc = 0x28,
.sense_key = UNIT_ATTENTION,
.sense_code = NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = UNIT_ATTENTION,
.asc = 0x29,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
@ -1457,14 +1456,13 @@ static int scsi_report_lun_scan(struct Scsi_Host *shost,
struct scsi_device *sdev;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Fail all CCs except the UA above */
{
.sense = SCMD_FAILURE_SENSE_ANY,
.sense_key = SCMD_FAILURE_SENSE_KEY_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry any other errors not listed above */

12
drivers/scsi/scsi_transport_spi.c
View File

@ -112,9 +112,8 @@ static int spi_execute(struct scsi_device *sdev, const void *cmd,
REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = DV_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -680,10 +679,9 @@ spi_dv_device_echo_buffer(struct scsi_device *sdev, u8 *buffer,
if (result || !scsi_device_online(sdev)) {
scsi_device_set_state(sdev, SDEV_QUIESCE);
if (result > 0 && scsi_sense_valid(&sshdr)
&& sshdr.sense_key == ILLEGAL_REQUEST
/* INVALID FIELD IN CDB */
&& sshdr.asc == 0x24 && sshdr.ascq == 0x00)
if (result > 0 && scsi_sense_valid(&sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
sshdr.sense_code == INVALID_FIELD_IN_CDB)
/* This would mean that the drive lied
* to us about supporting an echo
* buffer (unfortunately some Western

126
drivers/scsi/sd.c
View File

@ -1786,8 +1786,7 @@ static int media_not_present(struct scsi_disk *sdkp,
switch (sshdr->sense_key) {
case UNIT_ATTENTION:
case NOT_READY:
/* medium not present */
if (sshdr->asc == 0x3A) {
if (scsi_sense_asc(sshdr) == ASC_MEDIUM_NOT_PRESENT) {
set_media_not_present(sdkp);
return 1;
}
@ -1911,12 +1910,14 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
if (scsi_status_is_check_condition(res) &&
scsi_sense_valid(&sshdr)) {
u8 asc = scsi_sense_asc(&sshdr);
sd_print_sense_hdr(sdkp, &sshdr);
/* we need to evaluate the error return */
if (sshdr.asc == 0x3a || /* medium not present */
sshdr.asc == 0x20 || /* invalid command */
(sshdr.asc == 0x74 && sshdr.ascq == 0x71)) /* drive is password locked */
if (asc == ASC_MEDIUM_NOT_PRESENT ||
asc == ASC_INVALID_COMMAND_OP_CODE ||
sshdr.sense_code == LU_ACCESS_NOT_AUTHORIZED)
/* this is no error here */
return 0;
@ -1926,8 +1927,8 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
* this is called during shutdown or suspend so just
* return success so those operations can proceed.
*/
if ((sshdr.asc == 0x04 && sshdr.ascq == 0x04) ||
sshdr.sense_key == ILLEGAL_REQUEST)
if (sshdr.sense_key == ILLEGAL_REQUEST ||
sshdr.sense_code == LU_NOT_READY_FORMAT_IN_PROGRESS)
return 0;
}
@ -2015,7 +2016,9 @@ static int sd_scsi_to_pr_err(struct scsi_sense_hdr *sshdr, int result)
return PR_STS_IOERR;
if (sshdr->sense_key == ILLEGAL_REQUEST &&
(sshdr->asc == 0x26 || sshdr->asc == 0x24))
(scsi_sense_asc(sshdr) ==
ASC_INVALID_FIELD_IN_PARAMETER_LIST ||
scsi_sense_asc(sshdr) == ASC_INVALID_FIELD_IN_CDB))
return -EINVAL;
fallthrough;
@ -2033,9 +2036,8 @@ static int sd_pr_in_command(struct block_device *bdev, u8 sa,
u8 cmd[10] = { PERSISTENT_RESERVE_IN, sa };
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 5,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -2145,9 +2147,8 @@ static int sd_pr_out_command(struct block_device *bdev, u8 sa, u64 key,
struct scsi_sense_hdr sshdr;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 5,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -2440,16 +2441,17 @@ static int sd_done(struct scsi_cmnd *SCpnt)
memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
break;
case ABORTED_COMMAND:
if (sshdr.asc == 0x10) /* DIF: Target detected corruption */
if (scsi_sense_asc(&sshdr) == ASC_ID_CRC_OR_ECC_ERROR) /* DIF */
good_bytes = sd_completed_bytes(SCpnt);
break;
case ILLEGAL_REQUEST:
switch (sshdr.asc) {
case 0x10: /* DIX: Host detected corruption */
switch (scsi_sense_asc(&sshdr)) {
case ASC_ID_CRC_OR_ECC_ERROR:
/* DIX */
good_bytes = sd_completed_bytes(SCpnt);
break;
case 0x20: /* INVALID COMMAND OPCODE */
case 0x24: /* INVALID FIELD IN CDB */
case ASC_INVALID_COMMAND_OP_CODE:
case ASC_INVALID_FIELD_IN_CDB:
switch (SCpnt->cmnd[0]) {
case UNMAP:
sd_disable_discard(sdkp);
@ -2494,15 +2496,15 @@ sd_spinup_disk(struct scsi_disk *sdkp)
struct scsi_failure failure_defs[] = {
/* Do not retry Medium Not Present */
{
.sense = UNIT_ATTENTION,
.asc = 0x3A,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code =
MEDIUM_NOT_PRESENT | SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = NOT_READY,
.asc = 0x3A,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = NOT_READY,
.sense_code =
MEDIUM_NOT_PRESENT | SCMD_FAILURE_ASCQ_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Retry when scsi_status_is_good would return false 3 times */
@ -2566,18 +2568,18 @@ sd_spinup_disk(struct scsi_disk *sdkp)
break;
if (sense_valid && sshdr.sense_key == NOT_READY) {
if (sshdr.asc == 4 && sshdr.ascq == 3)
break; /* manual intervention required */
if (sshdr.asc == 4 && sshdr.ascq == 0xb)
break; /* standby */
if (sshdr.asc == 4 && sshdr.ascq == 0xc)
break; /* unavailable */
if (sshdr.asc == 4 && sshdr.ascq == 0x1b)
break; /* sanitize in progress */
if (sshdr.asc == 4 && sshdr.ascq == 0x24)
break; /* depopulation in progress */
if (sshdr.asc == 4 && sshdr.ascq == 0x25)
break; /* depopulation restoration in progress */
switch (sshdr.sense_code) {
case LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED:
case LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE:
case LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE:
case LU_NOT_READY_SANITIZE_IN_PROGRESS:
case DEPOPULATION_IN_PROGRESS:
case DEPOPULATION_RESTORATION_IN_PROGRESS:
goto out;
default:
break;
}
/*
* Issue command to spin up drive when not ready
*/
@ -2608,8 +2610,9 @@ sd_spinup_disk(struct scsi_disk *sdkp)
* occur here. It's characteristic of these devices.
*/
} else if (sense_valid &&
sshdr.sense_key == UNIT_ATTENTION &&
sshdr.asc == 0x28) {
sshdr.sense_key == UNIT_ATTENTION &&
scsi_sense_asc(&sshdr) ==
ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
if (!spintime) {
spintime_expire = jiffies + 5 * HZ;
spintime = 1;
@ -2628,6 +2631,7 @@ sd_spinup_disk(struct scsi_disk *sdkp)
} while (spintime && time_before_eq(jiffies, spintime_expire));
out:
if (spintime) {
if (scsi_status_is_good(the_result))
printk(KERN_CONT "ready\n");
@ -2753,15 +2757,14 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
sense_valid = scsi_sense_valid(&sshdr);
if (sense_valid &&
sshdr.sense_key == ILLEGAL_REQUEST &&
(sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
sshdr.ascq == 0x00)
/* Invalid Command Operation Code or
* Invalid Field in CDB, just retry
* silently with RC10 */
(sshdr.sense_code == INVALID_COMMAND_OP_CODE ||
sshdr.sense_code == INVALID_FIELD_IN_CDB))
/* Just retry silently with RC10 */
return -EINVAL;
if (sense_valid &&
sshdr.sense_key == UNIT_ATTENTION &&
sshdr.asc == 0x29 && sshdr.ascq == 0x00)
sshdr.sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/* Device reset might occur several times,
* give it one more chance */
if (--reset_retries > 0)
@ -2817,19 +2820,19 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
struct scsi_failure failure_defs[] = {
/* Do not retry Medium Not Present */
{
.sense = UNIT_ATTENTION,
.asc = 0x3A,
.sense_key = UNIT_ATTENTION,
.sense_code = MEDIUM_NOT_PRESENT,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = NOT_READY,
.asc = 0x3A,
.sense_key = NOT_READY,
.sense_code = MEDIUM_NOT_PRESENT,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Device reset might occur several times so retry a lot */
{
.sense = UNIT_ATTENTION,
.asc = 0x29,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.allowed = READ_CAPACITY_RETRIES_ON_RESET,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -3258,8 +3261,7 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
bad_sense:
if (res == -EIO && scsi_sense_valid(&sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
sshdr.asc == 0x24 && sshdr.ascq == 0x0)
/* Invalid field in CDB */
sshdr.sense_code == INVALID_FIELD_IN_CDB)
sd_first_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
else
sd_first_printk(KERN_ERR, sdkp,
@ -4159,23 +4161,20 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
struct scsi_failure failure_defs[] = {
{
/* Power on, reset, or bus device reset occurred */
.sense = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 0,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* Power on occurred */
.sense = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 1,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{
/* SCSI bus reset */
.sense = UNIT_ATTENTION,
.asc = 0x29,
.ascq = 2,
.sense_key = UNIT_ATTENTION,
.sense_code = SCSI_BUS_RESET_OCCURRED,
.result = SAM_STAT_CHECK_CONDITION,
},
{}
@ -4207,8 +4206,7 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
sd_print_result(sdkp, "Start/Stop Unit failed", res);
if (res > 0 && scsi_sense_valid(&sshdr)) {
sd_print_sense_hdr(sdkp, &sshdr);
/* 0x3a is medium not present */
if (sshdr.asc == 0x3a)
if (scsi_sense_asc(&sshdr) == ASC_MEDIUM_NOT_PRESENT)
res = 0;
}
}

2
drivers/scsi/sd_zbc.c
View File

@ -369,7 +369,7 @@ unsigned int sd_zbc_complete(struct scsi_cmnd *cmd, unsigned int good_bytes,
if (op_is_zone_mgmt(req_op(rq)) &&
result &&
sshdr->sense_key == ILLEGAL_REQUEST &&
sshdr->asc == 0x24) {
scsi_sense_asc(sshdr) == ASC_INVALID_FIELD_IN_CDB) {
/*
* INVALID FIELD IN CDB error: a zone management command was
* attempted on a conventional zone. Nothing to worry about,

2352
drivers/scsi/sense_codes.h
View File

File diff suppressed because it is too large Load Diff

23
drivers/scsi/ses.c
View File

@ -72,6 +72,9 @@ static void init_device_slot_control(unsigned char *dest_desc,
dest_desc[3] &= 0x3c;
}
#define POWER_ON_RESET_ANY \
scsi_sense_code(ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED, \
SCMD_FAILURE_ASCQ_ANY)
static int ses_recv_diag(struct scsi_device *sdev, int page_code,
void *buf, int bufflen)
@ -88,16 +91,14 @@ static int ses_recv_diag(struct scsi_device *sdev, int page_code,
unsigned char recv_page_code;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = 0x29,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_RESET_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = NOT_READY,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = NOT_READY,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -145,16 +146,14 @@ static int ses_send_diag(struct scsi_device *sdev, int page_code,
};
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = 0x29,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = POWER_ON_RESET_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = NOT_READY,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = NOT_READY,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SES_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},

31
drivers/scsi/smartpqi/smartpqi_init.c
View File

@ -3249,15 +3249,15 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
sense_data_length = sizeof(error_info->data);
if (scsi_status == SAM_STAT_CHECK_CONDITION &&
scsi_normalize_sense(error_info->data,
sense_data_length, &sshdr) &&
sshdr.sense_key == HARDWARE_ERROR &&
sshdr.asc == 0x3e) {
scsi_normalize_sense(error_info->data,
sense_data_length, &sshdr) &&
sshdr.sense_key == HARDWARE_ERROR &&
scsi_sense_asc(&sshdr) == ASC_LU_HAS_NOT_SELF_CONFIGURED_YET) {
struct pqi_ctrl_info *ctrl_info = shost_to_hba(scmd->device->host);
struct pqi_scsi_dev *device = scmd->device->hostdata;
switch (sshdr.ascq) {
case 0x1: /* LOGICAL UNIT FAILURE */
switch (sshdr.sense_code) {
case LU_FAILURE:
if (printk_ratelimit())
scmd_printk(KERN_ERR, scmd, "received 'logical unit failure' from controller for scsi %d:%d:%d:%d\n",
ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
@ -3265,10 +3265,15 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
host_byte = DID_NO_CONNECT;
break;
default: /* See http://www.t10.org/lists/asc-num.htm#ASC_3E */
default:
/* include/scsi/scsi_sense.h */
if (printk_ratelimit())
scmd_printk(KERN_ERR, scmd, "received unhandled error %d from controller for scsi %d:%d:%d:%d\n",
sshdr.ascq, ctrl_info->scsi_host->host_no, device->bus, device->target, device->lun);
scmd_printk(KERN_ERR, scmd,
"received unhandled error %d from controller for scsi %d:%d:%d:%d\n",
scsi_sense_ascq(&sshdr),
ctrl_info->scsi_host->host_no,
device->bus, device->target,
device->lun);
break;
}
}
@ -3286,11 +3291,11 @@ static void pqi_process_raid_io_error(struct pqi_io_request *io_request)
sense_data_length &&
scsi_normalize_sense(error_info->data, sense_data_length, &sshdr) &&
sshdr.sense_key == ILLEGAL_REQUEST &&
sshdr.asc == 0x26 &&
sshdr.ascq == 0x0) {
sshdr.sense_code == INVALID_FIELD_IN_PARAMETER_LIST) {
host_byte = DID_NO_CONNECT;
pqi_take_device_offline(scmd->device, "AIO");
scsi_build_sense_buffer(0, scmd->sense_buffer, HARDWARE_ERROR, 0x3e, 0x1);
scsi_set_sense_buffer(0, scmd->sense_buffer, HARDWARE_ERROR,
LU_FAILURE);
}
scmd->result = scsi_status;
@ -3380,7 +3385,7 @@ static void pqi_process_aio_io_error(struct pqi_io_request *io_request)
}
if (device_offline && sense_data_length == 0)
scsi_build_sense(scmd, 0, HARDWARE_ERROR, 0x3e, 0x1);
scsi_set_sense(scmd, 0, HARDWARE_ERROR, LU_FAILURE);
scmd->result = scsi_status;
set_host_byte(scmd, host_byte);

3
drivers/scsi/sr.c
View File

@ -253,7 +253,8 @@ static unsigned int sr_check_events(struct cdrom_device_info *cdi,
* (ASC 0x3a).
*/
cd->media_present = scsi_status_is_good(ret) ||
(scsi_sense_valid(&sshdr) && sshdr.asc != 0x3a);
(scsi_sense_valid(&sshdr) &&
scsi_sense_asc(&sshdr) != ASC_MEDIUM_NOT_PRESENT);
if (last_present != cd->media_present)
cd->device->changed = 1;

29
drivers/scsi/sr_ioctl.c
View File

@ -226,9 +226,8 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
err = -ENOMEDIUM;
break;
case NOT_READY: /* This happens if there is no disc in drive */
if (sshdr->asc == 0x04 &&
sshdr->ascq == 0x01) {
/* sense: Logical unit is in process of becoming ready */
if (sshdr->sense_code ==
LU_IS_IN_PROCESS_OF_BECOMING_READY) {
if (!cgc->quiet)
sr_printk(KERN_INFO, cd,
"CDROM not ready yet.\n");
@ -250,9 +249,7 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
break;
case ILLEGAL_REQUEST:
err = -EIO;
if (sshdr->asc == 0x20 &&
sshdr->ascq == 0x00)
/* sense: Invalid command operation code */
if (sshdr->sense_code == INVALID_COMMAND_OP_CODE)
err = -EDRIVE_CANT_DO_THIS;
break;
default:
@ -303,9 +300,8 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
if (!scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr))
return CDS_DISC_OK;
/* SK/ASC/ASCQ of 2/4/1 means "unit is becoming ready" */
if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY
&& sshdr.asc == 0x04 && sshdr.ascq == 0x01)
if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY &&
sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY)
return CDS_DRIVE_NOT_READY;
if (!cdrom_get_media_event(cdi, &med)) {
@ -318,18 +314,18 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
}
/*
* SK/ASC/ASCQ of 2/4/2 means "initialization required"
* Using CD_TRAY_OPEN results in an START_STOP_UNIT to close
* the tray, which resolves the initialization requirement.
*/
if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY
&& sshdr.asc == 0x04 && sshdr.ascq == 0x02)
if (scsi_sense_valid(&sshdr) && sshdr.sense_key == NOT_READY &&
sshdr.sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return CDS_TRAY_OPEN;
/*
* 0x04 is format in progress .. but there must be a disc present!
*/
if (sshdr.sense_key == NOT_READY && sshdr.asc == 0x04)
if (sshdr.sense_key == NOT_READY &&
scsi_sense_asc(&sshdr) == ASC_LU_NOT_READY)
return CDS_DISC_OK;
/*
@ -338,13 +334,10 @@ int sr_drive_status(struct cdrom_device_info *cdi, int slot)
* any other way to detect this...
*/
if (scsi_sense_valid(&sshdr) &&
/* 0x3a is medium not present */
sshdr.asc == 0x3a)
scsi_sense_asc(&sshdr) == ASC_MEDIUM_NOT_PRESENT)
return CDS_NO_DISC;
else
return CDS_TRAY_OPEN;
return CDS_DRIVE_NOT_READY;
return CDS_TRAY_OPEN;
}
int sr_disk_status(struct cdrom_device_info *cdi)

35
drivers/scsi/st.c
View File

@ -421,11 +421,13 @@ static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
STp->cln_sense_mask) != 0);
}
if (cmdstatp->have_sense &&
cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
cmdstatp->sense_hdr.sense_code == CLEANING_REQUESTED)
STp->cleaning_req = 1;
if (cmdstatp->have_sense && scode == UNIT_ATTENTION &&
cmdstatp->sense_hdr.asc == 0x29 && !STp->pos_unknown) {
STp->pos_unknown = 1; /* ASC => power on / reset */
scsi_sense_asc(&cmdstatp->sense_hdr) ==
ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED &&
!STp->pos_unknown) {
STp->pos_unknown = 1;
st_printk(KERN_WARNING, STp, "Power on/reset recognized.");
}
@ -1003,7 +1005,8 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
scode = cmdstatp->sense_hdr.sense_key;
if (scode == UNIT_ATTENTION) { /* New media? */
if (cmdstatp->sense_hdr.asc == 0x28) { /* New media */
if (scsi_sense_asc(&cmdstatp->sense_hdr) ==
ASC_NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED) {
new_session = 1;
DEBC_printk(STp, "New tape session.");
}
@ -1026,14 +1029,13 @@ static int test_ready(struct scsi_tape *STp, int do_wait)
waits++;
continue;
}
else {
if ((STp->device)->scsi_level >= SCSI_2 &&
cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
retval = CHKRES_NO_TAPE;
else
retval = CHKRES_NOT_READY;
break;
}
if ((STp->device)->scsi_level >= SCSI_2 &&
scsi_sense_asc(&cmdstatp->sense_hdr) ==
ASC_MEDIUM_NOT_PRESENT)
retval = CHKRES_NO_TAPE;
else
retval = CHKRES_NOT_READY;
break;
}
}
@ -3105,9 +3107,10 @@ static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned lon
cmd_in == MTSETDRVBUFFER ||
cmd_in == SET_DENS_AND_BLK) {
if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
cmdstatp->sense_hdr.asc == 0x24 &&
(STp->device)->scsi_level <= SCSI_2 &&
!(STp->use_pf & PF_TESTED)) {
scsi_sense_asc(&cmdstatp->sense_hdr) ==
ASC_INVALID_FIELD_IN_CDB &&
(STp->device)->scsi_level <= SCSI_2 &&
!(STp->use_pf & PF_TESTED)) {
/* Try the other possible state of Page Format if not
already tried */
STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;

3
drivers/scsi/stex.c
View File

@ -401,8 +401,7 @@ static struct status_msg *stex_get_status(struct st_hba *hba)
static void stex_invalid_field(struct scsi_cmnd *cmd,
void (*done)(struct scsi_cmnd *))
{
/* "Invalid field in cdb" */
scsi_build_sense(cmd, 0, ILLEGAL_REQUEST, 0x24, 0x0);
scsi_set_sense(cmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
done(cmd);
}

15
drivers/scsi/storvsc_drv.c
View File

@ -1016,7 +1016,7 @@ static int storvsc_channel_init(struct hv_device *device, bool is_fc)
static void storvsc_handle_error(struct vmscsi_request *vm_srb,
struct scsi_cmnd *scmnd,
struct Scsi_Host *host,
u8 asc, u8 ascq)
struct scsi_sense_hdr *sshdr)
{
struct storvsc_scan_work *wrk;
void (*process_err_fn)(struct work_struct *work);
@ -1033,7 +1033,7 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb,
case SRB_STATUS_DATA_OVERRUN:
if (vm_srb->srb_status & SRB_STATUS_AUTOSENSE_VALID) {
/* Check for capacity change */
if ((asc == 0x2a) && (ascq == 0x9)) {
if (sshdr->sense_code == CAPACITY_DATA_HAS_CHANGED) {
process_err_fn = storvsc_device_scan;
/* Retry the I/O that triggered this. */
set_host_byte(scmnd, DID_REQUEUE);
@ -1049,8 +1049,12 @@ static void storvsc_handle_error(struct vmscsi_request *vm_srb,
* want scsi_report_sense() to output a message
* that a sysadmin wouldn't know what to do with.
*/
if ((asc == 0x3f) && (ascq != 0x03) &&
(ascq != 0x0e)) {
if (scsi_sense_asc(sshdr) ==
ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED &&
sshdr->sense_code !=
INQUIRY_DATA_HAS_CHANGED &&
sshdr->sense_code !=
REPORTED_LUNS_DATA_HAS_CHANGED) {
process_err_fn = storvsc_device_scan;
set_host_byte(scmnd, DID_REQUEUE);
goto do_work;
@ -1141,8 +1145,7 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request,
}
if (vm_srb->srb_status != SRB_STATUS_SUCCESS) {
storvsc_handle_error(vm_srb, scmnd, host, sense_hdr.asc,
sense_hdr.ascq);
storvsc_handle_error(vm_srb, scmnd, host, &sense_hdr);
/*
* The Windows driver set data_transfer_length on
* SRB_STATUS_DATA_OVERRUN. On other errors, this value

11
drivers/target/target_core_spc.c
View File

@ -1226,9 +1226,9 @@ static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
{
unsigned char *cdb = cmd->t_task_cdb;
unsigned char *rbuf;
u8 ua_asc = 0, ua_ascq = 0;
unsigned char buf[SE_SENSE_BUF];
bool desc_format = target_sense_desc_format(cmd->se_dev);
u16 sense_code = NO_ADDITIONAL_SENSE_INFORMATION;
memset(buf, 0, SE_SENSE_BUF);
@ -1242,11 +1242,12 @@ static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
if (!rbuf)
return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq))
scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION,
ua_asc, ua_ascq);
if (!core_scsi3_ua_clear_for_request_sense(cmd, &sense_code))
scsi_set_sense_buffer(desc_format, buf, UNIT_ATTENTION,
sense_code);
else
scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0);
scsi_set_sense_buffer(desc_format, buf, NO_SENSE,
NO_ADDITIONAL_SENSE_INFORMATION);
memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length));
transport_kunmap_data_sg(cmd);

11
drivers/target/target_core_transport.c
View File

@ -3555,7 +3555,8 @@ static void translate_sense_reason(struct se_cmd *cmd, sense_reason_t reason)
const struct sense_detail *sd;
u8 *buffer = cmd->sense_buffer;
int r = (__force int)reason;
u8 key, asc, ascq;
u16 code;
u8 key;
bool desc_format = target_sense_desc_format(cmd->se_dev);
if (r < ARRAY_SIZE(sense_detail_table) && sense_detail_table[r].key)
@ -3566,21 +3567,19 @@ static void translate_sense_reason(struct se_cmd *cmd, sense_reason_t reason)
key = sd->key;
if (reason == TCM_CHECK_CONDITION_UNIT_ATTENTION) {
if (!core_scsi3_ua_for_check_condition(cmd, &key, &asc,
&ascq)) {
if (!core_scsi3_ua_for_check_condition(cmd, &key, &code)) {
cmd->scsi_status = SAM_STAT_BUSY;
return;
}
} else {
WARN_ON_ONCE(sd->asc == 0);
asc = sd->asc;
ascq = sd->ascq;
code = scsi_sense_code(sd->asc, sd->ascq);
}
cmd->se_cmd_flags |= SCF_EMULATED_TASK_SENSE;
cmd->scsi_status = SAM_STAT_CHECK_CONDITION;
cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER;
scsi_build_sense_buffer(desc_format, buffer, key, asc, ascq);
scsi_set_sense_buffer(desc_format, buffer, key, code);
if (sd->add_sense_info)
WARN_ON_ONCE(scsi_set_sense_information(buffer,
cmd->scsi_sense_length,

28
drivers/target/target_core_ua.c
View File

@ -187,11 +187,10 @@ void core_scsi3_ua_release_all(
/*
* Dequeue a unit attention from the unit attention list. This function
* returns true if the dequeuing succeeded and if *@key, *@asc and *@ascq have
* returns true if the dequeuing succeeded and if *@key and *@code have
* been set.
*/
bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
u8 *ascq)
bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u16 *code)
{
struct se_device *dev = cmd->se_dev;
struct se_dev_entry *deve;
@ -214,8 +213,7 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
if (!deve) {
rcu_read_unlock();
*key = ILLEGAL_REQUEST;
*asc = 0x25; /* LOGICAL UNIT NOT SUPPORTED */
*ascq = 0;
*code = LU_NOT_SUPPORTED;
return true;
}
*key = UNIT_ATTENTION;
@ -232,8 +230,7 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
* clearing it.
*/
if (!dev_ua_intlck_clear) {
*asc = ua->ua_asc;
*ascq = ua->ua_ascq;
*code = scsi_sense_code(ua->ua_asc, ua->ua_ascq);
break;
}
/*
@ -242,8 +239,7 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
* (head of the list) in the outgoing CHECK_CONDITION + sense.
*/
if (head) {
*asc = ua->ua_asc;
*ascq = ua->ua_ascq;
*code = scsi_sense_code(ua->ua_asc, ua->ua_ascq);
head = 0;
}
list_del(&ua->ua_nacl_list);
@ -258,15 +254,13 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
nacl->se_tpg->se_tpg_tfo->fabric_name,
dev_ua_intlck_clear ? "Releasing" : "Reporting",
dev->dev_attrib.emulate_ua_intlck_ctrl,
cmd->orig_fe_lun, cmd->t_task_cdb[0], *asc, *ascq);
cmd->orig_fe_lun, cmd->t_task_cdb[0],
scsi_sense_code_asc(*code), scsi_sense_code_ascq(*code));
return head == 0;
}
int core_scsi3_ua_clear_for_request_sense(
struct se_cmd *cmd,
u8 *asc,
u8 *ascq)
int core_scsi3_ua_clear_for_request_sense(struct se_cmd *cmd, u16 *code)
{
struct se_dev_entry *deve;
struct se_session *sess = cmd->se_sess;
@ -304,8 +298,7 @@ int core_scsi3_ua_clear_for_request_sense(
spin_lock(&deve->ua_lock);
list_for_each_entry_safe(ua, ua_p, &deve->ua_list, ua_nacl_list) {
if (head) {
*asc = ua->ua_asc;
*ascq = ua->ua_ascq;
*code = scsi_sense_code(ua->ua_asc, ua->ua_ascq);
head = 0;
}
list_del(&ua->ua_nacl_list);
@ -317,7 +310,8 @@ int core_scsi3_ua_clear_for_request_sense(
pr_debug("[%s]: Released UNIT ATTENTION condition, mapped"
" LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x,"
" ASCQ: 0x%02x\n", nacl->se_tpg->se_tpg_tfo->fabric_name,
cmd->orig_fe_lun, *asc, *ascq);
cmd->orig_fe_lun, scsi_sense_code_asc(*code),
scsi_sense_code_ascq(*code));
return (head) ? -EPERM : 0;
}

7
drivers/target/target_core_ua.h
View File

@ -37,9 +37,8 @@ extern sense_reason_t target_scsi3_ua_check(struct se_cmd *);
extern int core_scsi3_ua_allocate(struct se_dev_entry *, u8, u8);
extern void target_ua_allocate_lun(struct se_node_acl *, u32, u8, u8);
extern void core_scsi3_ua_release_all(struct se_dev_entry *);
extern bool core_scsi3_ua_for_check_condition(struct se_cmd *, u8 *, u8 *,
u8 *);
extern int core_scsi3_ua_clear_for_request_sense(struct se_cmd *,
u8 *, u8 *);
extern bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key,
u16 *code);
extern int core_scsi3_ua_clear_for_request_sense(struct se_cmd *cmd, u16 *code);
#endif /* TARGET_CORE_UA_H */

6
drivers/ufs/core/ufs-rpmb.c
View File

@ -45,9 +45,9 @@ static int ufs_sec_submit(struct ufs_hba *hba, u16 spsp, void *buffer, size_t le
struct scsi_device *sdev = hba->ufs_rpmb_wlun;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = 0x29, /* power on, reset, or bus device reset occurred */
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code =
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED,
.allowed = UFS_RPMB_UA_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},

34
drivers/usb/gadget/function/f_mass_storage.c
View File

@ -1103,9 +1103,9 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
* FSG normally uses option a); enable this code to use option b).
*/
#if 0
if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
if (curlun && curlun->unit_attention_data != NO_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
curlun->unit_attention_data = NO_SENSE;
}
#endif
@ -1118,18 +1118,18 @@ static int do_request_sense(struct fsg_common *common, struct fsg_buffhd *bh)
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
valid = curlun->info_valid << 7;
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
memset(buf, 0, 18);
buf[0] = valid | 0x70; /* Valid, current error */
buf[2] = SK(sd);
buf[2] = usb_sense_key(sd);
put_unaligned_be32(sdinfo, &buf[3]); /* Sense information */
buf[7] = 18 - 8; /* Additional sense length */
buf[12] = ASC(sd);
buf[13] = ASCQ(sd);
buf[12] = usb_sense_asc(sd);
buf[13] = usb_sense_ascq(sd);
return 18;
}
@ -1678,21 +1678,23 @@ static void send_status(struct fsg_common *common)
if (curlun) {
sd = curlun->sense_data;
sdinfo = curlun->sense_data_info;
} else if (common->bad_lun_okay)
sd = SS_NO_SENSE;
else
} else if (common->bad_lun_okay) {
sd = NO_SENSE;
} else {
sd = SS_LOGICAL_UNIT_NOT_SUPPORTED;
}
if (common->phase_error) {
DBG(common, "sending phase-error status\n");
status = US_BULK_STAT_PHASE;
sd = SS_INVALID_COMMAND;
} else if (sd != SS_NO_SENSE) {
} else if (sd != NO_SENSE) {
DBG(common, "sending command-failure status\n");
status = US_BULK_STAT_FAIL;
VDBG(common, " sense data: SK x%02x, ASC x%02x, ASCQ x%02x;"
" info x%x\n",
SK(sd), ASC(sd), ASCQ(sd), sdinfo);
usb_sense_key(sd), usb_sense_asc(sd),
usb_sense_ascq(sd), sdinfo);
}
/* Store and send the Bulk-only CSW */
@ -1798,7 +1800,7 @@ static int check_command(struct fsg_common *common, int cmnd_size,
curlun = common->curlun;
if (curlun) {
if (common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = SS_NO_SENSE;
curlun->sense_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}
@ -1820,11 +1822,11 @@ static int check_command(struct fsg_common *common, int cmnd_size,
* If a unit attention condition exists, only INQUIRY and
* REQUEST SENSE commands are allowed; anything else must fail.
*/
if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
if (curlun && curlun->unit_attention_data != NO_SENSE &&
common->cmnd[0] != INQUIRY &&
common->cmnd[0] != REQUEST_SENSE) {
curlun->sense_data = curlun->unit_attention_data;
curlun->unit_attention_data = SS_NO_SENSE;
curlun->unit_attention_data = NO_SENSE;
return -EINVAL;
}
@ -2501,8 +2503,8 @@ static void handle_exception(struct fsg_common *common)
if (!curlun)
continue;
curlun->prevent_medium_removal = 0;
curlun->sense_data = SS_NO_SENSE;
curlun->unit_attention_data = SS_NO_SENSE;
curlun->sense_data = NO_SENSE;
curlun->unit_attention_data = NO_SENSE;
curlun->sense_data_info = 0;
curlun->info_valid = 0;
}

69
drivers/usb/gadget/function/storage_common.h
View File

@ -70,24 +70,59 @@ do { \
#define MAX_COMMAND_SIZE 16
/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
#define SS_NO_SENSE 0
#define SS_COMMUNICATION_FAILURE 0x040800
#define SS_INVALID_COMMAND 0x052000
#define SS_INVALID_FIELD_IN_CDB 0x052400
#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x052100
#define SS_LOGICAL_UNIT_NOT_SUPPORTED 0x052500
#define SS_MEDIUM_NOT_PRESENT 0x023a00
#define SS_MEDIUM_REMOVAL_PREVENTED 0x055302
#define SS_NOT_READY_TO_READY_TRANSITION 0x062800
#define SS_RESET_OCCURRED 0x062900
#define SS_SAVING_PARAMETERS_NOT_SUPPORTED 0x053900
#define SS_UNRECOVERED_READ_ERROR 0x031100
#define SS_WRITE_ERROR 0x030c02
#define SS_WRITE_PROTECTED 0x072700
static inline u32 usb_sense_kc(u8 sense_key, u16 sense_code)
{
return ((u32)sense_key << 16) | (u32)sense_code;
}
#define SK(x) ((u8) ((x) >> 16)) /* Sense Key byte, etc. */
#define ASC(x) ((u8) ((x) >> 8))
#define ASCQ(x) ((u8) (x))
static inline u8 usb_sense_key(u32 kc)
{
return kc >> 16;
}
static inline u16 usb_sense_code(u32 kc)
{
return kc & 0xFFFF;
}
static inline u8 usb_sense_asc(u32 kc)
{
return scsi_sense_code_asc(usb_sense_code(kc));
}
static inline u8 usb_sense_ascq(u32 kc)
{
return scsi_sense_code_ascq(usb_sense_code(kc));
}
#define SS_COMMUNICATION_FAILURE \
usb_sense_kc(HARDWARE_ERROR, LU_COMMUNICATION_FAILURE)
#define SS_INVALID_COMMAND \
usb_sense_kc(ILLEGAL_REQUEST, INVALID_COMMAND_OP_CODE)
#define SS_INVALID_FIELD_IN_CDB \
usb_sense_kc(ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB)
#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE \
usb_sense_kc(ILLEGAL_REQUEST, LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE)
#define SS_LOGICAL_UNIT_NOT_SUPPORTED \
usb_sense_kc(ILLEGAL_REQUEST, LU_NOT_SUPPORTED)
#define SS_MEDIUM_NOT_PRESENT \
usb_sense_kc(NOT_READY, MEDIUM_NOT_PRESENT)
#define SS_MEDIUM_REMOVAL_PREVENTED \
usb_sense_kc(ILLEGAL_REQUEST, MEDIUM_REMOVAL_PREVENTED)
#define SS_NOT_READY_TO_READY_TRANSITION \
usb_sense_kc(UNIT_ATTENTION, \
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED)
#define SS_RESET_OCCURRED \
usb_sense_kc(UNIT_ATTENTION, \
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
#define SS_SAVING_PARAMETERS_NOT_SUPPORTED \
usb_sense_kc(ILLEGAL_REQUEST, SAVING_PARAMETERS_NOT_SUPPORTED)
#define SS_UNRECOVERED_READ_ERROR \
usb_sense_kc(MEDIUM_ERROR, UNRECOVERED_READ_ERROR)
#define SS_WRITE_ERROR \
usb_sense_kc(MEDIUM_ERROR, WRITE_ERROR_AUTO_REALLOCATION_FAILED)
#define SS_WRITE_PROTECTED \
usb_sense_kc(DATA_PROTECT, WRITE_PROTECTED)
/*
* Vendor (8 chars), product (16 chars), release (4 hexadecimal digits) and NUL

11
drivers/usb/storage/debug.c
View File

@ -141,14 +141,12 @@ void usb_stor_show_command(const struct us_data *us, struct scsi_cmnd *srb)
}
void usb_stor_show_sense(const struct us_data *us,
unsigned char key,
unsigned char asc,
unsigned char ascq)
const struct scsi_sense_hdr *sshdr)
{
const char *what, *keystr, *fmt;
keystr = scsi_sense_key_string(key);
what = scsi_extd_sense_format(asc, ascq, &fmt);
keystr = scsi_sense_key_string(sshdr->sense_key);
what = scsi_extd_sense_format(sshdr, &fmt);
if (keystr == NULL)
keystr = "(Unknown Key)";
@ -156,7 +154,8 @@ void usb_stor_show_sense(const struct us_data *us,
what = "(unknown ASC/ASCQ)";
if (fmt)
usb_stor_dbg(us, "%s: %s (%s%x)\n", keystr, what, fmt, ascq);
usb_stor_dbg(us, "%s: %s (%s%x)\n", keystr, what, fmt,
scsi_sense_ascq(sshdr));
else
usb_stor_dbg(us, "%s: %s\n", keystr, what);
}

4
drivers/usb/storage/debug.h
View File

@ -31,8 +31,8 @@
#ifdef CONFIG_USB_STORAGE_DEBUG
void usb_stor_show_command(const struct us_data *us, struct scsi_cmnd *srb);
void usb_stor_show_sense(const struct us_data *us, unsigned char key,
unsigned char asc, unsigned char ascq);
void usb_stor_show_sense(const struct us_data *us,
const struct scsi_sense_hdr *sshdr);
__printf(2, 3) void usb_stor_dbg(const struct us_data *us,
const char *fmt, ...);

7
drivers/usb/storage/transport.c
View File

@ -803,9 +803,9 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
temp_result);
usb_stor_dbg(us, "-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
sshdr.response_code, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr), scsi_sense_ascq(&sshdr));
#ifdef CONFIG_USB_STORAGE_DEBUG
usb_stor_show_sense(us, sshdr.sense_key, sshdr.asc, sshdr.ascq);
usb_stor_show_sense(us, &sshdr);
#endif
/* set the result so the higher layers expect this data */
@ -820,7 +820,8 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
* everything worked or that there was an unspecified
* problem. We have to decide which.
*/
if (sshdr.sense_key == 0 && sshdr.asc == 0 && sshdr.ascq == 0 &&
if (sshdr.sense_key == NO_SENSE &&
sshdr.sense_code == NO_ADDITIONAL_SENSE_INFORMATION &&
fm_ili == 0) {
/*
* If things are really okay, then let's show that.

3
include/scsi/scsi_cmnd.h
View File

@ -391,8 +391,7 @@ static inline unsigned scsi_transfer_length(struct scsi_cmnd *scmd)
return xfer_len;
}
extern void scsi_build_sense(struct scsi_cmnd *scmd, int desc,
u8 key, u8 asc, u8 ascq);
void scsi_set_sense(struct scsi_cmnd *scmd, int desc, u8 key, u16 code);
struct request *scsi_alloc_request(struct request_queue *q, blk_opf_t opf,
blk_mq_req_flags_t flags);

16
include/scsi/scsi_common.h
View File

@ -71,8 +71,7 @@ extern u64 scsilun_to_int(struct scsi_lun *);
struct scsi_sense_hdr { /* See SPC-3 section 4.5 */
u8 response_code; /* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
u8 sense_key;
u8 asc;
u8 ascq;
u16 sense_code;
u8 byte4;
u8 byte5;
u8 byte6;
@ -87,10 +86,21 @@ static inline bool scsi_sense_valid(const struct scsi_sense_hdr *sshdr)
return (sshdr->response_code & 0x70) == 0x70;
}
static inline u8 scsi_sense_asc(const struct scsi_sense_hdr *sshdr)
{
return scsi_sense_code_asc(sshdr->sense_code);
}
static inline u8 scsi_sense_ascq(const struct scsi_sense_hdr *sshdr)
{
return scsi_sense_code_ascq(sshdr->sense_code);
}
extern bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len,
struct scsi_sense_hdr *sshdr);
extern void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq);
void scsi_set_sense_buffer(int desc, u8 *buf, u8 key, u16 code);
int scsi_set_sense_information(u8 *buf, int buf_len, u64 info);
int scsi_set_sense_field_pointer(u8 *buf, int buf_len, u16 fp, u8 bp, bool cd);
extern const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,

6
include/scsi/scsi_dbg.h
View File

@ -20,8 +20,8 @@ extern void scsi_print_result(struct scsi_cmnd *, const char *, int);
#ifdef CONFIG_SCSI_CONSTANTS
extern bool scsi_opcode_sa_name(int, int, const char **, const char **);
extern const char *scsi_sense_key_string(unsigned char);
extern const char *scsi_extd_sense_format(unsigned char, unsigned char,
const char **);
extern const char *scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr,
const char **fmt);
extern const char *scsi_mlreturn_string(int);
extern const char *scsi_hostbyte_string(int);
#else
@ -57,7 +57,7 @@ scsi_sense_key_string(unsigned char key)
}
static inline const char *
scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr, const char **fmt)
{
*fmt = NULL;
return NULL;

26
include/scsi/scsi_device.h
View File

@ -514,20 +514,20 @@ extern void scsi_sanitize_inquiry_string(unsigned char *s, int len);
*/
#define SCMD_FAILURE_STAT_ANY 0xff
/*
* The following can be set to the scsi_failure sense, asc and ascq fields to
* match on any sense, ASC, or ASCQ value.
* The following can be set to the scsi_failure sense key, asc and ascq fields
* to match any sense key, ASC, and ASCQ value.
*/
#define SCMD_FAILURE_SENSE_ANY 0xff
#define SCMD_FAILURE_ASC_ANY 0xff
#define SCMD_FAILURE_ASCQ_ANY 0xff
#define SCMD_FAILURE_SENSE_KEY_ANY 0xff
#define SCMD_FAILURE_SENSE_CODE_ANY 0xffff
#define SCMD_FAILURE_ASC_ANY 0xff
#define SCMD_FAILURE_ASCQ_ANY 0xff
/* Always retry a matching failure. */
#define SCMD_FAILURE_NO_LIMIT -1
struct scsi_failure {
int result;
u8 sense;
u8 asc;
u8 ascq;
u8 sense_key;
u16 sense_code;
/*
* Number of times scsi_execute_cmd will retry the failure. It does
* not count for the total_allowed.
@ -537,6 +537,16 @@ struct scsi_failure {
s8 retries;
};
static inline u8 scsi_failure_asc(const struct scsi_failure *failure)
{
return scsi_sense_code_asc(failure->sense_code);
}
static inline u8 scsi_failure_ascq(const struct scsi_failure *failure)
{
return scsi_sense_code_ascq(failure->sense_code);
}
struct scsi_failures {
/*
* If a scsi_failure does not have a retry limit setup this limit will

71
include/scsi/scsi_proto.h
View File

@ -12,6 +12,7 @@
#include <linux/build_bug.h>
#include <linux/types.h>
#include <scsi/scsi_sense.h>
/*
* SCSI opcodes
@ -218,76 +219,6 @@ enum sam_status {
#define STATUS_MASK 0xfe
/*
* SENSE KEYS
*/
#define NO_SENSE 0x00
#define RECOVERED_ERROR 0x01
#define NOT_READY 0x02
#define MEDIUM_ERROR 0x03
#define HARDWARE_ERROR 0x04
#define ILLEGAL_REQUEST 0x05
#define UNIT_ATTENTION 0x06
#define DATA_PROTECT 0x07
#define BLANK_CHECK 0x08
#define VENDOR_SPECIFIC 0x09
#define COPY_ABORTED 0x0a
#define ABORTED_COMMAND 0x0b
#define VOLUME_OVERFLOW 0x0d
#define MISCOMPARE 0x0e
#define COMPLETED 0x0f
/*
* Additional Sense Codes (ASC).
*/
#define NO_ADDITIONAL_SENSE 0x00
#define OVERLAP_ATOMIC_COMMAND_ASC 0x00
#define LOGICAL_UNIT_NOT_READY 0x04
#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8
#define WRITE_ERROR_ASC 0x0c
#define UNRECOVERED_READ_ERR 0x11
#define PARAMETER_LIST_LENGTH_ERR 0x1a
#define MISCOMPARE_VERIFY_ASC 0x1d
#define INVALID_OPCODE 0x20
#define LBA_OUT_OF_RANGE 0x21
#define INVALID_FIELD_IN_CDB 0x24
#define INVALID_FIELD_IN_PARAM_LIST 0x26
#define WRITE_PROTECTED 0x27
#define UA_READY_ASC 0x28
#define UA_RESET_ASC 0x29
#define UA_CHANGED_ASC 0x2a
#define TOO_MANY_IN_PARTITION_ASC 0x3b
#define TARGET_CHANGED_ASC 0x3f
#define SAVING_PARAMS_UNSUP 0x39
#define TRANSPORT_PROBLEM 0x4b
#define INSUFF_RES_ASC 0x55
#define LOW_POWER_COND_ON 0x5e
#define THRESHOLD_EXCEEDED 0x5d
/*
* Additional Sense Code Qualifiers (ASCQ).
*/
#define POWER_ON_RESET_ASCQ 0x00
#define MODE_CHANGED_ASCQ 0x01 /* mode parameters changed */
#define FILEMARK_DETECTED_ASCQ 0x01
#define POWER_ON_OCCURRED_ASCQ 0x01
#define MICROCODE_CHANGED_ASCQ 0x01 /* with TARGET_CHANGED_ASC */
#define BUS_RESET_ASCQ 0x02 /* scsi bus reset occurred */
#define EOP_EOM_DETECTED_ASCQ 0x02
#define INSUFF_RES_ASCQ 0x03
#define BEGINNING_OF_P_M_DETECTED_ASCQ 0x04
#define UNALIGNED_WRITE_ASCQ 0x04
#define EOD_DETECTED_ASCQ 0x05
#define WRITE_BOUNDARY_ASCQ 0x05
#define READ_INVDATA_ASCQ 0x06
#define READ_BOUNDARY_ASCQ 0x07
#define CAPACITY_CHANGED_ASCQ 0x09
#define ATTEMPT_ACCESS_GAP 0x09
#define LUNS_CHANGED_ASCQ 0x0e
#define INSUFF_ZONE_ASCQ 0x0e
#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
#define OVERLAP_ATOMIC_COMMAND_ASCQ 0x23
/*
* DEVICE TYPES
* Please keep them in 0x%02x format for $MODALIAS to work

950
include/scsi/scsi_sense.h Normal file
View File

@ -0,0 +1,950 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Definitions of SCSI sense keys, additional sense codes and additional sense
* code qualifiers.
*/
#ifndef _SCSI_SENSE_H_
#define _SCSI_SENSE_H_
#include <linux/types.h>
/*
* Sense keys.
* See: https://www.t10.org/lists/2sensekey.htm
*/
enum scsi_sense_key {
NO_SENSE = 0x00,
RECOVERED_ERROR = 0x01,
NOT_READY = 0x02,
MEDIUM_ERROR = 0x03,
HARDWARE_ERROR = 0x04,
ILLEGAL_REQUEST = 0x05,
UNIT_ATTENTION = 0x06,
DATA_PROTECT = 0x07,
BLANK_CHECK = 0x08,
VENDOR_SPECIFIC = 0x09,
COPY_ABORTED = 0x0a,
ABORTED_COMMAND = 0x0b,
VOLUME_OVERFLOW = 0x0d,
MISCOMPARE = 0x0e,
COMPLETED = 0x0f,
};
#define ASC_DEF(name) ASC_##name
#define ASC(name, code) \
ASC_DEF(name) = (code), \
name = ((code) << 8) | 0x00
/*
* SCSI additional sense codes and sense codes qualifiers.
* See: https://www.t10.org/lists/asc-num.txt
* Additional sense codes and their qualifiers are combined as a single value
* equal to (ASC << 8) | ASCQ.
*
* The definitions are sorted in increasing sense code value order with a naming
* following as close as possible the exact naming used in T10. To avoid
* excessively long code lines when using these macros, some long ASC/ASCQ
* combination names are shortened (E.g. LOGICAL_UNIT_xxx -> LU_xxx).
* Very generic ASC names that potentially may clash with other macros elsewhere
* are prefixed with "SSC_" (e.g. WARNING and WRITE_ERROR).
*/
enum scsi_sense_code {
ASC(NO_ADDITIONAL_SENSE_INFORMATION, 0x00),
FILEMARK_DETECTED = 0x0001,
END_OF_PARTITION_MEDIUM_DETECTED = 0x0002,
SETMARK_DETECTED = 0x0003,
BEGINNING_OF_PARTITION_MEDIUM_DETECTED = 0x0004,
END_OF_DATA_DETECTED = 0x0005,
IO_PROCESS_TERMINATED = 0x0006,
PROGRAMMABLE_EARLY_WARNING_DETECTED = 0x0007,
AUDIO_PLAY_OP_IN_PROGRESS = 0x0011,
AUDIO_PLAY_OP_PAUSED = 0x0012,
AUDIO_PLAY_OP_SUCCESSFULLY_COMPLETED = 0x0013,
AUDIO_PLAY_OP_STOPPED_DUE_TO_ERROR = 0x0014,
NO_CURRENT_AUDIO_STATUS_TO_RETURN = 0x0015,
OP_IN_PROGRESS = 0x0016,
CLEANING_REQUESTED = 0x0017,
ERASE_OP_IN_PROGRESS = 0x0018,
LOCATE_OP_IN_PROGRESS = 0x0019,
REWIND_OP_IN_PROGRESS = 0x001A,
SET_CAPACITY_OP_IN_PROGRESS = 0x001B,
VERIFY_OP_IN_PROGRESS = 0x001C,
ATA_PASS_THROUGH_INFORMATION_AVAILABLE = 0x001D,
CONFLICTING_SA_CREATION_REQUEST = 0x001E,
LU_TRANSITIONING_TO_ANOTHER_POWER_CONDITION = 0x001F,
EXTENDED_COPY_INFORMATION_AVAILABLE = 0x0020,
ATOMIC_COMMAND_ABORTED_DUE_TO_ACA = 0x0021,
DEFERRED_MICROCODE_IS_PENDING = 0x0022,
OVERLAPPING_ATOMIC_COMMAND_IN_PROGRESS = 0x0023,
ASC(NO_INDEX_SECTOR_SIGNAL, 0x01),
ASC(NO_SEEK_COMPLETE, 0x02),
ASC(PERIPHERAL_DEVICE_WRITE_FAULT, 0x03),
NO_WRITE_CURRENT = 0x0301,
EXCESSIVE_WRITE_ERRORS = 0x0302,
ASC(LU_NOT_READY, 0x04),
LU_IS_IN_PROCESS_OF_BECOMING_READY = 0x0401,
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED = 0x0402,
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED = 0x0403,
LU_NOT_READY_FORMAT_IN_PROGRESS = 0x0404,
LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
LU_NOT_READY_RECALCULATION_IN_PROGRESS = 0x0406,
LU_NOT_READY_OP_IN_PROGRESS = 0x0407,
LU_NOT_READY_LONG_WRITE_IN_PROGRESS = 0x0408,
LU_NOT_READY_SELFTEST_IN_PROGRESS = 0x0409,
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION = 0x040A,
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE = 0x040B,
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE = 0x040C,
LU_NOT_READY_STRUCTURE_CHECK_REQUIRED = 0x040D,
LU_NOT_READY_SECURITY_SESSION_IN_PROGRESS = 0x040E,
LU_NOT_READY_AUXILIARY_MEMORY_NOT_ACCESSIBLE = 0x0410,
LU_NOT_READY_NOTIFY_REQUIRED = 0x0411,
LU_NOT_READY_OFFLINE = 0x0412,
LU_NOT_READY_SA_CREATION_IN_PROGRESS = 0x0413,
LU_NOT_READY_SPACE_ALLOCATION_IN_PROGRESS = 0x0414,
LU_NOT_READY_ROBOTICS_DISABLED = 0x0415,
LU_NOT_READY_CONFIG_REQUIRED = 0x0416,
LU_NOT_READY_CALIBRATION_REQUIRED = 0x0417,
LU_NOT_READY_A_DOOR_IS_OPEN = 0x0418,
LU_NOT_READY_OPERATING_IN_SEQUENTIAL_MODE = 0x0419,
LU_NOT_READY_START_STOP_UNIT_COMMAND_IN_PROGRESS = 0x041A,
LU_NOT_READY_SANITIZE_IN_PROGRESS = 0x041B,
LU_NOT_READY_ADDITIONAL_POWER_USE_NOT_YET_GRANTED = 0x041C,
LU_NOT_READY_CONFIG_IN_PROGRESS = 0x041D,
LU_NOT_READY_MICROCODE_ACTIVATION_REQUIRED = 0x041E,
LU_NOT_READY_MICROCODE_DOWNLOAD_REQUIRED = 0x041F,
LU_NOT_READY_LU_RESET_REQUIRED = 0x0420,
LU_NOT_READY_HARD_RESET_REQUIRED = 0x0421,
LU_NOT_READY_POWER_CYCLE_REQUIRED = 0x0422,
LU_NOT_READY_AFFILIATION_REQUIRED = 0x0423,
DEPOPULATION_IN_PROGRESS = 0x0424,
DEPOPULATION_RESTORATION_IN_PROGRESS = 0x0425,
ASC(LU_DOES_NOT_RESPOND_TO_SELECTION, 0x05),
ASC(NO_REFERENCE_POSITION_FOUND, 0x06),
ASC(MULTIPLE_PERIPHERAL_DEVICES_SELECTED, 0x07),
ASC(LU_COMMUNICATION_FAILURE, 0x08),
LU_COMMUNICATION_TIMEOUT = 0x0801,
LU_COMMUNICATION_PARITY_ERROR = 0x0802,
LU_COMMUNICATION_CRC_ERROR = 0x0803,
UNREACHABLE_COPY_TARGET = 0x0804,
ASC(TRACK_FOLLOWING_ERROR, 0x09),
TRACKING_SERVO_FAILURE = 0x0901,
FOCUS_SERVO_FAILURE = 0x0902,
SPINDLE_SERVO_FAILURE = 0x0903,
HEAD_SELECT_FAULT = 0x0904,
VIBRATION_INDUCED_TRACKING_ERROR = 0x0905,
ASC(ERROR_LOG_OVERFLOW, 0x0A),
ASC(SSC_WARNING, 0x0B),
WARNING_SPECIFIED_TEMPERATURE_EXCEEDED = 0x0B01,
WARNING_ENCLOSURE_DEGRADED = 0x0B02,
WARNING_BACKGROUND_SELFTEST_FAILED = 0x0B03,
WARNING_BACKGROUND_PRESCAN_DETECTED_MEDIUM_ERROR = 0x0B04,
WARNING_BACKGROUND_MEDIUM_SCAN_DETECTED_MEDIUM_ERROR = 0x0B05,
WARNING_NONVOLATILE_CACHE_NOW_VOLATILE = 0x0B06,
WARNING_DEGRADED_POWER_TO_NONVOLATILE_CACHE = 0x0B07,
WARNING_POWER_LOSS_EXPECTED = 0x0B08,
WARNING_DEVICE_STATISTICS_NOTIFICATION_ACTIVE = 0x0B09,
WARNING_HIGH_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0A,
WARNING_LOW_CRITICAL_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0B,
WARNING_HIGH_OPERATING_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0C,
WARNING_LOW_OPERATING_TEMPERATURE_LIMIT_EXCEEDED = 0x0B0D,
WARNING_HIGH_CRITICAL_HUMIDITY_LIMIT_EXCEEDED = 0x0B0E,
WARNING_LOW_CRITICAL_HUMIDITY_LIMIT_EXCEEDED = 0x0B0F,
WARNING_HIGH_OPERATING_HUMIDITY_LIMIT_EXCEEDED = 0x0B10,
WARNING_LOW_OPERATING_HUMIDITY_LIMIT_EXCEEDED = 0x0B11,
WARNING_MICROCODE_SECURITY_AT_RISK = 0x0B12,
WARNING_MICROCODE_DIGITAL_SIGNATURE_VALIDATION_FAILURE = 0x0B13,
WARNING_PHYSICAL_ELEMENT_STATUS_CHANGE = 0x0B14,
/* Defined as "WRITE ERROR" in T10. */
ASC(SSC_WRITE_ERROR, 0x0C),
WRITE_ERROR_RECOVERED_WITH_AUTO_REALLOCATION = 0x0C01,
WRITE_ERROR_AUTO_REALLOCATION_FAILED = 0x0C02,
WRITE_ERROR_RECOMMEND_REASSIGNMENT = 0x0C03,
COMPRESSION_CHECK_MISCOMPARE_ERROR = 0x0C04,
DATA_EXPANSION_OCCURRED_DURING_COMPRESSION = 0x0C05,
BLOCK_NOT_COMPRESSIBLE = 0x0C06,
WRITE_ERROR_RECOVERY_NEEDED = 0x0C07,
WRITE_ERROR_RECOVERY_FAILED = 0x0C08,
WRITE_ERROR_LOSS_OF_STREAMING = 0x0C09,
WRITE_ERROR_PADDING_BLOCKS_ADDED = 0x0C0A,
AUXILIARY_MEMORY_WRITE_ERROR = 0x0C0B,
WRITE_ERROR_UNEXPECTED_UNSOLICITED_DATA = 0x0C0C,
WRITE_ERROR_NOT_ENOUGH_UNSOLICITED_DATA = 0x0C0D,
MULTIPLE_WRITE_ERRORS = 0x0C0E,
DEFECTS_IN_ERROR_WINDOW = 0x0C0F,
INCOMPLETE_MULTIPLE_ATOMIC_WRITE_OPERATIONS = 0x0C10,
WRITE_ERROR_RECOVERY_SCAN_NEEDED = 0x0C11,
WRITE_ERROR_INSUFFICIENT_ZONE_RESOURCES = 0x0C12,
ASC(ERROR_DETECTED_BY_THIRD_PARTY_TEMPORARY_INITIATOR, 0x0D),
THIRD_PARTY_DEVICE_FAILURE = 0x0D01,
COPY_TARGET_DEVICE_NOT_REACHABLE = 0x0D02,
INCORRECT_COPY_TARGET_DEVICE_TYPE = 0x0D03,
COPY_TARGET_DEVICE_DATA_UNDERRUN = 0x0D04,
COPY_TARGET_DEVICE_DATA_OVERRUN = 0x0D05,
ASC(INVALID_INFORMATION_UNIT, 0x0E),
INFORMATION_UNIT_TOO_SHORT = 0x0E01,
INFORMATION_UNIT_TOO_LONG = 0x0E02,
INVALID_FIELD_IN_COMMAND_INFORMATION_UNIT = 0x0E03,
ASC(ID_CRC_OR_ECC_ERROR, 0x10),
LOGICAL_BLOCK_GUARD_CHECK_FAILED = 0x1001,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED = 0x1002,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED = 0x1003,
LOGICAL_BLOCK_PROTECTION_ERROR_ON_RECOVER_BUFFERED_DATA = 0x1004,
LOGICAL_BLOCK_PROTECTION_METHOD_ERROR = 0x1005,
ASC(UNRECOVERED_READ_ERROR, 0x11),
READ_RETRIES_EXHAUSTED = 0x1101,
ERROR_TOO_LONG_TO_CORRECT = 0x1102,
MULTIPLE_READ_ERRORS = 0x1103,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED = 0x1104,
LEC_UNCORRECTABLE_ERROR = 0x1105,
CIRC_UNRECOVERED_ERROR = 0x1106,
DATA_RESYNCHRONIZATION_ERROR = 0x1107,
INCOMPLETE_BLOCK_READ = 0x1108,
NO_GAP_FOUND = 0x1109,
MISCORRECTED_ERROR = 0x110A,
UNRECOVERED_READ_ERROR_RECOMMEND_REASSIGNMENT = 0x110B,
UNRECOVERED_READ_ERROR_RECOMMEND_REWRITE_THE_DATA = 0x110C,
DECOMPRESSION_CRC_ERROR = 0x110D,
CANNOT_DECOMPRESS_USING_DECLARED_ALGORITHM = 0x110E,
ERROR_READING_UPC_EAN_NUMBER = 0x110F,
ERROR_READING_ISRC_NUMBER = 0x1110,
READ_ERROR_LOSS_OF_STREAMING = 0x1111,
AUXILIARY_MEMORY_READ_ERROR = 0x1112,
READ_ERROR_FAILED_RETRANSMISSION_REQUEST = 0x1113,
READ_ERROR_LBA_MARKED_BAD_BY_APPLICATION_CLIENT = 0x1114,
WRITE_AFTER_SANITIZE_REQUIRED = 0x1115,
ASC(ADDRESS_MARK_NOT_FOUND_FOR_ID_FIELD, 0x12),
ASC(ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD, 0x13),
ASC(RECORDED_ENTITY_NOT_FOUND, 0x14),
RECORD_NOT_FOUND = 0x1401,
FILEMARK_OR_SETMARK_NOT_FOUND = 0x1402,
END_OF_DATA_NOT_FOUND = 0x1403,
BLOCK_SEQUENCE_ERROR = 0x1404,
RECORD_NOT_FOUND_RECOMMEND_REASSIGNMENT = 0x1405,
RECORD_NOT_FOUND_DATA_AUTO_REALLOCATED = 0x1406,
LOCATE_OPERATION_FAILURE = 0x1407,
ASC(RANDOM_POSITIONING_ERROR, 0x15),
MECHANICAL_POSITIONING_ERROR = 0x1501,
POSITIONING_ERROR_DETECTED_BY_READ_OF_MEDIUM = 0x1502,
ASC(DATA_SYNCHRONIZATION_MARK_ERROR, 0x16),
DATA_SYNC_ERROR_DATA_REWRITTEN = 0x1601,
DATA_SYNC_ERROR_RECOMMEND_REWRITE = 0x1602,
DATA_SYNC_ERROR_DATA_AUTO_REALLOCATED = 0x1603,
DATA_SYNC_ERROR_RECOMMEND_REASSIGNMENT = 0x1604,
ASC(RECOVERED_DATA_WITH_NO_ERROR_CORRECTION_APPLIED, 0x17),
RECOVERED_DATA_WITH_RETRIES = 0x1701,
RECOVERED_DATA_WITH_POSITIVE_HEAD_OFFSET = 0x1702,
RECOVERED_DATA_WITH_NEGATIVE_HEAD_OFFSET = 0x1703,
RECOVERED_DATA_WITH_RETRIES_AND_OR_CIRC_APPLIED = 0x1704,
RECOVERED_DATA_USING_PREVIOUS_SECTOR_ID = 0x1705,
RECOVERED_DATA_WITHOUT_ECC_DATA_AUTO_REALLOCATED = 0x1706,
RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REASSIGNMENT = 0x1707,
RECOVERED_DATA_WITHOUT_ECC_RECOMMEND_REWRITE = 0x1708,
RECOVERED_DATA_WITHOUT_ECC_DATA_REWRITTEN = 0x1709,
ASC(RECOVERED_DATA_WITH_ERROR_CORRECTION_APPLIED, 0x18),
RECOVERED_DATA_WITH_ERROR_CORRECTION_RETRIES_APPLIED = 0x1801,
RECOVERED_DATA_DATA_AUTO_REALLOCATED = 0x1802,
RECOVERED_DATA_WITH_CIRC = 0x1803,
RECOVERED_DATA_WITH_LEC = 0x1804,
RECOVERED_DATA_RECOMMEND_REASSIGNMENT = 0x1805,
RECOVERED_DATA_RECOMMEND_REWRITE = 0x1806,
RECOVERED_DATA_WITH_ECC_DATA_REWRITTEN = 0x1807,
RECOVERED_DATA_WITH_LINKING = 0x1808,
ASC(DEFECT_LIST_ERROR, 0x19),
DEFECT_LIST_NOT_AVAILABLE = 0x1901,
DEFECT_LIST_ERROR_IN_PRIMARY_LIST = 0x1902,
DEFECT_LIST_ERROR_IN_GROWN_LIST = 0x1903,
ASC(PARAMETER_LIST_LENGTH_ERROR, 0x1A),
ASC(SYNCHRONOUS_DATA_TRANSFER_ERROR, 0x1B),
ASC(DEFECT_LIST_NOT_FOUND, 0x1C),
PRIMARY_DEFECT_LIST_NOT_FOUND = 0x1C01,
GROWN_DEFECT_LIST_NOT_FOUND = 0x1C02,
ASC(MISCOMPARE_DURING_VERIFY_OPERATION, 0x1D),
MISCOMPARE_VERIFY_OF_UNMAPPED_LBA = 0x1D01,
ASC(RECOVERED_ID_WITH_ECC_CORRECTION, 0x1E),
ASC(PARTIAL_DEFECT_LIST_TRANSFER, 0x1F),
ASC(INVALID_COMMAND_OP_CODE, 0x20),
ACCESS_DENIED_INITIATOR_PENDING_ENROLLED = 0x2001,
ACCESS_DENIED_NO_ACCESS_RIGHTS = 0x2002,
ACCESS_DENIED_INVALID_MGMT_ID_KEY = 0x2003,
ILLEGAL_COMMAND_WHILE_IN_WRITE_CAPABLE_STATE = 0x2004,
ILLEGAL_COMMAND_WHILE_IN_EXPLICIT_ADDRESS_MODE = 0x2006,
ILLEGAL_COMMAND_WHILE_IN_IMPLICIT_ADDRESS_MODE = 0x2007,
ACCESS_DENIED_ENROLLMENT_CONFLICT = 0x2008,
ACCESS_DENIED_INVALID_LU_IDENTIFIER = 0x2009,
ACCESS_DENIED_INVALID_PROXY_TOKEN = 0x200A,
ACCESS_DENIED_ACL_LUN_CONFLICT = 0x200B,
ILLEGAL_COMMAND_WHEN_NOT_IN_APPEND_ONLY_MODE = 0x200C,
NOT_AN_ADMINISTRATIVE_LOGICAL_UNIT = 0x200D,
NOT_A_SUBSIDIARY_LOGICAL_UNIT = 0x200E,
NOT_A_CONGLOMERATE_LOGICAL_UNIT = 0x200F,
ASC(LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE, 0x21),
INVALID_ELEMENT_ADDRESS = 0x2101,
INVALID_ADDRESS_FOR_WRITE = 0x2102,
INVALID_WRITE_CROSSING_LAYER_JUMP = 0x2103,
UNALIGNED_WRITE_COMMAND = 0x2104,
WRITE_BOUNDARY_VIOLATION = 0x2105,
ATTEMPT_TO_READ_INVALID_DATA = 0x2106,
READ_BOUNDARY_VIOLATION = 0x2107,
MISALIGNED_WRITE_COMMAND = 0x2108,
ATTEMPT_TO_ACCESS_GAP_ZONE = 0x2109,
ASC(ILLEGAL_FUNCTION, 0x22),
ASC(INVALID_TOKEN_OP, 0x23),
INVALID_TOKEN_OP_UNSUPPORTED_TOKEN_TYPE = 0x2301,
INVALID_TOKEN_OP_REMOTE_TOKEN_USAGE_NOT_SUPPORTED = 0x2302,
INVALID_TOKEN_OP_REMOTE_ROD_TOKEN_CREATION_NOT_SUPPORTED = 0x2303,
INVALID_TOKEN_OP_TOKEN_UNKNOWN = 0x2304,
INVALID_TOKEN_OP_TOKEN_CORRUPT = 0x2305,
INVALID_TOKEN_OP_TOKEN_REVOKED = 0x2306,
INVALID_TOKEN_OP_TOKEN_EXPIRED = 0x2307,
INVALID_TOKEN_OP_TOKEN_CANCELLED = 0x2308,
INVALID_TOKEN_OP_TOKEN_DELETED = 0x2309,
INVALID_TOKEN_OP_INVALID_TOKEN_LENGTH = 0x230A,
ASC(INVALID_FIELD_IN_CDB, 0x24),
CDB_DECRYPTION_ERROR = 0x2401,
SECURITY_AUDIT_VALUE_FROZEN = 0x2404,
SECURITY_WORKING_KEY_FROZEN = 0x2405,
NONCE_NOT_UNIQUE = 0x2406,
NONCE_TIMESTAMP_OUT_OF_RANGE = 0x2407,
INVALID_XCDB = 0x2408,
INVALID_FAST_FORMAT = 0x2409,
ASC(LU_NOT_SUPPORTED, 0x25),
ASC(INVALID_FIELD_IN_PARAMETER_LIST, 0x26),
PARAMETER_NOT_SUPPORTED = 0x2601,
PARAMETER_VALUE_INVALID = 0x2602,
THRESHOLD_PARAMETERS_NOT_SUPPORTED = 0x2603,
INVALID_RELEASE_OF_PERSISTENT_RESERVATION = 0x2604,
DATA_DECRYPTION_ERROR = 0x2605,
TOO_MANY_TARGET_DESCRIPTORS = 0x2606,
UNSUPPORTED_TARGET_DESCRIPTOR_TYPE_CODE = 0x2607,
TOO_MANY_SEGMENT_DESCRIPTORS = 0x2608,
UNSUPPORTED_SEGMENT_DESCRIPTOR_TYPE_CODE = 0x2609,
UNEXPECTED_INEXACT_SEGMENT = 0x260A,
INLINE_DATA_LENGTH_EXCEEDED = 0x260B,
INVALID_OP_FOR_COPY_SOURCE_OR_DESTINATION = 0x260C,
COPY_SEGMENT_GRANULARITY_VIOLATION = 0x260D,
INVALID_PARAMETER_WHILE_PORT_IS_ENABLED = 0x260E,
INVALID_DATA_OUT_BUFFER_INTEGRITY_CHECK_VALUE = 0x260F,
DATA_DECRYPTION_KEY_FAIL_LIMIT_REACHED = 0x2610,
INCOMPLETE_KEY_ASSOCIATED_DATA_SET = 0x2611,
VENDOR_SPECIFIC_KEY_REFERENCE_NOT_FOUND = 0x2612,
APPLICATION_TAG_MODE_PAGE_IS_INVALID = 0x2613,
TAPE_STREAM_MIRRORING_PREVENTED = 0x2614,
COPY_SOURCE_OR_COPY_DESTINATION_NOT_AUTHORIZED = 0x2615,
FAST_COPY_NOT_POSSIBLE = 0x2616,
ASC(WRITE_PROTECTED, 0x27),
HW_WRITE_PROTECTED = 0x2701,
LU_SOFTWARE_WRITE_PROTECTED = 0x2702,
ASSOCIATED_WRITE_PROTECT = 0x2703,
PERSISTENT_WRITE_PROTECT = 0x2704,
PERMANENT_WRITE_PROTECT = 0x2705,
CONDITIONAL_WRITE_PROTECT = 0x2706,
SPACE_ALLOCATION_FAILED_WRITE_PROTECT = 0x2707,
ZONE_IS_READ_ONLY = 0x2708,
ASC(NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED, 0x28),
IMPORT_OR_EXPORT_ELEMENT_ACCESSED = 0x2801,
FORMAT_LAYER_MAY_HAVE_CHANGED = 0x2802,
IMPORT_EXPORT_ELEMENT_ACCESSED_MEDIUM_CHANGED = 0x2803,
ASC(POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED, 0x29),
POWER_ON_OCCURRED = 0x2901,
SCSI_BUS_RESET_OCCURRED = 0x2902,
BUS_DEVICE_RESET_FUNCTION_OCCURRED = 0x2903,
DEVICE_INTERNAL_RESET = 0x2904,
TRANSCEIVER_MODE_CHANGED_TO_SINGLE_ENDED = 0x2905,
TRANSCEIVER_MODE_CHANGED_TO_LVD = 0x2906,
I_T_NEXUS_LOSS_OCCURRED = 0x2907,
ASC(PARAMETERS_CHANGED, 0x2A),
MODE_PARAMETERS_CHANGED = 0x2A01,
LOG_PARAMETERS_CHANGED = 0x2A02,
RESERVATIONS_PREEMPTED = 0x2A03,
RESERVATIONS_RELEASED = 0x2A04,
REGISTRATIONS_PREEMPTED = 0x2A05,
ASYMMETRIC_ACCESS_STATE_CHANGED = 0x2A06,
IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED = 0x2A07,
PRIORITY_CHANGED = 0x2A08,
CAPACITY_DATA_HAS_CHANGED = 0x2A09,
ERROR_HISTORY_I_T_NEXUS_CLEARED = 0x2A0A,
ERROR_HISTORY_SNAPSHOT_RELEASED = 0x2A0B,
ERROR_RECOVERY_ATTRIBUTES_HAVE_CHANGED = 0x2A0C,
DATA_ENCRYPTION_CAPABILITIES_CHANGED = 0x2A0D,
TIMESTAMP_CHANGED = 0x2A10,
DATA_ENCRYPTION_PARAMS_CHANGED_BY_ANOTHER_I_T_NEXUS = 0x2A11,
DATA_ENCRYPTION_PARAMS_CHANGED_BY_VENDOR_SPECIFIC_EVENT = 0x2A12,
DATA_ENCRYPTION_KEY_INSTANCE_COUNTER_HAS_CHANGED = 0x2A13,
SA_CREATION_CAPABILITIES_DATA_HAS_CHANGED = 0x2A14,
MEDIUM_REMOVAL_PREVENTION_PREEMPTED = 0x2A15,
ZONE_RESET_WRITE_POINTER_RECOMMENDED = 0x2A16,
ASC(COPY_CANNOT_EXECUTE_SINCE_HOST_CANNOT_DISCONNECT, 0x2B),
ASC(COMMAND_SEQUENCE_ERROR, 0x2C),
TOO_MANY_WINDOWS_SPECIFIED = 0x2C01,
INVALID_COMBINATION_OF_WINDOWS_SPECIFIED = 0x2C02,
CURRENT_PROGRAM_AREA_IS_NOT_EMPTY = 0x2C03,
CURRENT_PROGRAM_AREA_IS_EMPTY = 0x2C04,
ILLEGAL_POWER_CONDITION_REQUEST = 0x2C05,
PERSISTENT_PREVENT_CONFLICT = 0x2C06,
PREVIOUS_BUSY_STATUS = 0x2C07,
PREVIOUS_TASK_SET_FULL_STATUS = 0x2C08,
PREVIOUS_RESERVATION_CONFLICT_STATUS = 0x2C09,
PARTITION_OR_COLLECTION_CONTAINS_USER_OBJECTS = 0x2C0A,
NOT_RESERVED = 0x2C0B,
ORWRITE_GENERATION_DOES_NOT_MATCH = 0x2C0C,
RESET_WRITE_POINTER_NOT_ALLOWED = 0x2C0D,
ZONE_IS_OFFLINE = 0x2C0E,
STREAM_NOT_OPEN = 0x2C0F,
UNWRITTEN_DATA_IN_ZONE = 0x2C10,
DESCRIPTOR_FORMAT_SENSE_DATA_REQUIRED = 0x2C11,
ZONE_IS_INACTIVE = 0x2C12,
WELL_KNOWN_LU_ACCESS_REQUIRED = 0x2C13,
ASC(OVERWRITE_ERROR_ON_UPDATE_IN_PLACE, 0x2D),
ASC(INSUFFICIENT_TIME_FOR_OPERATION, 0x2E),
COMMAND_TIMEOUT_BEFORE_PROCESSING = 0x2E01,
COMMAND_TIMEOUT_DURING_PROCESSING = 0x2E02,
COMMAND_TIMEOUT_DURING_PROCESSING_DUE_TO_ERROR_RECOVERY = 0x2E03,
ASC(COMMANDS_CLEARED_BY_ANOTHER_INITIATOR, 0x2F),
COMMANDS_CLEARED_BY_POWER_LOSS_NOTIFICATION = 0x2F01,
COMMANDS_CLEARED_BY_DEVICE_SERVER = 0x2F02,
SOME_COMMANDS_CLEARED_BY_QUEUING_LAYER_EVENT = 0x2F03,
ASC(INCOMPATIBLE_MEDIUM_INSTALLED, 0x30),
CANNOT_READ_MEDIUM_UNKNOWN_FORMAT = 0x3001,
CANNOT_READ_MEDIUM_INCOMPATIBLE_FORMAT = 0x3002,
CLEANING_CARTRIDGE_INSTALLED = 0x3003,
CANNOT_WRITE_MEDIUM_UNKNOWN_FORMAT = 0x3004,
CANNOT_WRITE_MEDIUM_INCOMPATIBLE_FORMAT = 0x3005,
CANNOT_FORMAT_MEDIUM_INCOMPATIBLE_MEDIUM = 0x3006,
CLEANING_FAILURE = 0x3007,
CANNOT_WRITE_APPLICATION_CODE_MISMATCH = 0x3008,
CURRENT_SESSION_NOT_FIXATED_FOR_APPEND = 0x3009,
CLEANING_REQUEST_REJECTED = 0x300A,
WORM_MEDIUM_OVERWRITE_ATTEMPTED = 0x300C,
WORM_MEDIUM_INTEGRITY_CHECK = 0x300D,
MEDIUM_NOT_FORMATTED = 0x3010,
INCOMPATIBLE_VOLUME_TYPE = 0x3011,
INCOMPATIBLE_VOLUME_QUALIFIER = 0x3012,
CLEANING_VOLUME_EXPIRED = 0x3013,
ASC(MEDIUM_FORMAT_CORRUPTED, 0x31),
FORMAT_COMMAND_FAILED = 0x3101,
ZONED_FORMATTING_FAILED_DUE_TO_SPARE_LINKING = 0x3102,
SANITIZE_COMMAND_FAILED = 0x3103,
DEPOPULATION_FAILED = 0x3104,
DEPOPULATION_RESTORATION_FAILED = 0x3105,
ASC(NO_DEFECT_SPARE_LOCATION_AVAILABLE, 0x32),
DEFECT_LIST_UPDATE_FAILURE = 0x3201,
ASC(TAPE_LENGTH_ERROR, 0x33),
ASC(ENCLOSURE_FAILURE, 0x34),
ASC(ENCLOSURE_SERVICES_FAILURE, 0x35),
UNSUPPORTED_ENCLOSURE_FUNCTION = 0x3501,
ENCLOSURE_SERVICES_UNAVAILABLE = 0x3502,
ENCLOSURE_SERVICES_TRANSFER_FAILURE = 0x3503,
ENCLOSURE_SERVICES_TRANSFER_REFUSED = 0x3504,
ENCLOSURE_SERVICES_CHECKSUM_ERROR = 0x3505,
ASC(RIBBON_INK_OR_TONER_FAILURE, 0x36),
ASC(ROUNDED_PARAMETER, 0x37),
ASC(EVENT_STATUS_NOTIFICATION, 0x38),
ESN_POWER_MANAGEMENT_CLASS_EVENT = 0x3802,
ESN_MEDIA_CLASS_EVENT = 0x3804,
ESN_DEVICE_BUSY_CLASS_EVENT = 0x3806,
THIN_PROVISIONING_SOFT_THRESHOLD_REACHED = 0x3807,
DEPOPULATION_INTERRUPTED = 0x3808,
DEPOPULATION_RESTORATION_INTERRUPTED = 0x3809,
ASC(SAVING_PARAMETERS_NOT_SUPPORTED, 0x39),
ASC(MEDIUM_NOT_PRESENT, 0x3A),
MEDIUM_NOT_PRESENT_TRAY_CLOSED = 0x3A01,
MEDIUM_NOT_PRESENT_TRAY_OPEN = 0x3A02,
MEDIUM_NOT_PRESENT_LOADABLE = 0x3A03,
MEDIUM_NOT_PRESENT_MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE = 0x3A04,
ASC(SEQUENTIAL_POSITIONING_ERROR, 0x3B),
TAPE_POSITION_ERROR_AT_BEGINNING_OF_MEDIUM = 0x3B01,
TAPE_POSITION_ERROR_AT_END_OF_MEDIUM = 0x3B02,
TAPE_OR_ELECTRONIC_VERTICAL_FORMS_UNIT_NOT_READY = 0x3B03,
SLEW_FAILURE = 0x3B04,
PAPER_JAM = 0x3B05,
FAILED_TO_SENSE_TOP_OF_FORM = 0x3B06,
FAILED_TO_SENSE_BOTTOM_OF_FORM = 0x3B07,
REPOSITION_ERROR = 0x3B08,
READ_PAST_END_OF_MEDIUM = 0x3B09,
READ_PAST_BEGINNING_OF_MEDIUM = 0x3B0A,
POSITION_PAST_END_OF_MEDIUM = 0x3B0B,
POSITION_PAST_BEGINNING_OF_MEDIUM = 0x3B0C,
MEDIUM_DESTINATION_ELEMENT_FULL = 0x3B0D,
MEDIUM_SOURCE_ELEMENT_EMPTY = 0x3B0E,
END_OF_MEDIUM_REACHED = 0x3B0F,
MEDIUM_MAGAZINE_NOT_ACCESSIBLE = 0x3B11,
MEDIUM_MAGAZINE_REMOVED = 0x3B12,
MEDIUM_MAGAZINE_INSERTED = 0x3B13,
MEDIUM_MAGAZINE_LOCKED = 0x3B14,
MEDIUM_MAGAZINE_UNLOCKED = 0x3B15,
MECHANICAL_POSITIONING_OR_CHANGER_ERROR = 0x3B16,
READ_PAST_END_OF_USER_OBJECT = 0x3B17,
ELEMENT_DISABLED = 0x3B18,
ELEMENT_ENABLED = 0x3B19,
DATA_TRANSFER_DEVICE_REMOVED = 0x3B1A,
DATA_TRANSFER_DEVICE_INSERTED = 0x3B1B,
TOO_MANY_LOGICAL_OBJECTS_ON_PARTITION_TO_SUPPORT_OP = 0x3B1C,
ELEMENT_STATIC_INFORMATION_CHANGED = 0x3B20,
ASC(INVALID_BITS_IN_IDENTIFY_MESSAGE, 0x3D),
ASC(LU_HAS_NOT_SELF_CONFIGURED_YET, 0x3E),
LU_FAILURE = 0x3E01,
TIMEOUT_ON_LOGICAL_UNIT = 0x3E02,
LU_FAILED_SELF_TEST = 0x3E03,
LU_UNABLE_TO_UPDATE_SELFTEST_LOG = 0x3E04,
ASC(TARGET_OPERATING_CONDITIONS_HAVE_CHANGED, 0x3F),
MICROCODE_HAS_BEEN_CHANGED = 0x3F01,
CHANGED_OPERATING_DEFINITION = 0x3F02,
INQUIRY_DATA_HAS_CHANGED = 0x3F03,
COMPONENT_DEVICE_ATTACHED = 0x3F04,
DEVICE_IDENTIFIER_CHANGED = 0x3F05,
REDUNDANCY_GROUP_CREATED_OR_MODIFIED = 0x3F06,
REDUNDANCY_GROUP_DELETED = 0x3F07,
SPARE_CREATED_OR_MODIFIED = 0x3F08,
SPARE_DELETED = 0x3F09,
VOLUME_SET_CREATED_OR_MODIFIED = 0x3F0A,
VOLUME_SET_DELETED = 0x3F0B,
VOLUME_SET_DEASSIGNED = 0x3F0C,
VOLUME_SET_REASSIGNED = 0x3F0D,
REPORTED_LUNS_DATA_HAS_CHANGED = 0x3F0E,
ECHO_BUFFER_OVERWRITTEN = 0x3F0F,
MEDIUM_LOADABLE = 0x3F10,
MEDIUM_AUXILIARY_MEMORY_ACCESSIBLE = 0x3F11,
iSCSI_IP_ADDRESS_ADDED = 0x3F12,
iSCSI_IP_ADDRESS_REMOVED = 0x3F13,
iSCSI_IP_ADDRESS_CHANGED = 0x3F14,
INSPECT_REFERRALS_SENSE_DESCRIPTORS = 0x3F15,
MICROCODE_HAS_BEEN_CHANGED_WITHOUT_RESET = 0x3F16,
ZONE_TRANSITION_TO_FULL = 0x3F17,
BIND_COMPLETED = 0x3F18,
BIND_REDIRECTED = 0x3F19,
SUBSIDIARY_BINDING_CHANGED = 0x3F1A,
ASC(RAM_FAILURE, 0x40),
/* DIAGNOSTIC_FAILURE_ON_COMPONENT_NN = 0x40NN */
ASC(DATA_PATH_FAILURE, 0x41),
ASC(POWER_ON_OR_SELFTEST_FAILURE, 0x42),
ASC(MESSAGE_ERROR, 0x43),
ASC(INTERNAL_TARGET_FAILURE, 0x44),
PERSISTENT_RESERVATION_INFORMATION_LOST = 0x4401,
ATA_DEVICE_FAILED_SET_FEATURES = 0x4471,
ASC(SELECT_OR_RESELECT_FAILURE, 0x45),
ASC(UNSUCCESSFUL_SOFT_RESET, 0x46),
ASC(SCSI_PARITY_ERROR, 0x47),
DATA_PHASE_CRC_ERROR_DETECTED = 0x4701,
SCSI_PARITY_ERROR_DETECTED_DURING_ST_DATA_PHASE = 0x4702,
INFORMATION_UNIT_iuCRC_ERROR_DETECTED = 0x4703,
ASYNCHRONOUS_INFORMATION_PROTECTION_ERROR_DETECTED = 0x4704,
PROTOCOL_SERVICE_CRC_ERROR = 0x4705,
PHY_TEST_FUNCTION_IN_PROGRESS = 0x4706,
SOME_COMMANDS_CLEARED_BY_ISCSI_PROTOCOL_EVENT = 0x477F,
ASC(INITIATOR_DETECTED_ERROR_MESSAGE_RECEIVED, 0x48),
ASC(INVALID_MESSAGE_ERROR, 0x49),
ASC(COMMAND_PHASE_ERROR, 0x4A),
ASC(DATA_PHASE_ERROR, 0x4B),
INVALID_TARGET_PORT_TRANSFER_TAG_RECEIVED = 0x4B01,
TOO_MUCH_WRITE_DATA = 0x4B02,
ACK_NAK_TIMEOUT = 0x4B03,
NAK_RECEIVED = 0x4B04,
DATA_OFFSET_ERROR = 0x4B05,
INITIATOR_RESPONSE_TIMEOUT = 0x4B06,
CONNECTION_LOST = 0x4B07,
DATA_IN_BUFFER_OVERFLOW_BUFFER_SIZE = 0x4B08,
DATA_IN_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA = 0x4B09,
DATA_IN_BUFFER_ERROR = 0x4B0A,
DATA_OUT_BUFFER_OVERFLOW_BUFFER_SIZE = 0x4B0B,
DATA_OUT_BUFFER_OVERFLOW_BUFFER_DESCRIPTOR_AREA = 0x4B0C,
DATA_OUT_BUFFER_ERROR = 0x4B0D,
PCIE_FABRIC_ERROR = 0x4B0E,
PCIE_COMPLETION_TIMEOUT = 0x4B0F,
PCIE_COMPLETER_ABORT = 0x4B10,
PCIE_POISONED_TLP_RECEIVED = 0x4B11,
PCIE_ECRC_CHECK_FAILED = 0x4B12,
PCIE_UNSUPPORTED_REQUEST = 0x4B13,
PCIE_ACS_VIOLATION = 0x4B14,
PCIE_TLP_PREFIX_BLOCKED = 0x4B15,
ASC(LU_FAILED_SELF_CONFIGURATION, 0x4C),
ASC(TAGGED_OVERLAPPED_COMMANDS, 0x4D),
ASC(OVERLAPPED_COMMANDS_ATTEMPTED, 0x4E),
ASC(WRITE_APPEND_ERROR, 0x50),
WRITE_APPEND_POSITION_ERROR = 0x5001,
POSITION_ERROR_RELATED_TO_TIMING = 0x5002,
ASC(ERASE_FAILURE, 0x51),
ERASE_FAILURE_INCOMPLETE_ERASE_OP_DETECTED = 0x5101,
ASC(CARTRIDGE_FAULT, 0x52),
ASC(MEDIA_LOAD_OR_EJECT_FAILED, 0x53),
UNLOAD_TAPE_FAILURE = 0x5301,
MEDIUM_REMOVAL_PREVENTED = 0x5302,
MEDIUM_REMOVAL_PREVENTED_BY_DATA_TRANSFER_ELEMENT = 0x5303,
MEDIUM_THREAD_OR_UNTHREAD_FAILURE = 0x5304,
VOLUME_IDENTIFIER_INVALID = 0x5305,
VOLUME_IDENTIFIER_MISSING = 0x5306,
DUPLICATE_VOLUME_IDENTIFIER = 0x5307,
ELEMENT_STATUS_UNKNOWN = 0x5308,
DATA_TRANSFER_DEVICE_ERR_LOAD_FAILED = 0x5309,
DATA_TRANSFER_DEVICE_ERR_UNLOAD_FAILED = 0x530A,
DATA_TRANSFER_DEVICE_ERR_UNLOAD_MISSING = 0x530B,
DATA_TRANSFER_DEVICE_ERR_EJECT_FAILED = 0x530C,
DATA_TRANSFER_DEVICE_ERR_LIBRARY_COMMUNICATION_FAILED = 0x530D,
ASC(SCSI_TO_HOST_SYSTEM_INTERFACE_FAILURE, 0x54),
ASC(SYSTEM_RESOURCE_FAILURE, 0x55),
SYSTEM_BUFFER_FULL = 0x5501,
INSUFFICIENT_RESERVATION_RESOURCES = 0x5502,
INSUFFICIENT_RESOURCES = 0x5503,
INSUFFICIENT_REGISTRATION_RESOURCES = 0x5504,
INSUFFICIENT_ACCESS_CONTROL_RESOURCES = 0x5505,
AUXILIARY_MEMORY_OUT_OF_SPACE = 0x5506,
QUOTA_ERROR = 0x5507,
MAXIMUM_NUMBER_OF_SUPPLEMENTAL_DECRYPTION_KEYS_EXCEEDED = 0x5508,
MEDIUM_AUXILIARY_MEMORY_NOT_ACCESSIBLE = 0x5509,
DATA_CURRENTLY_UNAVAILABLE = 0x550A,
INSUFFICIENT_POWER_FOR_OPERATION = 0x550B,
INSUFFICIENT_RESOURCES_TO_CREATE_ROD = 0x550C,
INSUFFICIENT_RESOURCES_TO_CREATE_ROD_TOKEN = 0x550D,
INSUFFICIENT_ZONE_RESOURCES = 0x550E,
INSUFFICIENT_ZONE_RESOURCES_TO_COMPLETE_WRITE = 0x550F,
MAXIMUM_NUMBER_OF_STREAMS_OPEN = 0x5510,
INSUFFICIENT_RESOURCES_TO_BIND = 0x5511,
ASC(UNABLE_TO_RECOVER_TABLE_OF_CONTENTS, 0x57),
ASC(GENERATION_DOES_NOT_EXIST, 0x58),
ASC(UPDATED_BLOCK_READ, 0x59),
ASC(OPERATOR_REQUEST_OR_STATE_CHANGE_INPUT, 0x5A),
OPERATOR_MEDIUM_REMOVAL_REQUEST = 0x5A01,
OPERATOR_SELECTED_WRITE_PROTECT = 0x5A02,
OPERATOR_SELECTED_WRITE_PERMIT = 0x5A03,
ASC(LOG_EXCEPTION, 0x5B),
THRESHOLD_CONDITION_MET = 0x5B01,
LOG_COUNTER_AT_MAXIMUM = 0x5B02,
LOG_LIST_CODES_EXHAUSTED = 0x5B03,
ASC(RPL_STATUS_CHANGE, 0x5C),
SPINDLES_SYNCHRONIZED = 0x5C01,
SPINDLES_NOT_SYNCHRONIZED = 0x5C02,
ASC(FAILURE_PREDICTION_THRESHOLD_EXCEEDED, 0x5D),
MEDIA_FAILURE_PREDICTION_THRESHOLD_EXCEEDED = 0x5D01,
LU_FAILURE_PREDICTION_THRESHOLD_EXCEEDED = 0x5D02,
SPARE_AREA_EXHAUSTION_PREDICTION_THRESHOLD_EXCEEDED = 0x5D03,
HW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D10,
HW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D11,
HW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D12,
HW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D13,
HW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D14,
HW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D15,
HW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D16,
HW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D17,
HW_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D18,
HW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D19,
HW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D1A,
HW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D1B,
HW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D1C,
HW_IMPENDING_FAILURE_POWER_LOSS_PROTECTION_CIRCUIT = 0x5D1D,
CONTROLLER_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D20,
CONTROLLER_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D21,
CONTROLLER_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D22,
CONTROLLER_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D23,
CONTROLLER_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D24,
CONTROLLER_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D25,
CONTROLLER_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D26,
CONTROLLER_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D27,
CONTROLLER_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D28,
CONTROLLER_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D29,
CONTROLLER_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D2A,
CONTROLLER_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D2B,
CONTROLLER_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D2C,
DATA_CHANNEL_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D30,
DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D31,
DATA_CHANNEL_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D32,
DATA_CHANNEL_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D33,
DATA_CHANNEL_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D34,
DATA_CHANNEL_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D35,
DATA_CHANNEL_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D36,
DATA_CHANNEL_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D37,
DATA_CHANNEL_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D38,
DATA_CHANNEL_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D39,
DATA_CHANNEL_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D3A,
DATA_CHANNEL_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D3B,
DATA_CHANNEL_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D3C,
SERVO_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D40,
SERVO_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D41,
SERVO_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D42,
SERVO_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D43,
SERVO_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D44,
SERVO_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D45,
SERVO_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D46,
SERVO_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D47,
SERVO_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D48,
SERVO_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D49,
SERVO_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D4A,
SERVO_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D4B,
SERVO_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D4C,
SPINDLE_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D50,
SPINDLE_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D51,
SPINDLE_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D52,
SPINDLE_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D53,
SPINDLE_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D54,
SPINDLE_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D55,
SPINDLE_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D56,
SPINDLE_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D57,
SPINDLE_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D58,
SPINDLE_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D59,
SPINDLE_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D5A,
SPINDLE_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D5B,
SPINDLE_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D5C,
FW_IMPENDING_FAILURE_GENERAL_HARD_DRIVE_FAILURE = 0x5D60,
FW_IMPENDING_FAILURE_DRIVE_ERROR_RATE_TOO_HIGH = 0x5D61,
FW_IMPENDING_FAILURE_DATA_ERROR_RATE_TOO_HIGH = 0x5D62,
FW_IMPENDING_FAILURE_SEEK_ERROR_RATE_TOO_HIGH = 0x5D63,
FW_IMPENDING_FAILURE_TOO_MANY_BLOCK_REASSIGNS = 0x5D64,
FW_IMPENDING_FAILURE_ACCESS_TIMES_TOO_HIGH = 0x5D65,
FW_IMPENDING_FAILURE_START_UNIT_TIMES_TOO_HIGH = 0x5D66,
FW_IMPENDING_FAILURE_CHANNEL_PARAMETRICS = 0x5D67,
FW_IMPENDING_FAILURE_CONTROLLER_DETECTED = 0x5D68,
FW_IMPENDING_FAILURE_THROUGHPUT_PERFORMANCE = 0x5D69,
FW_IMPENDING_FAILURE_SEEK_TIME_PERFORMANCE = 0x5D6A,
FW_IMPENDING_FAILURE_SPINUP_RETRY_COUNT = 0x5D6B,
FW_IMPENDING_FAILURE_DRIVE_CALIBRATION_RETRY_COUNT = 0x5D6C,
MEDIA_IMPENDING_FAILURE_ENDURANCE_LIMIT_MET = 0x5D73,
FAILURE_PREDICTION_THRESHOLD_EXCEEDED_FALSE = 0x5DFF,
ASC(LOW_POWER_CONDITION_ON, 0x5E),
IDLE_CONDITION_ACTIVATED_BY_TIMER = 0x5E01,
STANDBY_CONDITION_ACTIVATED_BY_TIMER = 0x5E02,
IDLE_CONDITION_ACTIVATED_BY_COMMAND = 0x5E03,
STANDBY_CONDITION_ACTIVATED_BY_COMMAND = 0x5E04,
IDLE_B_CONDITION_ACTIVATED_BY_TIMER = 0x5E05,
IDLE_B_CONDITION_ACTIVATED_BY_COMMAND = 0x5E06,
IDLE_C_CONDITION_ACTIVATED_BY_TIMER = 0x5E07,
IDLE_C_CONDITION_ACTIVATED_BY_COMMAND = 0x5E08,
STANDBY_Y_CONDITION_ACTIVATED_BY_TIMER = 0x5E09,
STANDBY_Y_CONDITION_ACTIVATED_BY_COMMAND = 0x5E0A,
POWER_STATE_CHANGE_TO_ACTIVE = 0x5E41,
POWER_STATE_CHANGE_TO_IDLE = 0x5E42,
POWER_STATE_CHANGE_TO_STANDBY = 0x5E43,
POWER_STATE_CHANGE_TO_SLEEP = 0x5E45,
POWER_STATE_CHANGE_TO_DEVICE_CONTROL = 0x5E47,
ASC(LAMP_FAILURE, 0x60),
ASC(VIDEO_ACQUISITION_ERROR, 0x61),
UNABLE_TO_ACQUIRE_VIDEO = 0x6101,
OUT_OF_FOCUS = 0x6102,
ASC(SCAN_HEAD_POSITIONING_ERROR, 0x62),
ASC(END_OF_USER_AREA_ENCOUNTERED_ON_THIS_TRACK, 0x63),
PACKET_DOES_NOT_FIT_IN_AVAILABLE_SPACE = 0x6301,
ASC(ILLEGAL_MODE_FOR_THIS_TRACK, 0x64),
INVALID_PACKET_SIZE = 0x6401,
ASC(VOLTAGE_FAULT, 0x65),
ASC(AUTOMATIC_DOCUMENT_FEEDER_COVER_UP, 0x66),
AUTOMATIC_DOCUMENT_FEEDER_LIFT_UP = 0x6601,
DOCUMENT_JAM_IN_AUTOMATIC_DOCUMENT_FEEDER = 0x6602,
DOCUMENT_MISS_FEED_AUTOMATIC_IN_DOCUMENT_FEEDER = 0x6603,
ASC(CONFIG_FAILURE, 0x67),
CONFIG_OF_INCAPABLE_LOGICAL_UNITS_FAILED = 0x6701,
ADD_LU_FAILED = 0x6702,
MODIFICATION_OF_LU_FAILED = 0x6703,
EXCHANGE_OF_LU_FAILED = 0x6704,
REMOVE_OF_LU_FAILED = 0x6705,
ATTACHMENT_OF_LU_FAILED = 0x6706,
CREATION_OF_LU_FAILED = 0x6707,
ASSIGN_FAILURE_OCCURRED = 0x6708,
MULTIPLY_ASSIGNED_LOGICAL_UNIT = 0x6709,
SET_TARGET_PORT_GROUPS_COMMAND_FAILED = 0x670A,
ATA_DEVICE_FEATURE_NOT_ENABLED = 0x670B,
COMMAND_REJECTED = 0x670C,
EXPLICIT_BIND_NOT_ALLOWED = 0x670D,
FEATURE_NOT_ENABLED = 0x670E,
ASC(LU_NOT_CONFIGURED, 0x68),
SUBSIDIARY_LU_NOT_CONFIGURED = 0x6801,
ASC(DATA_LOSS_ON_LOGICAL_UNIT, 0x69),
MULTIPLE_LU_FAILURES = 0x6901,
PARITY_DATA_MISMATCH = 0x6902,
ASC(INFORMATIONAL_REFER_TO_LOG, 0x6A),
ASC(STATE_CHANGE_HAS_OCCURRED, 0x6B),
REDUNDANCY_LEVEL_GOT_BETTER = 0x6B01,
REDUNDANCY_LEVEL_GOT_WORSE = 0x6B02,
ASC(REBUILD_FAILURE_OCCURRED, 0x6C),
ASC(RECALCULATE_FAILURE_OCCURRED, 0x6D),
ASC(COMMAND_TO_LU_FAILED, 0x6E),
ASC(COPY_PROTECTION_KEY_EXCHANGE_FAILURE_AUTHENTICATION_FAILURE, 0x6F),
COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_PRESENT = 0x6F01,
COPY_PROTECTION_KEY_EXCHANGE_FAILURE_KEY_NOT_ESTABLISHED = 0x6F02,
READ_OF_SCRAMBLED_SECTOR_WITHOUT_AUTHENTICATION = 0x6F03,
MEDIA_REGION_CODE_IS_MISMATCHED_TO_LU_REGION = 0x6F04,
DRIVE_REGION_MUST_BE_PERMANENT_REGION_RESET_COUNT_ERROR = 0x6F05,
INSUFFICIENT_BLOCK_COUNT_FOR_BINDING_NONCE_RECORDING = 0x6F06,
CONFLICT_IN_BINDING_NONCE_RECORDING = 0x6F07,
INSUFFICIENT_PERMISSION = 0x6F08,
INVALID_DRIVE_HOST_PAIRING_SERVER = 0x6F09,
DRIVE_HOST_PAIRING_SUSPENDED = 0x6F0A,
ASC(DECOMPRESSION_EXCEPTION_SHORT_ALGORITHM_ID, 0x70),
ASC(DECOMPRESSION_EXCEPTION_LONG_ALGORITHM_ID, 0x71),
ASC(SESSION_FIXATION_ERROR, 0x72),
SESSION_FIXATION_ERROR_WRITING_LEAD_IN = 0x7201,
SESSION_FIXATION_ERROR_WRITING_LEAD_OUT = 0x7202,
SESSION_FIXATION_ERROR_INCOMPLETE_TRACK_IN_SESSION = 0x7203,
EMPTY_OR_PARTIALLY_WRITTEN_RESERVED_TRACK = 0x7204,
NO_MORE_TRACK_RESERVATIONS_ALLOWED = 0x7205,
RMZ_EXTENSION_IS_NOT_ALLOWED = 0x7206,
NO_MORE_TEST_ZONE_EXTENSIONS_ARE_ALLOWED = 0x7207,
ASC(CD_CONTROL_ERROR, 0x73),
POWER_CALIBRATION_AREA_ALMOST_FULL = 0x7301,
POWER_CALIBRATION_AREA_IS_FULL = 0x7302,
POWER_CALIBRATION_AREA_ERROR = 0x7303,
PROGRAM_MEMORY_AREA_UPDATE_FAILURE = 0x7304,
PROGRAM_MEMORY_AREA_IS_FULL = 0x7305,
RMA_PMA_IS_ALMOST_FULL = 0x7306,
CURRENT_POWER_CALIBRATION_AREA_ALMOST_FULL = 0x7310,
CURRENT_POWER_CALIBRATION_AREA_IS_FULL = 0x7311,
RDZ_IS_FULL = 0x7317,
ASC(SECURITY_ERROR, 0x74),
UNABLE_TO_DECRYPT_DATA = 0x7401,
UNENCRYPTED_DATA_ENCOUNTERED_WHILE_DECRYPTING = 0x7402,
INCORRECT_DATA_ENCRYPTION_KEY = 0x7403,
CRYPTOGRAPHIC_INTEGRITY_VALIDATION_FAILED = 0x7404,
ERROR_DECRYPTING_DATA = 0x7405,
UNKNOWN_SIGNATURE_VERIFICATION_KEY = 0x7406,
ENCRYPTION_PARAMS_NOT_USEABLE = 0x7407,
DIGITAL_SIGNATURE_VALIDATION_FAILURE = 0x7408,
ENCRYPTION_MODE_MISMATCH_ON_READ = 0x7409,
ENCRYPTED_BLOCK_NOT_RAW_READ_ENABLED = 0x740A,
INCORRECT_ENCRYPTION_PARAMS = 0x740B,
UNABLE_TO_DECRYPT_PARAMETER_LIST = 0x740C,
ENCRYPTION_ALGORITHM_DISABLED = 0x740D,
SA_CREATION_PARAMETER_VALUE_INVALID = 0x7410,
SA_CREATION_PARAMETER_VALUE_REJECTED = 0x7411,
INVALID_SA_USAGE = 0x7412,
DATA_ENCRYPTION_CONFIG_PREVENTED = 0x7421,
SA_CREATION_PARAMETER_NOT_SUPPORTED = 0x7430,
AUTHENTICATION_FAILED = 0x7440,
EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ACCESS_ERROR = 0x7461,
EXTERNAL_DATA_ENCRYPTION_KEY_MANAGER_ERROR = 0x7462,
EXTERNAL_DATA_ENCRYPTION_KEY_NOT_FOUND = 0x7463,
EXTERNAL_DATA_ENCRYPTION_REQUEST_NOT_AUTHORIZED = 0x7464,
EXTERNAL_DATA_ENCRYPTION_CONTROL_TIMEOUT = 0x746E,
EXTERNAL_DATA_ENCRYPTION_CONTROL_ERROR = 0x746F,
LU_ACCESS_NOT_AUTHORIZED = 0x7471,
SECURITY_CONFLICT_IN_TRANSLATED_DEVICE = 0x7479,
};
#undef ASC_DEF
#undef ASC
/*
* Use this to build non-standard sense codes.
* Note: this is defined as a macro instead of an inline function so that it can
* be used to define SCSI failures array variables (see struct scsi_failure).
*/
#define scsi_sense_code(asc, ascq) \
((((asc) & 0xff) << 8) | ((ascq) & 0xff))
static inline u8 scsi_sense_code_asc(u16 code)
{
return (code >> 8) & 0xff;
}
static inline u8 scsi_sense_code_ascq(u16 code)
{
return code & 0xff;
}
#endif /* _SCSI_SENSE_H_ */

4
include/trace/events/scsi.h
View File

@ -303,8 +303,8 @@ DECLARE_EVENT_CLASS(scsi_cmd_done_timeout_template,
if (cmd->sense_buffer && SCSI_SENSE_VALID(cmd) &&
scsi_command_normalize_sense(cmd, &sshdr)) {
__entry->sense_key = sshdr.sense_key;
__entry->asc = sshdr.asc;
__entry->ascq = sshdr.ascq;
__entry->asc = scsi_sense_asc(&sshdr);
__entry->ascq = scsi_sense_ascq(&sshdr);
} else {
__entry->sense_key = 0;
__entry->asc = 0;