scsi: core: Kill DRIVER_SENSE

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

diff --git a/block/bsg.c b/block/bsg.c
index bd10922..9e6ff0d 100644 (file)
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -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->transport_status = host_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;
        if (hdr->device_status || hdr->transport_status || hdr->driver_status)
                hdr->info |= SG_INFO_CHECK;

diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index 48bb4e1..eb65bcd 100644 (file)
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -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->host_status = host_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;
        if (hdr->masked_status || hdr->host_status || hdr->driver_status)
                hdr->info |= SG_INFO_CHECK;

diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 61e15a2..31b47ad 100644 (file)
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -411,13 +411,12 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
                rc = cmd_result;
                goto error;
        }
-       if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
+       if (scsi_sense_valid(&sshdr)) {/* sense data available */
                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
                 * 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 &&
                            sshdr.asc == 0 && sshdr.ascq == 0x1d)
                                cmd_result &= ~SAM_STAT_CHECK_CONDITION;
@@ -496,9 +495,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
                rc = cmd_result;
                goto error;
        }
-       if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
+       if (scsi_sense_valid(&sshdr)) {/* sense data available */
                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
                 * 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);
 
-       cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
-
        /*
         * Use ata_to_sense_error() to map status register bits
         * 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);
 
-       cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
-
        if (ata_dev_disabled(dev)) {
                /* Device disabled after error recovery */
                /* 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:
                ata_scsi_set_sense(dev, cmd, 0, 0, 0);
-               cmd->result = (DRIVER_SENSE << 24);
                break;
 
        /* if we reach this, then writeback caching is disabled,

diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index 2ddbcaa..d7594b7 100644 (file)
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -542,7 +542,7 @@ static void complete_cmd(struct Scsi_Host *instance,
                        scsi_eh_restore_cmnd(cmd, &hostdata->ses);
                } else {
                        scsi_eh_restore_cmnd(cmd, &hostdata->ses);
-                       set_driver_byte(cmd, DRIVER_SENSE);
+                       set_status_byte(cmd, SAM_STAT_CHECK_CONDITION);
                }
                hostdata->sensing = NULL;
        }

diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 800052f..379ff1b 100644 (file)
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -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_PRT_SENSE(2, scp->sense_buffer,
                                                  SCSI_SENSE_BUFFERSIZE);
-                               set_driver_byte(scp, DRIVER_SENSE);
                        }
                        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_PRT_SENSE(2, scp->sense_buffer,
                                                  SCSI_SENSE_BUFFERSIZE);
-                               set_driver_byte(scp, DRIVER_SENSE);
                        }
                        break;
 

diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 4f7102f..92ea24a 100644 (file)
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -1928,7 +1928,7 @@ ahd_linux_handle_scsi_status(struct ahd_softc *ahd,
                        memcpy(cmd->sense_buffer,
                               ahd_get_sense_buf(ahd, scb)
                               + sense_offset, sense_size);
-                       cmd->result |= (DRIVER_SENSE << 24);
+                       set_status_byte(cmd, SAM_STAT_CHECK_CONDITION);
 
 #ifdef AHD_DEBUG
                        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 do_fallback = 0;
        int scsi_status;
+       struct scsi_sense_data *sense;
 
        /*
         * 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) {
                case SAM_STAT_COMMAND_TERMINATED:
                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;
-                       } 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;
                default:
                        break;

diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index d33f5a0..8b3d472 100644 (file)
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -1838,7 +1838,6 @@ ahc_linux_handle_scsi_status(struct ahc_softc *ahc,
                        if (sense_size < SCSI_SENSE_BUFFERSIZE)
                                memset(&cmd->sense_buffer[sense_size], 0,
                                       SCSI_SENSE_BUFFERSIZE - sense_size);
-                       cmd->result |= (DRIVER_SENSE << 24);
 #ifdef AHC_DEBUG
                        if (ahc_debug & AHC_SHOW_SENSE) {
                                int i;

diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 42e494a..c01a5b2 100644 (file)
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -1335,7 +1335,6 @@ static void arcmsr_report_sense_info(struct CommandControlBlock *ccb)
                memcpy(sensebuffer, ccb->arcmsr_cdb.SenseData, sense_data_length);
                sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
                sensebuffer->Valid = 1;
-               pcmd->result |= (DRIVER_SENSE << 24);
        }
 }
 

diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index d5990f6..fc7197a 100644 (file)
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -200,7 +200,7 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
                                  MAX_RETRIES, NULL);
        if (result < 0)
                return result;
-       if (driver_byte(result) == DRIVER_SENSE) {
+       if (scsi_sense_valid(&sshdr)) {
                if (debug)
                        scsi_print_sense_hdr(ch->device, ch->name, &sshdr);
                errno = ch_find_errno(&sshdr);

diff --git a/drivers/scsi/cxlflash/superpipe.c b/drivers/scsi/cxlflash/superpipe.c
index caa7c5f..df0ebab 100644 (file)
--- a/drivers/scsi/cxlflash/superpipe.c
+++ b/drivers/scsi/cxlflash/superpipe.c
@@ -369,8 +369,7 @@ retry:
                goto out;
        }
 
-       if (result > 0 && driver_byte(result) == DRIVER_SENSE) {
-               result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
+       if (result > 0 && scsi_sense_valid(&sshdr)) {
                if (result & SAM_STAT_CHECK_CONDITION) {
                        switch (sshdr.sense_key) {
                        case NO_SENSE:

diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index be87d5a..a713fe6 100644 (file)
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -3239,16 +3239,9 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
                }
                dprintkdbg(DBG_0, "srb_done: AUTO_REQSENSE2\n");
 
-               if (srb->total_xfer_length
-                   && srb->total_xfer_length >= cmd->underflow)
-                       cmd->result =
-                           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);
+               cmd->result =
+                   MK_RES(0, DID_OK,
+                          srb->end_message, SAM_STAT_CHECK_CONDITION);
 
                goto ckc_e;
        }

diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index 342535a..9a8c037 100644 (file)
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -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
                 * the sense data.
                 */
-               cmd->result = ((DRIVER_SENSE << 24) |
-                              (DID_OK << 16) |
-                              (SAM_STAT_CHECK_CONDITION << 0));
+               cmd->result = SAM_STAT_CHECK_CONDITION;
 
                ent->flags &= ~ESP_CMD_FLAG_AUTOSENSE;
                if (esp_debug & ESP_DEBUG_AUTOSENSE) {

diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index ae3f32f..1880471 100644 (file)
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1583,9 +1583,7 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
                                memcpy(cmd->sense_buffer, pthru->reqsensearea,
                                                14);
 
-                               cmd->result = (DRIVER_SENSE << 24) |
-                                       (DID_OK << 16) |
-                                       (CHECK_CONDITION << 1);
+                               cmd->result = SAM_STAT_CHECK_CONDITION;
                        }
                        else {
                                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,
                                                epthru->reqsensearea, 14);
 
-                                       cmd->result = (DRIVER_SENSE << 24) |
-                                               (DID_OK << 16) |
-                                               (CHECK_CONDITION << 1);
+                                       cmd->result = SAM_STAT_CHECK_CONDITION;
                                } else
                                        scsi_build_sense(cmd, 0,
                                                         ABORTED_COMMAND, 0, 0);

diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 44154e1..bb8b2fb 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2299,8 +2299,7 @@ megaraid_mbox_dpc(unsigned long devp)
                                memcpy(scp->sense_buffer, pthru->reqsensearea,
                                                14);
 
-                               scp->result = DRIVER_SENSE << 24 |
-                                       DID_OK << 16 | CHECK_CONDITION << 1;
+                               scp->result = SAM_STAT_CHECK_CONDITION;
                        }
                        else {
                                if (mbox->cmd == MBOXCMD_EXTPTHRU) {
@@ -2308,9 +2307,7 @@ megaraid_mbox_dpc(unsigned long devp)
                                        memcpy(scp->sense_buffer,
                                                epthru->reqsensearea, 14);
 
-                                       scp->result = DRIVER_SENSE << 24 |
-                                               DID_OK << 16 |
-                                               CHECK_CONDITION << 1;
+                                       scp->result = SAM_STAT_CHECK_CONDITION;
                                } else
                                        scsi_build_sense(scp, 0,
                                                         ABORTED_COMMAND, 0, 0);

diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 8ed347e..1814078 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -3617,8 +3617,6 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                                       SCSI_SENSE_BUFFERSIZE);
                                memcpy(cmd->scmd->sense_buffer, cmd->sense,
                                       hdr->sense_len);
-
-                               cmd->scmd->result |= DRIVER_SENSE << 24;
                        }
 
                        break;

diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 2221175..1a4bd75 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -2051,7 +2051,6 @@ map_cmd_status(struct fusion_context *fusion,
                               SCSI_SENSE_BUFFERSIZE);
                        memcpy(scmd->sense_buffer, sense,
                               SCSI_SENSE_BUFFERSIZE);
-                       scmd->result |= DRIVER_SENSE << 24;
                }
 
                /*

diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
index 94f706e..f612505 100644 (file)
--- a/drivers/scsi/mvumi.c
+++ b/drivers/scsi/mvumi.c
@@ -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) {
                        memcpy(cmd->scmd->sense_buffer, ob_frame->payload,
                                sizeof(struct mvumi_sense_data));
-                       scmd->result |=  (DRIVER_SENSE << 24);
                }
                break;
        default:

diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 1ce46e6..d26025c 100644 (file)
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -185,13 +185,6 @@ void scsi_finish_command(struct scsi_cmnd *cmd)
        if (atomic_read(&sdev->device_blocked))
                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,
                                "Notifying upper driver of completion "
                                "(result %x)\n", cmd->result));

diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index a49fbd9..5b3a20a 100644 (file)
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -851,10 +851,10 @@ static struct device_driver sdebug_driverfs_driver = {
 };
 
 static const int check_condition_result =
-               (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+       SAM_STAT_CHECK_CONDITION;
 
 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 =
        (DID_OK << 16) | SAM_STAT_TASK_SET_FULL;

diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index d34e1b4..0d13610 100644 (file)
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -103,8 +103,7 @@ static int ioctl_internal_command(struct scsi_device *sdev, char *cmd,
 
        if (result < 0)
                goto out;
-       if (driver_byte(result) == DRIVER_SENSE &&
-           scsi_sense_valid(&sshdr)) {
+       if (scsi_sense_valid(&sshdr)) {
                switch (sshdr.sense_key) {
                case ILLEGAL_REQUEST:
                        if (cmd[0] == ALLOW_MEDIUM_REMOVAL)

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index d6b0cb2..75d633f 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -593,8 +593,6 @@ static blk_status_t scsi_result_to_blk_status(struct scsi_cmnd *cmd, int result)
        case DID_OK:
                /*
                 * 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)
                        return BLK_STS_OK;
@@ -790,7 +788,7 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
                         */
                        if (!level && __ratelimit(&_rs)) {
                                scsi_print_result(cmd, NULL, FAILED);
-                               if (driver_byte(result) == DRIVER_SENSE)
+                               if (sense_valid)
                                        scsi_print_sense(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 */
 
        if (!scsi_status_is_good(result)) {
-               if (driver_byte(result) == DRIVER_SENSE &&
-                   scsi_sense_valid(sshdr)) {
+               if (scsi_sense_valid(sshdr)) {
                        if ((sshdr->sense_key == ILLEGAL_REQUEST) &&
                            (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)
 {
        scsi_build_sense_buffer(desc, scmd->sense_buffer, key, asc, ascq);
-       scmd->result = (DRIVER_SENSE << 24) | (DID_OK << 16) |
-               SAM_STAT_CHECK_CONDITION;
+       scmd->result = SAM_STAT_CHECK_CONDITION;
 }
 EXPORT_SYMBOL_GPL(scsi_build_sense);

diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index a0edcff..5ce45ef 100644 (file)
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -623,7 +623,7 @@ static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
                         * INQUIRY should not yield UNIT_ATTENTION
                         * but many buggy devices do so anyway. 
                         */
-                       if (driver_byte(result) == DRIVER_SENSE &&
+                       if (scsi_status_is_check_condition(result) &&
                            scsi_sense_valid(&sshdr)) {
                                if ((sshdr.sense_key == UNIT_ATTENTION) &&
                                    ((sshdr.asc == 0x28) ||

diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index a9bb7ae..5af7a10 100644 (file)
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -127,7 +127,7 @@ static int spi_execute(struct scsi_device *sdev, const void *cmd,
                                      REQ_FAILFAST_TRANSPORT |
                                      REQ_FAILFAST_DRIVER,
                                      RQF_PM, NULL);
-               if (result < 0 || driver_byte(result) != DRIVER_SENSE ||
+               if (result < 0 || !scsi_sense_valid(sshdr) ||
                    sshdr->sense_key != UNIT_ATTENTION)
                        break;
        }

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 5733fbe..66cb161 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1722,16 +1722,17 @@ static int sd_sync_cache(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
                if (res < 0)
                        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);
 
-               /* we need to evaluate the error return  */
-               if (scsi_sense_valid(sshdr) &&
-                       (sshdr->asc == 0x3a ||  /* medium not present */
-                        sshdr->asc == 0x20 ||  /* invalid command */
-                        (sshdr->asc == 0x74 && sshdr->ascq == 0x71)))  /* drive is password locked */
+                       /* 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 */
                                /* this is no error here */
                                return 0;
+               }
 
                switch (host_byte(res)) {
                /* 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),
                        &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)) {
                sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result);
                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;
 
-       if (driver_byte(result) != DRIVER_SENSE &&
+       if (!scsi_status_is_check_condition(result) &&
            (!sense_valid || sense_deferred))
                goto out;
 
@@ -2175,12 +2176,12 @@ sd_spinup_disk(struct scsi_disk *sdkp)
                        if (the_result)
                                sense_valid = scsi_sense_valid(&sshdr);
                        retries++;
-               } while (retries < 3 && 
+               } while (retries < 3 &&
                         (!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)));
 
-               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
                         * with a status error */
                        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,
                        int the_result)
 {
-       if (driver_byte(the_result) == DRIVER_SENSE)
+       if (sense_valid)
                sd_print_sense_hdr(sdkp, sshdr);
        else
                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);
        if (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);
-               if (scsi_sense_valid(&sshdr) &&
                        /* 0x3a is medium not present */
-                       sshdr.asc == 0x3a)
-                       res = 0;
+                       if (sshdr.asc == 0x3a)
+                               res = 0;
+               }
        }
 
        /* SCSI error codes must not go to the generic layer */

diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index d4a79fd..186b5ff 100644 (file)
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -116,8 +116,7 @@ static int sd_zbc_do_report_zones(struct scsi_disk *sdkp, unsigned char *buf,
                sd_printk(KERN_ERR, sdkp,
                          "REPORT ZONES start lba %llu failed\n", lba);
                sd_print_result(sdkp, "REPORT ZONES", result);
-               if (result > 0 && driver_byte(result) == DRIVER_SENSE &&
-                   scsi_sense_valid(&sshdr))
+               if (result > 0 && scsi_sense_valid(&sshdr))
                        sd_print_sense_hdr(sdkp, &sshdr);
                return -EIO;
        }

diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index def7ec3..faf7716 100644 (file)
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -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->driver_status = hp->driver_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,
                       sizeof (old_hdr->sense_buffer));
+       }
        switch (hp->host_status) {
        /* This setup of 'result' is for backward compatibility and is best
           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;
        if ((hp->mx_sb_len > 0) && hp->sbp) {
                if ((CHECK_CONDITION & hp->masked_status) ||
-                   (DRIVER_SENSE & hp->driver_status)) {
+                   (srp->sense_b[0] & 0x70) == 0x70) {
                        int sb_len = SCSI_SENSE_BUFFERSIZE;
                        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 */
@@ -583,6 +585,7 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
                                err = -EFAULT;
                                goto err_out;
                        }
+                       hp->driver_status = DRIVER_SENSE;
                        hp->sb_len_wr = len;
                }
        }

diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index 3af2a2d..491b435 100644 (file)
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -737,7 +737,7 @@ static void stex_scsi_done(struct st_ccb *ccb)
                        result |= DID_OK << 16;
                        break;
                case SAM_STAT_CHECK_CONDITION:
-                       result |= DRIVER_SENSE << 24;
+                       result |= DID_OK << 16;
                        break;
                case SAM_STAT_BUSY:
                        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)
-               result = DRIVER_SENSE << 24 | SAM_STAT_CHECK_CONDITION;
+               result = SAM_STAT_CHECK_CONDITION;
        else switch (ccb->srb_status) {
                case SRB_STATUS_SELECTION_TIMEOUT:
                        result = DID_NO_CONNECT << 16;

diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index d9a045f..16b65fc 100644 (file)
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -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)
 {
        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;
        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) {
                        cam_status = sym_xerr_cam_status(DID_OK,
                                                         cp->sv_xerr_status);
-                       drv_status = DRIVER_SENSE;
                        /*
                         *  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);
        }
        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)

diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 9523e26..02267b0 100644 (file)
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -8604,7 +8604,7 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
                sdev_printk(KERN_WARNING, sdp,
                            "START_STOP failed for power mode: %d, result %x\n",
                            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);
        }
 

diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index 1678b6f..fd69a03 100644 (file)
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -161,8 +161,7 @@ static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
                       min_t(u32,
                             virtio32_to_cpu(vscsi->vdev, resp->sense_len),
                             VIRTIO_SCSI_SENSE_SIZE));
-               if (resp->sense_len)
-                       set_driver_byte(sc, DRIVER_SENSE);
+               set_status_byte(sc, SAM_STAT_CHECK_CONDITION);
        }
 
        sc->scsi_done(sc);

diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c
index 8a79605..f0707ea 100644 (file)
--- a/drivers/scsi/vmw_pvscsi.c
+++ b/drivers/scsi/vmw_pvscsi.c
@@ -576,9 +576,6 @@ static void pvscsi_complete_request(struct pvscsi_adapter *adapter,
                        cmd->result = (DID_RESET << 16);
                } else {
                        cmd->result = (DID_OK << 16) | sdstat;
-                       if (sdstat == SAM_STAT_CHECK_CONDITION &&
-                           cmd->sense_buffer)
-                               cmd->result |= (DRIVER_SENSE << 24);
                }
        } else
                switch (btstat) {

diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 2687fd7..6d0b0e6 100644 (file)
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -566,7 +566,6 @@ static int tcm_loop_queue_data_or_status(const char *func,
                memcpy(sc->sense_buffer, se_cmd->sense_buffer,
                                SCSI_SENSE_BUFFERSIZE);
                sc->result = SAM_STAT_CHECK_CONDITION;
-               set_driver_byte(sc, DRIVER_SENSE);
        } else
                sc->result = scsi_status;
 

diff --git a/drivers/usb/storage/cypress_atacb.c b/drivers/usb/storage/cypress_atacb.c
index a6f3267..2f7093b 100644 (file)
--- a/drivers/usb/storage/cypress_atacb.c
+++ b/drivers/usb/storage/cypress_atacb.c
@@ -221,11 +221,11 @@ static void cypress_atacb_passthrough(struct scsi_cmnd *srb, struct us_data *us)
                desc[12] = regs[6];  /* device */
                desc[13] = regs[7];  /* command */
 
-               srb->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+               srb->result = SAM_STAT_CHECK_CONDITION;
        }
        goto end;
 invalid_fld:
-       srb->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
+       srb->result = SAM_STAT_CHECK_CONDITION;
 
        memcpy(srb->sense_buffer,
                        usb_stor_sense_invalidCDB,

diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c
index 55a4763..3ec038c 100644 (file)
--- a/drivers/xen/xen-scsiback.c
+++ b/drivers/xen/xen-scsiback.c
@@ -1401,8 +1401,7 @@ static int scsiback_queue_status(struct se_cmd *se_cmd)
        if (se_cmd->sense_buffer &&
            ((se_cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ||
             (se_cmd->se_cmd_flags & SCF_EMULATED_TASK_SENSE)))
-               pending_req->result = (DRIVER_SENSE << 24) |
-                                     SAM_STAT_CHECK_CONDITION;
+               pending_req->result = SAM_STAT_CHECK_CONDITION;
        else
                pending_req->result = se_cmd->scsi_status;
 

diff --git a/include/scsi/sg.h b/include/scsi/sg.h
index e1a42c2..d5c1777 100644 (file)
--- a/include/scsi/sg.h
+++ b/include/scsi/sg.h
@@ -131,6 +131,17 @@ struct compat_sg_io_hdr {
 #define SG_INFO_DIRECT_IO 0x2   /* direct IO requested and performed */
 #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() */
     int host_no;        /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */