scsi: sd: Convert to scsi_execute_cmd()

scsi_execute*() is going to be removed. Convert sd_mod to use
scsi_execute_cmd().

Signed-off-by: Mike Christie <michael.christie@oracle.com>
Reviewed-by: John Garry <john.g.garry@oracle.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 47dafe6..2aa3b03 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -664,6 +664,9 @@ static int sd_sec_submit(void *data, u16 spsp, u8 secp, void *buffer,
        struct scsi_disk *sdkp = data;
        struct scsi_device *sdev = sdkp->device;
        u8 cdb[12] = { 0, };
+       const struct scsi_exec_args exec_args = {
+               .req_flags = BLK_MQ_REQ_PM,
+       };
        int ret;
 
        cdb[0] = send ? SECURITY_PROTOCOL_OUT : SECURITY_PROTOCOL_IN;
@@ -671,9 +674,9 @@ static int sd_sec_submit(void *data, u16 spsp, u8 secp, void *buffer,
        put_unaligned_be16(spsp, &cdb[2]);
        put_unaligned_be32(len, &cdb[6]);
 
-       ret = scsi_execute(sdev, cdb, send ? DMA_TO_DEVICE : DMA_FROM_DEVICE,
-               buffer, len, NULL, NULL, SD_TIMEOUT, sdkp->max_retries, 0,
-               RQF_PM, NULL);
+       ret = scsi_execute_cmd(sdev, cdb, send ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
+                              buffer, len, SD_TIMEOUT, sdkp->max_retries,
+                              &exec_args);
        return ret <= 0 ? ret : -EIO;
 }
 #endif /* CONFIG_BLK_SED_OPAL */
@@ -1583,13 +1586,16 @@ static int sd_sync_cache(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
        const int timeout = sdp->request_queue->rq_timeout
                * SD_FLUSH_TIMEOUT_MULTIPLIER;
        struct scsi_sense_hdr my_sshdr;
+       const struct scsi_exec_args exec_args = {
+               .req_flags = BLK_MQ_REQ_PM,
+               /* caller might not be interested in sense, but we need it */
+               .sshdr = sshdr ? : &my_sshdr,
+       };
 
        if (!scsi_device_online(sdp))
                return -ENODEV;
 
-       /* caller might not be interested in sense, but we need it */
-       if (!sshdr)
-               sshdr = &my_sshdr;
+       sshdr = exec_args.sshdr;
 
        for (retries = 3; retries > 0; --retries) {
                unsigned char cmd[16] = { 0 };
@@ -1602,8 +1608,8 @@ static int sd_sync_cache(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
                 * Leave the rest of the command zero to indicate
                 * flush everything.
                 */
-               res = scsi_execute(sdp, cmd, DMA_NONE, NULL, 0, NULL, sshdr,
-                               timeout, sdkp->max_retries, 0, RQF_PM, NULL);
+               res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
+                                      timeout, sdkp->max_retries, &exec_args);
                if (res == 0)
                        break;
        }
@@ -1745,6 +1751,9 @@ static int sd_pr_command(struct block_device *bdev, u8 sa,
        struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
        struct scsi_device *sdev = sdkp->device;
        struct scsi_sense_hdr sshdr;
+       const struct scsi_exec_args exec_args = {
+               .sshdr = &sshdr,
+       };
        int result;
        u8 cmd[16] = { 0, };
        u8 data[24] = { 0, };
@@ -1758,8 +1767,9 @@ static int sd_pr_command(struct block_device *bdev, u8 sa,
        put_unaligned_be64(sa_key, &data[8]);
        data[20] = flags;
 
-       result = scsi_execute_req(sdev, cmd, DMA_TO_DEVICE, &data, sizeof(data),
-                       &sshdr, SD_TIMEOUT, sdkp->max_retries, NULL);
+       result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, &data,
+                                 sizeof(data), SD_TIMEOUT, sdkp->max_retries,
+                                 &exec_args);
 
        if (scsi_status_is_check_condition(result) &&
            scsi_sense_valid(&sshdr)) {
@@ -2088,6 +2098,9 @@ sd_spinup_disk(struct scsi_disk *sdkp)
        int retries, spintime;
        unsigned int the_result;
        struct scsi_sense_hdr sshdr;
+       const struct scsi_exec_args exec_args = {
+               .sshdr = &sshdr,
+       };
        int sense_valid = 0;
 
        spintime = 0;
@@ -2103,10 +2116,11 @@ sd_spinup_disk(struct scsi_disk *sdkp)
                        cmd[0] = TEST_UNIT_READY;
                        memset((void *) &cmd[1], 0, 9);
 
-                       the_result = scsi_execute_req(sdkp->device, cmd,
-                                                     DMA_NONE, NULL, 0,
-                                                     &sshdr, SD_TIMEOUT,
-                                                     sdkp->max_retries, NULL);
+                       the_result = scsi_execute_cmd(sdkp->device, cmd,
+                                                     REQ_OP_DRV_IN, NULL, 0,
+                                                     SD_TIMEOUT,
+                                                     sdkp->max_retries,
+                                                     &exec_args);
 
                        /*
                         * If the drive has indicated to us that it
@@ -2163,10 +2177,10 @@ sd_spinup_disk(struct scsi_disk *sdkp)
                                cmd[4] = 1;     /* Start spin cycle */
                                if (sdkp->device->start_stop_pwr_cond)
                                        cmd[4] |= 1 << 4;
-                               scsi_execute_req(sdkp->device, cmd, DMA_NONE,
-                                                NULL, 0, &sshdr,
+                               scsi_execute_cmd(sdkp->device, cmd,
+                                                REQ_OP_DRV_IN, NULL, 0,
                                                 SD_TIMEOUT, sdkp->max_retries,
-                                                NULL);
+                                                &exec_args);
                                spintime_expire = jiffies + 100 * HZ;
                                spintime = 1;
                        }
@@ -2296,6 +2310,9 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
 {
        unsigned char cmd[16];
        struct scsi_sense_hdr sshdr;
+       const struct scsi_exec_args exec_args = {
+               .sshdr = &sshdr,
+       };
        int sense_valid = 0;
        int the_result;
        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
@@ -2313,9 +2330,9 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
                cmd[13] = RC16_LEN;
                memset(buffer, 0, RC16_LEN);
 
-               the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
-                                       buffer, RC16_LEN, &sshdr,
-                                       SD_TIMEOUT, sdkp->max_retries, NULL);
+               the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN,
+                                             buffer, RC16_LEN, SD_TIMEOUT,
+                                             sdkp->max_retries, &exec_args);
 
                if (media_not_present(sdkp, &sshdr))
                        return -ENODEV;
@@ -2387,6 +2404,9 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
 {
        unsigned char cmd[16];
        struct scsi_sense_hdr sshdr;
+       const struct scsi_exec_args exec_args = {
+               .sshdr = &sshdr,
+       };
        int sense_valid = 0;
        int the_result;
        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
@@ -2398,9 +2418,9 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
                memset(&cmd[1], 0, 9);
                memset(buffer, 0, 8);
 
-               the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
-                                       buffer, 8, &sshdr,
-                                       SD_TIMEOUT, sdkp->max_retries, NULL);
+               the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, buffer,
+                                             8, SD_TIMEOUT, sdkp->max_retries,
+                                             &exec_args);
 
                if (media_not_present(sdkp, &sshdr))
                        return -ENODEV;
@@ -3637,6 +3657,10 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
 {
        unsigned char cmd[6] = { START_STOP };  /* START_VALID */
        struct scsi_sense_hdr sshdr;
+       const struct scsi_exec_args exec_args = {
+               .sshdr = &sshdr,
+               .req_flags = BLK_MQ_REQ_PM,
+       };
        struct scsi_device *sdp = sdkp->device;
        int res;
 
@@ -3649,8 +3673,8 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
        if (!scsi_device_online(sdp))
                return -ENODEV;
 
-       res = scsi_execute(sdp, cmd, DMA_NONE, NULL, 0, NULL, &sshdr,
-                       SD_TIMEOUT, sdkp->max_retries, 0, RQF_PM, NULL);
+       res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0, SD_TIMEOUT,
+                              sdkp->max_retries, &exec_args);
        if (res) {
                sd_print_result(sdkp, "Start/Stop Unit failed", res);
                if (res > 0 && scsi_sense_valid(&sshdr)) {
@@ -3790,10 +3814,13 @@ static int sd_resume_runtime(struct device *dev)
        if (sdp->ignore_media_change) {
                /* clear the device's sense data */
                static const u8 cmd[10] = { REQUEST_SENSE };
+               const struct scsi_exec_args exec_args = {
+                       .req_flags = BLK_MQ_REQ_PM,
+               };
 
-               if (scsi_execute(sdp, cmd, DMA_NONE, NULL, 0, NULL,
-                                NULL, sdp->request_queue->rq_timeout, 1, 0,
-                                RQF_PM, NULL))
+               if (scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
+                                    sdp->request_queue->rq_timeout, 1,
+                                    &exec_args))
                        sd_printk(KERN_NOTICE, sdkp,
                                  "Failed to clear sense data\n");
        }