nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

scsi: core: Kill DRIVER_SENSE

Browse source 
Replace the check for DRIVER_SENSE with a check for
scsi_status_is_check_condition().

Audit all callsites to ensure the SAM status is set correctly. For
backwards compability move the DRIVER_SENSE definition to sg.h, and update
sg, bsg, and scsi_ioctl to set the DRIVER_SENSE driver_status whenever
SAM_STAT_CHECK_CONDITION is present.

[mkp: fix zeroday srp warning]

Link: https://lore.kernel.org/r/20210427083046.31620-10-hare@suse.de
Signed-off-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

fix
This commit is contained in:
Hannes Reinecke 2021-04-27 10:30:15 +02:00 committed by Martin K. Petersen
parent d0672a03e0
commit 464a00c9e0
35 changed files with 76 additions and 115 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

2
block/bsg.c
View file

@ -97,6 +97,8 @@ static int bsg_scsi_complete_rq(struct request *rq, struct sg_io_v4 *hdr)
hdr->device_status = sreq->result & 0xff; hdr->device_status = sreq->result & 0xff;
hdr->transport_status = host_byte(sreq->result); hdr->transport_status = host_byte(sreq->result);
hdr->driver_status = driver_byte(sreq->result); hdr->driver_status = driver_byte(sreq->result);
if (scsi_status_is_check_condition(sreq->result))
hdr->driver_status = DRIVER_SENSE;
hdr->info = 0; hdr->info = 0;
if (hdr->device_status || hdr->transport_status || hdr->driver_status) if (hdr->device_status || hdr->transport_status || hdr->driver_status)
hdr->info |= SG_INFO_CHECK; hdr->info |= SG_INFO_CHECK;

2
block/scsi_ioctl.c
View file

@ -257,6 +257,8 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
hdr->msg_status = msg_byte(req->result); hdr->msg_status = msg_byte(req->result);
hdr->host_status = host_byte(req->result); hdr->host_status = host_byte(req->result);
hdr->driver_status = driver_byte(req->result); hdr->driver_status = driver_byte(req->result);
if (scsi_status_is_check_condition(hdr->status))
hdr->driver_status = DRIVER_SENSE;
hdr->info = 0; hdr->info = 0;
if (hdr->masked_status || hdr->host_status || hdr->driver_status) if (hdr->masked_status || hdr->host_status || hdr->driver_status)
hdr->info |= SG_INFO_CHECK; hdr->info |= SG_INFO_CHECK;

13
drivers/ata/libata-scsi.c
View file

@ -411,13 +411,12 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
rc = cmd_result; rc = cmd_result;
goto error; goto error;
} }
if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */ if (scsi_sense_valid(&sshdr)) {/* sense data available */
u8 *desc = sensebuf + 8; u8 *desc = sensebuf + 8;
cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
/* If we set cc then ATA pass-through will cause a /* If we set cc then ATA pass-through will cause a
* check condition even if no error. Filter that. */ * check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) { if (scsi_status_is_check_condition(cmd_result)) {
if (sshdr.sense_key == RECOVERED_ERROR && if (sshdr.sense_key == RECOVERED_ERROR &&
sshdr.asc == 0 && sshdr.ascq == 0x1d) sshdr.asc == 0 && sshdr.ascq == 0x1d)
cmd_result &= ~SAM_STAT_CHECK_CONDITION; cmd_result &= ~SAM_STAT_CHECK_CONDITION;
@ -496,9 +495,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
rc = cmd_result; rc = cmd_result;
goto error; goto error;
} }
if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */ if (scsi_sense_valid(&sshdr)) {/* sense data available */
u8 *desc = sensebuf + 8; u8 *desc = sensebuf + 8;
cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
/* If we set cc then ATA pass-through will cause a /* If we set cc then ATA pass-through will cause a
* check condition even if no error. Filter that. */ * check condition even if no error. Filter that. */
@ -864,8 +862,6 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
memset(sb, 0, SCSI_SENSE_BUFFERSIZE); memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
/* /*
* Use ata_to_sense_error() to map status register bits * Use ata_to_sense_error() to map status register bits
* onto sense key, asc & ascq. * onto sense key, asc & ascq.
@ -962,8 +958,6 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
memset(sb, 0, SCSI_SENSE_BUFFERSIZE); memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
if (ata_dev_disabled(dev)) { if (ata_dev_disabled(dev)) {
/* Device disabled after error recovery */ /* Device disabled after error recovery */
/* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */ /* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */
@ -4201,7 +4195,6 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
case REQUEST_SENSE: case REQUEST_SENSE:
ata_scsi_set_sense(dev, cmd, 0, 0, 0); ata_scsi_set_sense(dev, cmd, 0, 0, 0);
cmd->result = (DRIVER_SENSE << 24);
break; break;
/* if we reach this, then writeback caching is disabled, /* if we reach this, then writeback caching is disabled,

2
drivers/scsi/NCR5380.c
View file

@ -542,7 +542,7 @@ static void complete_cmd(struct Scsi_Host *instance,
scsi_eh_restore_cmnd(cmd, &hostdata->ses); scsi_eh_restore_cmnd(cmd, &hostdata->ses);
} else { } else {
scsi_eh_restore_cmnd(cmd, &hostdata->ses); scsi_eh_restore_cmnd(cmd, &hostdata->ses);
set_driver_byte(cmd, DRIVER_SENSE); set_status_byte(cmd, SAM_STAT_CHECK_CONDITION);
} }
hostdata->sensing = NULL; hostdata->sensing = NULL;
} }

2
drivers/scsi/advansys.c
View file

@ -5964,7 +5964,6 @@ static void adv_isr_callback(ADV_DVC_VAR *adv_dvc_varp, ADV_SCSI_REQ_Q *scsiqp)
ASC_DBG(2, "SAM_STAT_CHECK_CONDITION\n"); ASC_DBG(2, "SAM_STAT_CHECK_CONDITION\n");
ASC_DBG_PRT_SENSE(2, scp->sense_buffer, ASC_DBG_PRT_SENSE(2, scp->sense_buffer,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
set_driver_byte(scp, DRIVER_SENSE);
} }
break; break;
@ -6715,7 +6714,6 @@ static void asc_isr_callback(ASC_DVC_VAR *asc_dvc_varp, ASC_QDONE_INFO *qdonep)
ASC_DBG(2, "SAM_STAT_CHECK_CONDITION\n"); ASC_DBG(2, "SAM_STAT_CHECK_CONDITION\n");
ASC_DBG_PRT_SENSE(2, scp->sense_buffer, ASC_DBG_PRT_SENSE(2, scp->sense_buffer,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
set_driver_byte(scp, DRIVER_SENSE);
} }
break; break;

19
drivers/scsi/aic7xxx/aic79xx_osm.c
View file

@ -1928,7 +1928,7 @@ ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
memcpy(cmd->sense_buffer, memcpy(cmd->sense_buffer,
ahd_get_sense_buf(ahd, scb) ahd_get_sense_buf(ahd, scb)
+ sense_offset, sense_size); + sense_offset, sense_size);
cmd->result |= (DRIVER_SENSE << 24); set_status_byte(cmd, SAM_STAT_CHECK_CONDITION);
#ifdef AHD_DEBUG #ifdef AHD_DEBUG
if (ahd_debug & AHD_SHOW_SENSE) { if (ahd_debug & AHD_SHOW_SENSE) {
@ -2018,6 +2018,7 @@ ahd_linux_queue_cmd_complete(struct ahd_softc *ahd, struct scsi_cmnd *cmd)
int new_status = DID_OK; int new_status = DID_OK;
int do_fallback = 0; int do_fallback = 0;
int scsi_status; int scsi_status;
struct scsi_sense_data *sense;
/* /*
* Map CAM error codes into Linux Error codes. We * Map CAM error codes into Linux Error codes. We
@ -2041,18 +2042,12 @@ ahd_linux_queue_cmd_complete(struct ahd_softc *ahd, struct scsi_cmnd *cmd)
switch(scsi_status) { switch(scsi_status) {
case SAM_STAT_COMMAND_TERMINATED: case SAM_STAT_COMMAND_TERMINATED:
case SAM_STAT_CHECK_CONDITION: case SAM_STAT_CHECK_CONDITION:
if ((cmd->result >> 24) != DRIVER_SENSE) { sense = (struct scsi_sense_data *)
cmd->sense_buffer;
if (sense->extra_len >= 5 &&
(sense->add_sense_code == 0x47
|| sense->add_sense_code == 0x48))
do_fallback = 1; do_fallback = 1;
} else {
struct scsi_sense_data *sense;
sense = (struct scsi_sense_data *)
cmd->sense_buffer;
if (sense->extra_len >= 5 &&
(sense->add_sense_code == 0x47
|| sense->add_sense_code == 0x48))
do_fallback = 1;
}
break; break;
default: default:
break; break;

1
drivers/scsi/aic7xxx/aic7xxx_osm.c
View file

@ -1838,7 +1838,6 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
if (sense_size < SCSI_SENSE_BUFFERSIZE) if (sense_size < SCSI_SENSE_BUFFERSIZE)
memset(&cmd->sense_buffer[sense_size], 0, memset(&cmd->sense_buffer[sense_size], 0,
SCSI_SENSE_BUFFERSIZE - sense_size); SCSI_SENSE_BUFFERSIZE - sense_size);
cmd->result |= (DRIVER_SENSE << 24);
#ifdef AHC_DEBUG #ifdef AHC_DEBUG
if (ahc_debug & AHC_SHOW_SENSE) { if (ahc_debug & AHC_SHOW_SENSE) {
int i; int i;

1
drivers/scsi/arcmsr/arcmsr_hba.c
View file

@ -1335,7 +1335,6 @@ static void arcmsr_report_sense_info(struct CommandControlBlock *ccb)
memcpy(sensebuffer, ccb->arcmsr_cdb.SenseData, sense_data_length); memcpy(sensebuffer, ccb->arcmsr_cdb.SenseData, sense_data_length);
sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS; sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
sensebuffer->Valid = 1; sensebuffer->Valid = 1;
pcmd->result |= (DRIVER_SENSE << 24);
} }
} }

2
drivers/scsi/ch.c
View file

@ -200,7 +200,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
MAX_RETRIES, NULL); MAX_RETRIES, NULL);
if (result < 0) if (result < 0)
return result; return result;
if (driver_byte(result) == DRIVER_SENSE) { if (scsi_sense_valid(&sshdr)) {
if (debug) if (debug)
scsi_print_sense_hdr(ch->device, ch->name, &sshdr); scsi_print_sense_hdr(ch->device, ch->name, &sshdr);
errno = ch_find_errno(&sshdr); errno = ch_find_errno(&sshdr);

3
drivers/scsi/cxlflash/superpipe.c
View file

@ -369,8 +369,7 @@ static int read_cap16(struct scsi_device *sdev, struct llun_info *lli)
goto out; goto out;
} }
if (result > 0 && driver_byte(result) == DRIVER_SENSE) { if (result > 0 && scsi_sense_valid(&sshdr)) {
result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
if (result & SAM_STAT_CHECK_CONDITION) { if (result & SAM_STAT_CHECK_CONDITION) {
switch (sshdr.sense_key) { switch (sshdr.sense_key) {
case NO_SENSE: case NO_SENSE:

13
drivers/scsi/dc395x.c
View file

@ -3239,16 +3239,9 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
} }
dprintkdbg(DBG_0, "srb_done: AUTO_REQSENSE2\n"); dprintkdbg(DBG_0, "srb_done: AUTO_REQSENSE2\n");
if (srb->total_xfer_length cmd->result =
&& srb->total_xfer_length >= cmd->underflow) MK_RES(0, DID_OK,
cmd->result = srb->end_message, SAM_STAT_CHECK_CONDITION);
MK_RES_LNX(DRIVER_SENSE, DID_OK,
srb->end_message, CHECK_CONDITION);
/*SET_RES_DID(cmd->result,DID_OK) */
else
cmd->result =
MK_RES_LNX(DRIVER_SENSE, DID_OK,
srb->end_message, CHECK_CONDITION);
goto ckc_e; goto ckc_e;
} }

4
drivers/scsi/esp_scsi.c
View file

@ -922,9 +922,7 @@ static void esp_cmd_is_done(struct esp *esp, struct esp_cmd_entry *ent,
* saw originally. Also, report that we are providing * saw originally. Also, report that we are providing
* the sense data. * the sense data.
*/ */
cmd->result = ((DRIVER_SENSE << 24) | cmd->result = SAM_STAT_CHECK_CONDITION;
(DID_OK << 16) |
(SAM_STAT_CHECK_CONDITION << 0));
ent->flags &= ~ESP_CMD_FLAG_AUTOSENSE; ent->flags &= ~ESP_CMD_FLAG_AUTOSENSE;
if (esp_debug & ESP_DEBUG_AUTOSENSE) { if (esp_debug & ESP_DEBUG_AUTOSENSE) {

8
drivers/scsi/megaraid.c
View file

@ -1583,9 +1583,7 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
memcpy(cmd->sense_buffer, pthru->reqsensearea, memcpy(cmd->sense_buffer, pthru->reqsensearea,
14); 14);
cmd->result = (DRIVER_SENSE << 24) | cmd->result = SAM_STAT_CHECK_CONDITION;
(DID_OK << 16) |
(CHECK_CONDITION << 1);
} }
else { else {
if (mbox->m_out.cmd == MEGA_MBOXCMD_EXTPTHRU) { if (mbox->m_out.cmd == MEGA_MBOXCMD_EXTPTHRU) {
@ -1593,9 +1591,7 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
memcpy(cmd->sense_buffer, memcpy(cmd->sense_buffer,
epthru->reqsensearea, 14); epthru->reqsensearea, 14);
cmd->result = (DRIVER_SENSE << 24) | cmd->result = SAM_STAT_CHECK_CONDITION;
(DID_OK << 16) |
(CHECK_CONDITION << 1);
} else } else
scsi_build_sense(cmd, 0, scsi_build_sense(cmd, 0,
ABORTED_COMMAND, 0, 0); ABORTED_COMMAND, 0, 0);

7
drivers/scsi/megaraid/megaraid_mbox.c
View file

@ -2299,8 +2299,7 @@ megaraid_mbox_dpc(unsigned long devp)
memcpy(scp->sense_buffer, pthru->reqsensearea, memcpy(scp->sense_buffer, pthru->reqsensearea,
14); 14);
scp->result = DRIVER_SENSE << 24 | scp->result = SAM_STAT_CHECK_CONDITION;
DID_OK << 16 | CHECK_CONDITION << 1;
} }
else { else {
if (mbox->cmd == MBOXCMD_EXTPTHRU) { if (mbox->cmd == MBOXCMD_EXTPTHRU) {
@ -2308,9 +2307,7 @@ megaraid_mbox_dpc(unsigned long devp)
memcpy(scp->sense_buffer, memcpy(scp->sense_buffer,
epthru->reqsensearea, 14); epthru->reqsensearea, 14);
scp->result = DRIVER_SENSE << 24 | scp->result = SAM_STAT_CHECK_CONDITION;
DID_OK << 16 |
CHECK_CONDITION << 1;
} else } else
scsi_build_sense(scp, 0, scsi_build_sense(scp, 0,
ABORTED_COMMAND, 0, 0); ABORTED_COMMAND, 0, 0);

2
drivers/scsi/megaraid/megaraid_sas_base.c
View file

@ -3617,8 +3617,6 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
memcpy(cmd->scmd->sense_buffer, cmd->sense, memcpy(cmd->scmd->sense_buffer, cmd->sense,
hdr->sense_len); hdr->sense_len);
cmd->scmd->result |= DRIVER_SENSE << 24;
} }
break; break;

1
drivers/scsi/megaraid/megaraid_sas_fusion.c
View file

@ -2051,7 +2051,6 @@ map_cmd_status(struct fusion_context *fusion,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
memcpy(scmd->sense_buffer, sense, memcpy(scmd->sense_buffer, sense,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
scmd->result |= DRIVER_SENSE << 24;
} }
/* /*

1
drivers/scsi/mvumi.c
View file

@ -1317,7 +1317,6 @@ static void mvumi_complete_cmd(struct mvumi_hba *mhba, struct mvumi_cmd *cmd,
if (ob_frame->rsp_flag & CL_RSP_FLAG_SENSEDATA) { if (ob_frame->rsp_flag & CL_RSP_FLAG_SENSEDATA) {
memcpy(cmd->scmd->sense_buffer, ob_frame->payload, memcpy(cmd->scmd->sense_buffer, ob_frame->payload,
sizeof(struct mvumi_sense_data)); sizeof(struct mvumi_sense_data));
scmd->result |= (DRIVER_SENSE << 24);
} }
break; break;
default: default:

7
drivers/scsi/scsi.c
View file

@ -185,13 +185,6 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
if (atomic_read(&sdev->device_blocked)) if (atomic_read(&sdev->device_blocked))
atomic_set(&sdev->device_blocked, 0); atomic_set(&sdev->device_blocked, 0);
/*
* If we have valid sense information, then some kind of recovery
* must have taken place. Make a note of this.
*/
if (SCSI_SENSE_VALID(cmd))
cmd->result |= (DRIVER_SENSE << 24);
SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev, SCSI_LOG_MLCOMPLETE(4, sdev_printk(KERN_INFO, sdev,
"Notifying upper driver of completion " "Notifying upper driver of completion "
"(result %x)\n", cmd->result)); "(result %x)\n", cmd->result));

4
drivers/scsi/scsi_debug.c
View file

@ -851,10 +851,10 @@ static struct device_driver sdebug_driverfs_driver = {
}; };
static const int check_condition_result = static const int check_condition_result =
(DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION; SAM_STAT_CHECK_CONDITION;
static const int illegal_condition_result = static const int illegal_condition_result =
(DRIVER_SENSE << 24) | (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION; (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
static const int device_qfull_result = static const int device_qfull_result =
(DID_OK << 16) | SAM_STAT_TASK_SET_FULL; (DID_OK << 16) | SAM_STAT_TASK_SET_FULL;

3
drivers/scsi/scsi_ioctl.c
View file

@ -103,8 +103,7 @@ static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
if (result < 0) if (result < 0)
goto out; goto out;
if (driver_byte(result) == DRIVER_SENSE && if (scsi_sense_valid(&sshdr)) {
scsi_sense_valid(&sshdr)) {
switch (sshdr.sense_key) { switch (sshdr.sense_key) {
case ILLEGAL_REQUEST: case ILLEGAL_REQUEST:
if (cmd[0] == ALLOW_MEDIUM_REMOVAL) if (cmd[0] == ALLOW_MEDIUM_REMOVAL)

10
drivers/scsi/scsi_lib.c
View file

@ -593,8 +593,6 @@ static blk_status_t scsi_result_to_blk_status(struct scsi_cmnd *cmd, int result)
case DID_OK: case DID_OK:
/* /*
* Also check the other bytes than the status byte in result * Also check the other bytes than the status byte in result
* to handle the case when a SCSI LLD sets result to
* DRIVER_SENSE << 24 without setting SAM_STAT_CHECK_CONDITION.
*/ */
if (scsi_status_is_good(result) && (result & ~0xff) == 0) if (scsi_status_is_good(result) && (result & ~0xff) == 0)
return BLK_STS_OK; return BLK_STS_OK;
@ -790,7 +788,7 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
*/ */
if (!level && __ratelimit(&_rs)) { if (!level && __ratelimit(&_rs)) {
scsi_print_result(cmd, NULL, FAILED); scsi_print_result(cmd, NULL, FAILED);
if (driver_byte(result) == DRIVER_SENSE) if (sense_valid)
scsi_print_sense(cmd); scsi_print_sense(cmd);
scsi_print_command(cmd); scsi_print_command(cmd);
} }
@ -2152,8 +2150,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
* ILLEGAL REQUEST if the code page isn't supported */ * ILLEGAL REQUEST if the code page isn't supported */
if (!scsi_status_is_good(result)) { if (!scsi_status_is_good(result)) {
if (driver_byte(result) == DRIVER_SENSE && if (scsi_sense_valid(sshdr)) {
scsi_sense_valid(sshdr)) {
if ((sshdr->sense_key == ILLEGAL_REQUEST) && if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
(sshdr->asc == 0x20) && (sshdr->ascq == 0)) { (sshdr->asc == 0x20) && (sshdr->ascq == 0)) {
/* /*
@ -3236,7 +3233,6 @@ EXPORT_SYMBOL(scsi_vpd_tpg_id);
void scsi_build_sense(struct scsi_cmnd *scmd, int desc, u8 key, u8 asc, u8 ascq) void scsi_build_sense(struct scsi_cmnd *scmd, int desc, u8 key, u8 asc, u8 ascq)
{ {
scsi_build_sense_buffer(desc, scmd->sense_buffer, key, asc, ascq); scsi_build_sense_buffer(desc, scmd->sense_buffer, key, asc, ascq);
scmd->result = (DRIVER_SENSE << 24) | (DID_OK << 16) | scmd->result = SAM_STAT_CHECK_CONDITION;
SAM_STAT_CHECK_CONDITION;
} }
EXPORT_SYMBOL_GPL(scsi_build_sense); EXPORT_SYMBOL_GPL(scsi_build_sense);

2
drivers/scsi/scsi_scan.c
View file

@ -623,7 +623,7 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
* INQUIRY should not yield UNIT_ATTENTION * INQUIRY should not yield UNIT_ATTENTION
* but many buggy devices do so anyway. * but many buggy devices do so anyway.
*/ */
if (driver_byte(result) == DRIVER_SENSE && if (scsi_status_is_check_condition(result) &&
scsi_sense_valid(&sshdr)) { scsi_sense_valid(&sshdr)) {
if ((sshdr.sense_key == UNIT_ATTENTION) && if ((sshdr.sense_key == UNIT_ATTENTION) &&
((sshdr.asc == 0x28) || ((sshdr.asc == 0x28) ||

2
drivers/scsi/scsi_transport_spi.c
View file

@ -127,7 +127,7 @@ static int spi_execute(struct scsi_device *sdev, const void *cmd,
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_TRANSPORT |
REQ_FAILFAST_DRIVER, REQ_FAILFAST_DRIVER,
RQF_PM, NULL); RQF_PM, NULL);
if (result < 0 || driver_byte(result) != DRIVER_SENSE || if (result < 0 || !scsi_sense_valid(sshdr) ||
sshdr->sense_key != UNIT_ATTENTION) sshdr->sense_key != UNIT_ATTENTION)
break; break;
} }

33
drivers/scsi/sd.c
View file

@ -1722,16 +1722,17 @@ static int sd_sync_cache(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
if (res < 0) if (res < 0)
return res; return res;
if (driver_byte(res) == DRIVER_SENSE) if (scsi_status_is_check_condition(res) &&
scsi_sense_valid(sshdr)) {
sd_print_sense_hdr(sdkp, sshdr); sd_print_sense_hdr(sdkp, sshdr);
/* we need to evaluate the error return */ /* we need to evaluate the error return */
if (scsi_sense_valid(sshdr) && if (sshdr->asc == 0x3a || /* medium not present */
(sshdr->asc == 0x3a || /* medium not present */ sshdr->asc == 0x20 || /* invalid command */
sshdr->asc == 0x20 || /* invalid command */ (sshdr->asc == 0x74 && sshdr->ascq == 0x71)) /* drive is password locked */
(sshdr->asc == 0x74 && sshdr->ascq == 0x71))) /* drive is password locked */
/* this is no error here */ /* this is no error here */
return 0; return 0;
}
switch (host_byte(res)) { switch (host_byte(res)) {
/* ignore errors due to racing a disconnection */ /* ignore errors due to racing a disconnection */
@ -1828,7 +1829,7 @@ static int sd_pr_command(struct block_device *bdev, u8 sa,
result = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, &data, sizeof(data), result = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, &data, sizeof(data),
&sshdr, SD_TIMEOUT, sdkp->max_retries, NULL); &sshdr, SD_TIMEOUT, sdkp->max_retries, NULL);
if (result > 0 && driver_byte(result) == DRIVER_SENSE && if (scsi_status_is_check_condition(result) &&
scsi_sense_valid(&sshdr)) { scsi_sense_valid(&sshdr)) {
sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result); sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result);
scsi_print_sense_hdr(sdev, NULL, &sshdr); scsi_print_sense_hdr(sdev, NULL, &sshdr);
@ -2072,7 +2073,7 @@ static int sd_done(struct scsi_cmnd *SCpnt)
} }
sdkp->medium_access_timed_out = 0; sdkp->medium_access_timed_out = 0;
if (driver_byte(result) != DRIVER_SENSE && if (!scsi_status_is_check_condition(result) &&
(!sense_valid || sense_deferred)) (!sense_valid || sense_deferred))
goto out; goto out;
@ -2175,12 +2176,12 @@ sd_spinup_disk(struct scsi_disk *sdkp)
if (the_result) if (the_result)
sense_valid = scsi_sense_valid(&sshdr); sense_valid = scsi_sense_valid(&sshdr);
retries++; retries++;
} while (retries < 3 && } while (retries < 3 &&
(!scsi_status_is_good(the_result) || (!scsi_status_is_good(the_result) ||
((driver_byte(the_result) == DRIVER_SENSE) && (scsi_status_is_check_condition(the_result) &&
sense_valid && sshdr.sense_key == UNIT_ATTENTION))); sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
if (the_result < 0 || driver_byte(the_result) != DRIVER_SENSE) { if (!scsi_status_is_check_condition(the_result)) {
/* no sense, TUR either succeeded or failed /* no sense, TUR either succeeded or failed
* with a status error */ * with a status error */
if(!spintime && !scsi_status_is_good(the_result)) { if(!spintime && !scsi_status_is_good(the_result)) {
@ -2308,7 +2309,7 @@ static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
struct scsi_sense_hdr *sshdr, int sense_valid, struct scsi_sense_hdr *sshdr, int sense_valid,
int the_result) int the_result)
{ {
if (driver_byte(the_result) == DRIVER_SENSE) if (sense_valid)
sd_print_sense_hdr(sdkp, sshdr); sd_print_sense_hdr(sdkp, sshdr);
else else
sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n"); sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
@ -3594,12 +3595,12 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
SD_TIMEOUT, sdkp->max_retries, 0, RQF_PM, NULL); SD_TIMEOUT, sdkp->max_retries, 0, RQF_PM, NULL);
if (res) { if (res) {
sd_print_result(sdkp, "Start/Stop Unit failed", res); sd_print_result(sdkp, "Start/Stop Unit failed", res);
if (res > 0 && driver_byte(res) == DRIVER_SENSE) if (res > 0 && scsi_sense_valid(&sshdr)) {
sd_print_sense_hdr(sdkp, &sshdr); sd_print_sense_hdr(sdkp, &sshdr);
if (scsi_sense_valid(&sshdr) &&
/* 0x3a is medium not present */ /* 0x3a is medium not present */
sshdr.asc == 0x3a) if (sshdr.asc == 0x3a)
res = 0; res = 0;
}
} }
/* SCSI error codes must not go to the generic layer */ /* SCSI error codes must not go to the generic layer */

3
drivers/scsi/sd_zbc.c
View file

@ -116,8 +116,7 @@ static int sd_zbc_do_report_zones(struct scsi_disk *sdkp, unsigned char *buf,
sd_printk(KERN_ERR, sdkp, sd_printk(KERN_ERR, sdkp,
"REPORT ZONES start lba %llu failed\n", lba); "REPORT ZONES start lba %llu failed\n", lba);
sd_print_result(sdkp, "REPORT ZONES", result); sd_print_result(sdkp, "REPORT ZONES", result);
if (result > 0 && driver_byte(result) == DRIVER_SENSE && if (result > 0 && scsi_sense_valid(&sshdr))
scsi_sense_valid(&sshdr))
sd_print_sense_hdr(sdkp, &sshdr); sd_print_sense_hdr(sdkp, &sshdr);
return -EIO; return -EIO;
} }

7
drivers/scsi/sg.c
View file

@ -498,9 +498,11 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
old_hdr->host_status = hp->host_status; old_hdr->host_status = hp->host_status;
old_hdr->driver_status = hp->driver_status; old_hdr->driver_status = hp->driver_status;
if ((CHECK_CONDITION & hp->masked_status) || if ((CHECK_CONDITION & hp->masked_status) ||
(DRIVER_SENSE & hp->driver_status)) (srp->sense_b[0] & 0x70) == 0x70) {
old_hdr->driver_status = DRIVER_SENSE;
memcpy(old_hdr->sense_buffer, srp->sense_b, memcpy(old_hdr->sense_buffer, srp->sense_b,
sizeof (old_hdr->sense_buffer)); sizeof (old_hdr->sense_buffer));
}
switch (hp->host_status) { switch (hp->host_status) {
/* This setup of 'result' is for backward compatibility and is best /* This setup of 'result' is for backward compatibility and is best
ignored by the user who should use target, host + driver status */ ignored by the user who should use target, host + driver status */
@ -574,7 +576,7 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
hp->sb_len_wr = 0; hp->sb_len_wr = 0;
if ((hp->mx_sb_len > 0) && hp->sbp) { if ((hp->mx_sb_len > 0) && hp->sbp) {
if ((CHECK_CONDITION & hp->masked_status) || if ((CHECK_CONDITION & hp->masked_status) ||
(DRIVER_SENSE & hp->driver_status)) { (srp->sense_b[0] & 0x70) == 0x70) {
int sb_len = SCSI_SENSE_BUFFERSIZE; int sb_len = SCSI_SENSE_BUFFERSIZE;
sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len; sb_len = (hp->mx_sb_len > sb_len) ? sb_len : hp->mx_sb_len;
len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */ len = 8 + (int) srp->sense_b[7]; /* Additional sense length field */
@ -583,6 +585,7 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
err = -EFAULT; err = -EFAULT;
goto err_out; goto err_out;
} }
hp->driver_status = DRIVER_SENSE;
hp->sb_len_wr = len; hp->sb_len_wr = len;
} }
} }

4
drivers/scsi/stex.c
View file

@ -737,7 +737,7 @@ static void stex_scsi_done(struct st_ccb *ccb)
result |= DID_OK << 16; result |= DID_OK << 16;
break; break;
case SAM_STAT_CHECK_CONDITION: case SAM_STAT_CHECK_CONDITION:
result |= DRIVER_SENSE << 24; result |= DID_OK << 16;
break; break;
case SAM_STAT_BUSY: case SAM_STAT_BUSY:
result |= DID_BUS_BUSY << 16; result |= DID_BUS_BUSY << 16;
@ -748,7 +748,7 @@ static void stex_scsi_done(struct st_ccb *ccb)
} }
} }
else if (ccb->srb_status & SRB_SEE_SENSE) else if (ccb->srb_status & SRB_SEE_SENSE)
result = DRIVER_SENSE << 24 | SAM_STAT_CHECK_CONDITION; result = SAM_STAT_CHECK_CONDITION;
else switch (ccb->srb_status) { else switch (ccb->srb_status) {
case SRB_STATUS_SELECTION_TIMEOUT: case SRB_STATUS_SELECTION_TIMEOUT:
result = DID_NO_CONNECT << 16; result = DID_NO_CONNECT << 16;

6
drivers/scsi/sym53c8xx_2/sym_glue.c
View file

@ -170,9 +170,8 @@ static int sym_xerr_cam_status(int cam_status, int x_status)
void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid) void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
{ {
struct scsi_cmnd *cmd = cp->cmd; struct scsi_cmnd *cmd = cp->cmd;
u_int cam_status, scsi_status, drv_status; u_int cam_status, scsi_status;
drv_status = 0;
cam_status = DID_OK; cam_status = DID_OK;
scsi_status = cp->ssss_status; scsi_status = cp->ssss_status;
@ -186,7 +185,6 @@ void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
cp->xerr_status == 0) { cp->xerr_status == 0) {
cam_status = sym_xerr_cam_status(DID_OK, cam_status = sym_xerr_cam_status(DID_OK,
cp->sv_xerr_status); cp->sv_xerr_status);
drv_status = DRIVER_SENSE;
/* /*
* Bounce back the sense data to user. * Bounce back the sense data to user.
*/ */
@ -235,7 +233,7 @@ void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
cam_status = sym_xerr_cam_status(DID_ERROR, cp->xerr_status); cam_status = sym_xerr_cam_status(DID_ERROR, cp->xerr_status);
} }
scsi_set_resid(cmd, resid); scsi_set_resid(cmd, resid);
cmd->result = (drv_status << 24) | (cam_status << 16) | scsi_status; cmd->result = (cam_status << 16) | scsi_status;
} }
static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd) static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd *cmd)

2
drivers/scsi/ufs/ufshcd.c
View file

@ -8604,7 +8604,7 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
sdev_printk(KERN_WARNING, sdp, sdev_printk(KERN_WARNING, sdp,
"START_STOP failed for power mode: %d, result %x\n", "START_STOP failed for power mode: %d, result %x\n",
pwr_mode, ret); pwr_mode, ret);
if (ret > 0 && driver_byte(ret) == DRIVER_SENSE) if (ret > 0 && scsi_sense_valid(&sshdr))
scsi_print_sense_hdr(sdp, NULL, &sshdr); scsi_print_sense_hdr(sdp, NULL, &sshdr);
} }

3
drivers/scsi/virtio_scsi.c
View file

@ -161,8 +161,7 @@ static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
min_t(u32, min_t(u32,
virtio32_to_cpu(vscsi->vdev, resp->sense_len), virtio32_to_cpu(vscsi->vdev, resp->sense_len),
VIRTIO_SCSI_SENSE_SIZE)); VIRTIO_SCSI_SENSE_SIZE));
if (resp->sense_len) set_status_byte(sc, SAM_STAT_CHECK_CONDITION);
set_driver_byte(sc, DRIVER_SENSE);
} }
sc->scsi_done(sc); sc->scsi_done(sc);

3
drivers/scsi/vmw_pvscsi.c
View file

@ -576,9 +576,6 @@ static void pvscsi_complete_request(struct pvscsi_adapter *adapter,
cmd->result = (DID_RESET << 16); cmd->result = (DID_RESET << 16);
} else { } else {
cmd->result = (DID_OK << 16) | sdstat; cmd->result = (DID_OK << 16) | sdstat;
if (sdstat == SAM_STAT_CHECK_CONDITION &&
cmd->sense_buffer)
cmd->result |= (DRIVER_SENSE << 24);
} }
} else } else
switch (btstat) { switch (btstat) {

1
drivers/target/loopback/tcm_loop.c
View file

@ -566,7 +566,6 @@ static int tcm_loop_queue_data_or_status(const char *func,
memcpy(sc->sense_buffer, se_cmd->sense_buffer, memcpy(sc->sense_buffer, se_cmd->sense_buffer,
SCSI_SENSE_BUFFERSIZE); SCSI_SENSE_BUFFERSIZE);
sc->result = SAM_STAT_CHECK_CONDITION; sc->result = SAM_STAT_CHECK_CONDITION;
set_driver_byte(sc, DRIVER_SENSE);
} else } else
sc->result = scsi_status; sc->result = scsi_status;

4
drivers/usb/storage/cypress_atacb.c
View file

@ -221,11 +221,11 @@ static void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
desc[12] = regs[6]; /* device */ desc[12] = regs[6]; /* device */
desc[13] = regs[7]; /* command */ desc[13] = regs[7]; /* command */
srb->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION; srb->result = SAM_STAT_CHECK_CONDITION;
} }
goto end; goto end;
invalid_fld: invalid_fld:
srb->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION; srb->result = SAM_STAT_CHECK_CONDITION;
memcpy(srb->sense_buffer, memcpy(srb->sense_buffer,
usb_stor_sense_invalidCDB, usb_stor_sense_invalidCDB,

3
drivers/xen/xen-scsiback.c
View file

@ -1401,8 +1401,7 @@ static int scsiback_queue_status(struct se_cmd *se_cmd)
if (se_cmd->sense_buffer && if (se_cmd->sense_buffer &&
((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) || ((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||
(se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE))) (se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE)))
pending_req->result = (DRIVER_SENSE << 24) | pending_req->result = SAM_STAT_CHECK_CONDITION;
SAM_STAT_CHECK_CONDITION;
else else
pending_req->result = se_cmd->scsi_status; pending_req->result = se_cmd->scsi_status;

11
include/scsi/sg.h
View file

@ -131,6 +131,17 @@ struct compat_sg_io_hdr {
#define SG_INFO_DIRECT_IO 0x2 /* direct IO requested and performed */ #define SG_INFO_DIRECT_IO 0x2 /* direct IO requested and performed */
#define SG_INFO_MIXED_IO 0x4 /* part direct, part indirect IO */ #define SG_INFO_MIXED_IO 0x4 /* part direct, part indirect IO */
/*
* Obsolete DRIVER_SENSE driver byte
*
* Originally the SCSI midlayer would set the DRIVER_SENSE driver byte when
* a sense code was generated and a sense buffer was allocated.
* However, as nowadays every scsi command has a sense code allocated this
* distinction became moot as one could check the sense buffer directly.
* Consequently this byte is not set anymore from the midlayer, but SG will
* keep setting this byte to be compatible with previous releases.
*/
#define DRIVER_SENSE 0x08
typedef struct sg_scsi_id { /* used by SG_GET_SCSI_ID ioctl() */ typedef struct sg_scsi_id { /* used by SG_GET_SCSI_ID ioctl() */
int host_no; /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */ int host_no; /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */