tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

scsi: scsi_dh: Convert to scsi_execute_cmd()

scsi_execute() is going to be removed. Convert the scsi_dh users to
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>

authored by

Mike Christie and committed by
Martin K. Petersen 31fc28c6 ed226f08

+45 -28
+16 -10
drivers/scsi/device_handler/scsi_dh_alua.c
··· 127 127 int bufflen, struct scsi_sense_hdr *sshdr, int flags) 128 128 { 129 129 u8 cdb[MAX_COMMAND_SIZE]; 130 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 131 - REQ_FAILFAST_DRIVER; 130 + blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV | 131 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 132 + const struct scsi_exec_args exec_args = { 133 + .sshdr = sshdr, 134 + }; 132 135 133 136 /* Prepare the command. */ 134 137 memset(cdb, 0x0, MAX_COMMAND_SIZE); ··· 142 139 cdb[1] = MI_REPORT_TARGET_PGS; 143 140 put_unaligned_be32(bufflen, &cdb[6]); 144 141 145 - return scsi_execute(sdev, cdb, DMA_FROM_DEVICE, buff, bufflen, NULL, 146 - sshdr, ALUA_FAILOVER_TIMEOUT * HZ, 147 - ALUA_FAILOVER_RETRIES, req_flags, 0, NULL); 142 + return scsi_execute_cmd(sdev, cdb, opf, buff, bufflen, 143 + ALUA_FAILOVER_TIMEOUT * HZ, 144 + ALUA_FAILOVER_RETRIES, &exec_args); 148 145 } 149 146 150 147 /* ··· 160 157 u8 cdb[MAX_COMMAND_SIZE]; 161 158 unsigned char stpg_data[8]; 162 159 int stpg_len = 8; 163 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 164 - REQ_FAILFAST_DRIVER; 160 + blk_opf_t opf = REQ_OP_DRV_OUT | REQ_FAILFAST_DEV | 161 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 162 + const struct scsi_exec_args exec_args = { 163 + .sshdr = sshdr, 164 + }; 165 165 166 166 /* Prepare the data buffer */ 167 167 memset(stpg_data, 0, stpg_len); ··· 177 171 cdb[1] = MO_SET_TARGET_PGS; 178 172 put_unaligned_be32(stpg_len, &cdb[6]); 179 173 180 - return scsi_execute(sdev, cdb, DMA_TO_DEVICE, stpg_data, stpg_len, NULL, 181 - sshdr, ALUA_FAILOVER_TIMEOUT * HZ, 182 - ALUA_FAILOVER_RETRIES, req_flags, 0, NULL); 174 + return scsi_execute_cmd(sdev, cdb, opf, stpg_data, 175 + stpg_len, ALUA_FAILOVER_TIMEOUT * HZ, 176 + ALUA_FAILOVER_RETRIES, &exec_args); 183 177 } 184 178 185 179 static struct alua_port_group *alua_find_get_pg(char *id_str, size_t id_size,
+8 -5
drivers/scsi/device_handler/scsi_dh_emc.c
··· 239 239 unsigned char cdb[MAX_COMMAND_SIZE]; 240 240 int err, res = SCSI_DH_OK, len; 241 241 struct scsi_sense_hdr sshdr; 242 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 243 - REQ_FAILFAST_DRIVER; 242 + blk_opf_t opf = REQ_OP_DRV_OUT | REQ_FAILFAST_DEV | 243 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 244 + const struct scsi_exec_args exec_args = { 245 + .sshdr = &sshdr, 246 + }; 244 247 245 248 if (csdev->flags & CLARIION_SHORT_TRESPASS) { 246 249 page22 = short_trespass; ··· 266 263 BUG_ON((len > CLARIION_BUFFER_SIZE)); 267 264 memcpy(csdev->buffer, page22, len); 268 265 269 - err = scsi_execute(sdev, cdb, DMA_TO_DEVICE, csdev->buffer, len, NULL, 270 - &sshdr, CLARIION_TIMEOUT * HZ, CLARIION_RETRIES, 271 - req_flags, 0, NULL); 266 + err = scsi_execute_cmd(sdev, cdb, opf, csdev->buffer, len, 267 + CLARIION_TIMEOUT * HZ, CLARIION_RETRIES, 268 + &exec_args); 272 269 if (err) { 273 270 if (scsi_sense_valid(&sshdr)) 274 271 res = trespass_endio(sdev, &sshdr);
+14 -8
drivers/scsi/device_handler/scsi_dh_hp_sw.c
··· 83 83 unsigned char cmd[6] = { TEST_UNIT_READY }; 84 84 struct scsi_sense_hdr sshdr; 85 85 int ret = SCSI_DH_OK, res; 86 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 87 - REQ_FAILFAST_DRIVER; 86 + blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV | 87 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 88 + const struct scsi_exec_args exec_args = { 89 + .sshdr = &sshdr, 90 + }; 88 91 89 92 retry: 90 - res = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL, &sshdr, 91 - HP_SW_TIMEOUT, HP_SW_RETRIES, req_flags, 0, NULL); 93 + res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT, 94 + HP_SW_RETRIES, &exec_args); 92 95 if (res) { 93 96 if (scsi_sense_valid(&sshdr)) 94 97 ret = tur_done(sdev, h, &sshdr); ··· 124 121 struct scsi_device *sdev = h->sdev; 125 122 int res, rc = SCSI_DH_OK; 126 123 int retry_cnt = HP_SW_RETRIES; 127 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 128 - REQ_FAILFAST_DRIVER; 124 + blk_opf_t opf = REQ_OP_DRV_IN | REQ_FAILFAST_DEV | 125 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 126 + const struct scsi_exec_args exec_args = { 127 + .sshdr = &sshdr, 128 + }; 129 129 130 130 retry: 131 - res = scsi_execute(sdev, cmd, DMA_NONE, NULL, 0, NULL, &sshdr, 132 - HP_SW_TIMEOUT, HP_SW_RETRIES, req_flags, 0, NULL); 131 + res = scsi_execute_cmd(sdev, cmd, opf, NULL, 0, HP_SW_TIMEOUT, 132 + HP_SW_RETRIES, &exec_args); 133 133 if (res) { 134 134 if (!scsi_sense_valid(&sshdr)) { 135 135 sdev_printk(KERN_WARNING, sdev,
+7 -5
drivers/scsi/device_handler/scsi_dh_rdac.c
··· 536 536 unsigned char cdb[MAX_COMMAND_SIZE]; 537 537 struct scsi_sense_hdr sshdr; 538 538 unsigned int data_size; 539 - blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | 540 - REQ_FAILFAST_DRIVER; 539 + blk_opf_t opf = REQ_OP_DRV_OUT | REQ_FAILFAST_DEV | 540 + REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER; 541 + const struct scsi_exec_args exec_args = { 542 + .sshdr = &sshdr, 543 + }; 541 544 542 545 spin_lock(&ctlr->ms_lock); 543 546 list_splice_init(&ctlr->ms_head, &list); ··· 558 555 (char *) h->ctlr->array_name, h->ctlr->index, 559 556 (retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying"); 560 557 561 - if (scsi_execute(sdev, cdb, DMA_TO_DEVICE, &h->ctlr->mode_select, 562 - data_size, NULL, &sshdr, RDAC_TIMEOUT * HZ, 563 - RDAC_RETRIES, req_flags, 0, NULL)) { 558 + if (scsi_execute_cmd(sdev, cdb, opf, &h->ctlr->mode_select, data_size, 559 + RDAC_TIMEOUT * HZ, RDAC_RETRIES, &exec_args)) { 564 560 err = mode_select_handle_sense(sdev, &sshdr); 565 561 if (err == SCSI_DH_RETRY && retry_cnt--) 566 562 goto retry;