Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge patch series "Change the return type of the .queuecommand() callback"
Bart Van Assche <bvanassche@acm.org> says:
Hi Martin,
Most but not all .queuecommand() implementations return a SCSI_MLQUEUE_*
constant. This affects code readability: in order to understand what happens
if a .queuecommand() function returns a value that is not a SCSI_MLQUEUE_*
constant, one has to read the scsi_dispatch_cmd() implementation and check
how other values are handled. Hence this patch series that changes the
return type of the .queuecommand() callback and also of the implementations of
this callback.
Please consider this patch series for the next merge window.
Thanks,
Bart.
Link: https://patch.msgid.link/20260115210357.2501991-1-bvanassche@acm.org
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+267
-207
+2
-1
Documentation/scsi/scsi_mid_low_api.rst
+2
-1
Documentation/scsi/scsi_mid_low_api.rst
+5
-3
drivers/ata/libata-scsi.c
+5
-3
drivers/ata/libata-scsi.c
···
4309
4309
return NULL;
4310
4310
}
4311
4311
4312
-
int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev)
4312
+
enum scsi_qc_status __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
4313
+
struct ata_device *dev)
4313
4314
{
4314
4315
struct ata_port *ap = dev->link->ap;
4315
4316
u8 scsi_op = scmd->cmnd[0];
···
4384
4383
* Return value from __ata_scsi_queuecmd() if @cmd can be queued,
4385
4384
* 0 otherwise.
4386
4385
*/
4387
-
int ata_scsi_queuecmd(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
4386
+
enum scsi_qc_status ata_scsi_queuecmd(struct Scsi_Host *shost,
4387
+
struct scsi_cmnd *cmd)
4388
4388
{
4389
4389
struct ata_port *ap;
4390
4390
struct ata_device *dev;
4391
4391
struct scsi_device *scsidev = cmd->device;
4392
-
int rc = 0;
4392
+
enum scsi_qc_status rc = 0;
4393
4393
unsigned long irq_flags;
4394
4394
4395
4395
ap = ata_shost_to_port(shost);
+2
-1
drivers/ata/libata.h
+2
-1
drivers/ata/libata.h
···
164
164
void ata_scsi_sdev_config(struct scsi_device *sdev);
165
165
int ata_scsi_dev_config(struct scsi_device *sdev, struct queue_limits *lim,
166
166
struct ata_device *dev);
167
-
int __ata_scsi_queuecmd(struct scsi_cmnd *scmd, struct ata_device *dev);
167
+
enum scsi_qc_status __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
168
+
struct ata_device *dev);
168
169
169
170
/* libata-eh.c */
170
171
extern unsigned int ata_internal_cmd_timeout(struct ata_device *dev, u8 cmd);
+4
-3
drivers/firewire/sbp2.c
+4
-3
drivers/firewire/sbp2.c
···
1440
1440
1441
1441
/* SCSI stack integration */
1442
1442
1443
-
static int sbp2_scsi_queuecommand(struct Scsi_Host *shost,
1444
-
struct scsi_cmnd *cmd)
1443
+
static enum scsi_qc_status sbp2_scsi_queuecommand(struct Scsi_Host *shost,
1444
+
struct scsi_cmnd *cmd)
1445
1445
{
1446
1446
struct sbp2_logical_unit *lu = cmd->device->hostdata;
1447
1447
struct fw_device *device = target_parent_device(lu->tgt);
1448
+
enum scsi_qc_status retval = SCSI_MLQUEUE_HOST_BUSY;
1448
1449
struct sbp2_command_orb *orb;
1449
-
int generation, retval = SCSI_MLQUEUE_HOST_BUSY;
1450
+
int generation;
1450
1451
1451
1452
orb = kzalloc(sizeof(*orb), GFP_ATOMIC);
1452
1453
if (orb == NULL)
+2
-1
drivers/infiniband/ulp/srp/ib_srp.c
+2
-1
drivers/infiniband/ulp/srp/ib_srp.c
···
2148
2148
target->qp_in_error = true;
2149
2149
}
2150
2150
2151
-
static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd)
2151
+
static enum scsi_qc_status srp_queuecommand(struct Scsi_Host *shost,
2152
+
struct scsi_cmnd *scmnd)
2152
2153
{
2153
2154
struct request *rq = scsi_cmd_to_rq(scmnd);
2154
2155
struct srp_target_port *target = host_to_target(shost);
+4
-3
drivers/message/fusion/mptfc.c
+4
-3
drivers/message/fusion/mptfc.c
···
97
97
98
98
static int mptfc_target_alloc(struct scsi_target *starget);
99
99
static int mptfc_sdev_init(struct scsi_device *sdev);
100
-
static int mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt);
100
+
static enum scsi_qc_status mptfc_qcmd(struct Scsi_Host *shost,
101
+
struct scsi_cmnd *SCpnt);
101
102
static void mptfc_target_destroy(struct scsi_target *starget);
102
103
static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
103
104
static void mptfc_remove(struct pci_dev *pdev);
···
677
676
return 0;
678
677
}
679
678
680
-
static int
681
-
mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
679
+
static enum scsi_qc_status mptfc_qcmd(struct Scsi_Host *shost,
680
+
struct scsi_cmnd *SCpnt)
682
681
{
683
682
struct mptfc_rport_info *ri;
684
683
struct fc_rport *rport = starget_to_rport(scsi_target(SCpnt->device));
+2
-2
drivers/message/fusion/mptsas.c
+2
-2
drivers/message/fusion/mptsas.c
···
1920
1920
return 0;
1921
1921
}
1922
1922
1923
-
static int
1924
-
mptsas_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
1923
+
static enum scsi_qc_status mptsas_qcmd(struct Scsi_Host *shost,
1924
+
struct scsi_cmnd *SCpnt)
1925
1925
{
1926
1926
MPT_SCSI_HOST *hd;
1927
1927
MPT_ADAPTER *ioc;
+1
-2
drivers/message/fusion/mptscsih.c
+1
-2
drivers/message/fusion/mptscsih.c
+1
-1
drivers/message/fusion/mptscsih.h
+1
-1
drivers/message/fusion/mptscsih.h
···
113
113
#endif
114
114
extern int mptscsih_show_info(struct seq_file *, struct Scsi_Host *);
115
115
extern const char * mptscsih_info(struct Scsi_Host *SChost);
116
-
extern int mptscsih_qcmd(struct scsi_cmnd *SCpnt);
116
+
extern enum scsi_qc_status mptscsih_qcmd(struct scsi_cmnd *SCpnt);
117
117
extern int mptscsih_IssueTaskMgmt(MPT_SCSI_HOST *hd, u8 type, u8 channel,
118
118
u8 id, u64 lun, int ctx2abort, ulong timeout);
119
119
extern void mptscsih_sdev_destroy(struct scsi_device *device);
+2
-2
drivers/message/fusion/mptspi.c
+2
-2
drivers/message/fusion/mptspi.c
···
774
774
return 0;
775
775
}
776
776
777
-
static int
778
-
mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
777
+
static enum scsi_qc_status mptspi_qcmd(struct Scsi_Host *shost,
778
+
struct scsi_cmnd *SCpnt)
779
779
{
780
780
struct _MPT_SCSI_HOST *hd = shost_priv(shost);
781
781
VirtDevice *vdevice = SCpnt->device->hostdata;
+2
-2
drivers/s390/scsi/zfcp_scsi.c
+2
-2
drivers/s390/scsi/zfcp_scsi.c
···
63
63
scsi_done(scpnt);
64
64
}
65
65
66
-
static
67
-
int zfcp_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scpnt)
66
+
static enum scsi_qc_status zfcp_scsi_queuecommand(struct Scsi_Host *shost,
67
+
struct scsi_cmnd *scpnt)
68
68
{
69
69
struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scpnt->device);
70
70
struct fc_rport *rport = starget_to_rport(scsi_target(scpnt->device));
+1
-1
drivers/scsi/3w-9xxx.c
+1
-1
drivers/scsi/3w-9xxx.c
···
1746
1746
} /* End twa_scsi_eh_reset() */
1747
1747
1748
1748
/* This is the main scsi queue function to handle scsi opcodes */
1749
-
static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1749
+
static enum scsi_qc_status twa_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1750
1750
{
1751
1751
void (*done)(struct scsi_cmnd *) = scsi_done;
1752
1752
int request_id, retval;
+5
-3
drivers/scsi/3w-sas.c
+5
-3
drivers/scsi/3w-sas.c
···
1453
1453
} /* End twl_scsi_eh_reset() */
1454
1454
1455
1455
/* This is the main scsi queue function to handle scsi opcodes */
1456
-
static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1456
+
static enum scsi_qc_status twl_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1457
1457
{
1458
+
TW_Device_Extension *tw_dev =
1459
+
(TW_Device_Extension *)SCpnt->device->host->hostdata;
1458
1460
void (*done)(struct scsi_cmnd *) = scsi_done;
1459
-
int request_id, retval;
1460
-
TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1461
+
enum scsi_qc_status retval;
1462
+
int request_id;
1461
1463
1462
1464
/* If we are resetting due to timed out ioctl, report as busy */
1463
1465
if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
+1
-1
drivers/scsi/3w-xxxx.c
+1
-1
drivers/scsi/3w-xxxx.c
···
1920
1920
} /* End tw_scsiop_test_unit_ready_complete() */
1921
1921
1922
1922
/* This is the main scsi queue function to handle scsi opcodes */
1923
-
static int tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1923
+
static enum scsi_qc_status tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
1924
1924
{
1925
1925
void (*done)(struct scsi_cmnd *) = scsi_done;
1926
1926
unsigned char *command = SCpnt->cmnd;
+3
-3
drivers/scsi/53c700.c
+3
-3
drivers/scsi/53c700.c
···
152
152
/* This is the script */
153
153
#include "53c700_d.h"
154
154
155
-
156
-
STATIC int NCR_700_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *);
155
+
STATIC enum scsi_qc_status NCR_700_queuecommand(struct Scsi_Host *h,
156
+
struct scsi_cmnd *);
157
157
STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
158
158
STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
159
159
STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
···
1751
1751
return IRQ_RETVAL(handled);
1752
1752
}
1753
1753
1754
-
static int NCR_700_queuecommand_lck(struct scsi_cmnd *SCp)
1754
+
static enum scsi_qc_status NCR_700_queuecommand_lck(struct scsi_cmnd *SCp)
1755
1755
{
1756
1756
struct NCR_700_Host_Parameters *hostdata =
1757
1757
(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
+1
-1
drivers/scsi/BusLogic.c
+1
-1
drivers/scsi/BusLogic.c
···
2877
2877
Outgoing Mailbox for execution by the associated Host Adapter.
2878
2878
*/
2879
2879
2880
-
static int blogic_qcmd_lck(struct scsi_cmnd *command)
2880
+
static enum scsi_qc_status blogic_qcmd_lck(struct scsi_cmnd *command)
2881
2881
{
2882
2882
void (*comp_cb)(struct scsi_cmnd *) = scsi_done;
2883
2883
struct blogic_adapter *adapter =
+2
-1
drivers/scsi/BusLogic.h
+2
-1
drivers/scsi/BusLogic.h
···
1272
1272
*/
1273
1273
1274
1274
static const char *blogic_drvr_info(struct Scsi_Host *);
1275
-
static int blogic_qcmd(struct Scsi_Host *h, struct scsi_cmnd *);
1275
+
static enum scsi_qc_status blogic_qcmd(struct Scsi_Host *h,
1276
+
struct scsi_cmnd *command);
1276
1277
static int blogic_diskparam(struct scsi_device *, struct gendisk *, sector_t, int *);
1277
1278
static int blogic_sdev_configure(struct scsi_device *,
1278
1279
struct queue_limits *lim);
+2
-2
drivers/scsi/NCR5380.c
+2
-2
drivers/scsi/NCR5380.c
···
555
555
* main coroutine is not running, it is restarted.
556
556
*/
557
557
558
-
static int NCR5380_queue_command(struct Scsi_Host *instance,
559
-
struct scsi_cmnd *cmd)
558
+
static enum scsi_qc_status NCR5380_queue_command(struct Scsi_Host *instance,
559
+
struct scsi_cmnd *cmd)
560
560
{
561
561
struct NCR5380_hostdata *hostdata = shost_priv(instance);
562
562
struct NCR5380_cmd *ncmd = NCR5380_to_ncmd(cmd);
+1
-1
drivers/scsi/a100u2w.c
+1
-1
drivers/scsi/a100u2w.c
···
909
909
* block, build the host specific scb structures and if there is room
910
910
* queue the command down to the controller
911
911
*/
912
-
static int inia100_queue_lck(struct scsi_cmnd *cmd)
912
+
static enum scsi_qc_status inia100_queue_lck(struct scsi_cmnd *cmd)
913
913
{
914
914
struct orc_scb *scb;
915
915
struct orc_host *host; /* Point to Host adapter control block */
+2
-2
drivers/scsi/aacraid/linit.c
+2
-2
drivers/scsi/aacraid/linit.c
···
237
237
* TODO: unify with aac_scsi_cmd().
238
238
*/
239
239
240
-
static int aac_queuecommand(struct Scsi_Host *shost,
241
-
struct scsi_cmnd *cmd)
240
+
static enum scsi_qc_status aac_queuecommand(struct Scsi_Host *shost,
241
+
struct scsi_cmnd *cmd)
242
242
{
243
243
aac_priv(cmd)->owner = AAC_OWNER_LOWLEVEL;
244
244
+3
-2
drivers/scsi/advansys.c
+3
-2
drivers/scsi/advansys.c
···
8462
8462
* This function always returns 0. Command return status is saved
8463
8463
* in the 'scp' result field.
8464
8464
*/
8465
-
static int advansys_queuecommand_lck(struct scsi_cmnd *scp)
8465
+
static enum scsi_qc_status advansys_queuecommand_lck(struct scsi_cmnd *scp)
8466
8466
{
8467
8467
struct Scsi_Host *shost = scp->device->host;
8468
-
int asc_res, result = 0;
8468
+
enum scsi_qc_status result = 0;
8469
+
int asc_res;
8469
8470
8470
8471
ASC_STATS(shost, queuecommand);
8471
8472
+4
-4
drivers/scsi/aha152x.c
+4
-4
drivers/scsi/aha152x.c
···
924
924
/*
925
925
* Queue a command and setup interrupts for a free bus.
926
926
*/
927
-
static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
927
+
static enum scsi_qc_status aha152x_internal_queue(struct scsi_cmnd *SCpnt,
928
928
struct completion *complete, int phase)
929
929
{
930
930
struct aha152x_cmd_priv *acp = aha152x_priv(SCpnt);
···
939
939
if (acp->phase & (resetting | check_condition)) {
940
940
if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
941
941
scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
942
-
return FAILED;
942
+
return SCSI_MLQUEUE_HOST_BUSY;
943
943
}
944
944
} else {
945
945
SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
946
946
if(!SCpnt->host_scribble) {
947
947
scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
948
-
return FAILED;
948
+
return SCSI_MLQUEUE_HOST_BUSY;
949
949
}
950
950
}
951
951
···
995
995
* queue a command
996
996
*
997
997
*/
998
-
static int aha152x_queue_lck(struct scsi_cmnd *SCpnt)
998
+
static enum scsi_qc_status aha152x_queue_lck(struct scsi_cmnd *SCpnt)
999
999
{
1000
1000
return aha152x_internal_queue(SCpnt, NULL, 0);
1001
1001
}
+2
-1
drivers/scsi/aha1542.c
+2
-1
drivers/scsi/aha1542.c
···
411
411
}
412
412
}
413
413
414
-
static int aha1542_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
414
+
static enum scsi_qc_status aha1542_queuecommand(struct Scsi_Host *sh,
415
+
struct scsi_cmnd *cmd)
415
416
{
416
417
struct aha1542_cmd *acmd = scsi_cmd_priv(cmd);
417
418
struct aha1542_hostdata *aha1542 = shost_priv(sh);
+1
-1
drivers/scsi/aha1740.c
+1
-1
drivers/scsi/aha1740.c
+6
-6
drivers/scsi/aic7xxx/aic79xx_osm.c
+6
-6
drivers/scsi/aic7xxx/aic79xx_osm.c
···
359
359
static u_int ahd_linux_user_tagdepth(struct ahd_softc *ahd,
360
360
struct ahd_devinfo *devinfo);
361
361
static void ahd_linux_device_queue_depth(struct scsi_device *);
362
-
static int ahd_linux_run_command(struct ahd_softc*,
362
+
static enum scsi_qc_status ahd_linux_run_command(struct ahd_softc*,
363
363
struct ahd_linux_device *,
364
364
struct scsi_cmnd *);
365
365
static void ahd_linux_setup_tag_info_global(char *p);
···
577
577
/*
578
578
* Queue an SCB to the controller.
579
579
*/
580
-
static int ahd_linux_queue_lck(struct scsi_cmnd *cmd)
580
+
static enum scsi_qc_status ahd_linux_queue_lck(struct scsi_cmnd *cmd)
581
581
{
582
-
struct ahd_softc *ahd;
583
-
struct ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
584
-
int rtn = SCSI_MLQUEUE_HOST_BUSY;
582
+
struct ahd_linux_device *dev = scsi_transport_device_data(cmd->device);
583
+
enum scsi_qc_status rtn = SCSI_MLQUEUE_HOST_BUSY;
584
+
struct ahd_softc *ahd;
585
585
586
586
ahd = *(struct ahd_softc **)cmd->device->host->hostdata;
587
587
···
1535
1535
}
1536
1536
}
1537
1537
1538
-
static int
1538
+
static enum scsi_qc_status
1539
1539
ahd_linux_run_command(struct ahd_softc *ahd, struct ahd_linux_device *dev,
1540
1540
struct scsi_cmnd *cmd)
1541
1541
{
+2
-2
drivers/scsi/aic7xxx/aic7xxx_osm.c
+2
-2
drivers/scsi/aic7xxx/aic7xxx_osm.c
···
519
519
/*
520
520
* Queue an SCB to the controller.
521
521
*/
522
-
static int ahc_linux_queue_lck(struct scsi_cmnd *cmd)
522
+
static enum scsi_qc_status ahc_linux_queue_lck(struct scsi_cmnd *cmd)
523
523
{
524
524
struct ahc_softc *ahc;
525
525
struct ahc_linux_device *dev = scsi_transport_device_data(cmd->device);
526
-
int rtn = SCSI_MLQUEUE_HOST_BUSY;
526
+
enum scsi_qc_status rtn = SCSI_MLQUEUE_HOST_BUSY;
527
527
unsigned long flags;
528
528
529
529
ahc = *(struct ahc_softc **)cmd->device->host->hostdata;
+3
-2
drivers/scsi/arcmsr/arcmsr_hba.c
+3
-2
drivers/scsi/arcmsr/arcmsr_hba.c
···
113
113
static int arcmsr_bus_reset(struct scsi_cmnd *);
114
114
static int arcmsr_bios_param(struct scsi_device *sdev,
115
115
struct gendisk *disk, sector_t capacity, int *info);
116
-
static int arcmsr_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
116
+
static enum scsi_qc_status arcmsr_queue_command(struct Scsi_Host *h,
117
+
struct scsi_cmnd *cmd);
117
118
static int arcmsr_probe(struct pci_dev *pdev,
118
119
const struct pci_device_id *id);
119
120
static int __maybe_unused arcmsr_suspend(struct device *dev);
···
3313
3312
}
3314
3313
}
3315
3314
3316
-
static int arcmsr_queue_command_lck(struct scsi_cmnd *cmd)
3315
+
static enum scsi_qc_status arcmsr_queue_command_lck(struct scsi_cmnd *cmd)
3317
3316
{
3318
3317
struct Scsi_Host *host = cmd->device->host;
3319
3318
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
+1
-1
drivers/scsi/arm/acornscsi.c
+1
-1
drivers/scsi/arm/acornscsi.c
···
2408
2408
* Params : cmd - SCSI command
2409
2409
* Returns : 0, or < 0 on error.
2410
2410
*/
2411
-
static int acornscsi_queuecmd_lck(struct scsi_cmnd *SCpnt)
2411
+
static enum scsi_qc_status acornscsi_queuecmd_lck(struct scsi_cmnd *SCpnt)
2412
2412
{
2413
2413
struct scsi_pointer *scsi_pointer = arm_scsi_pointer(SCpnt);
2414
2414
void (*done)(struct scsi_cmnd *) = scsi_done;
+6
-5
drivers/scsi/arm/fas216.c
+6
-5
drivers/scsi/arm/fas216.c
···
2202
2202
* Returns: 0 on success, else error.
2203
2203
* Notes: io_request_lock is held, interrupts are disabled.
2204
2204
*/
2205
-
static int fas216_queue_command_internal(struct scsi_cmnd *SCpnt,
2206
-
void (*done)(struct scsi_cmnd *))
2205
+
static enum scsi_qc_status
2206
+
fas216_queue_command_internal(struct scsi_cmnd *SCpnt,
2207
+
void (*done)(struct scsi_cmnd *))
2207
2208
{
2208
2209
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;
2209
-
int result;
2210
+
enum scsi_qc_status result;
2210
2211
2211
2212
fas216_checkmagic(info);
2212
2213
···
2244
2243
return result;
2245
2244
}
2246
2245
2247
-
static int fas216_queue_command_lck(struct scsi_cmnd *SCpnt)
2246
+
static enum scsi_qc_status fas216_queue_command_lck(struct scsi_cmnd *SCpnt)
2248
2247
{
2249
2248
return fas216_queue_command_internal(SCpnt, scsi_done);
2250
2249
}
···
2274
2273
* Returns: scsi result code.
2275
2274
* Notes: io_request_lock is held, interrupts are disabled.
2276
2275
*/
2277
-
static int fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
2276
+
static enum scsi_qc_status fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
2278
2277
{
2279
2278
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;
2280
2279
+7
-4
drivers/scsi/arm/fas216.h
+7
-4
drivers/scsi/arm/fas216.h
···
338
338
*/
339
339
extern int fas216_add (struct Scsi_Host *instance, struct device *dev);
340
340
341
-
/* Function: int fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
341
+
/* Function: enum scsi_qc_status fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
342
342
* Purpose : queue a command for adapter to process.
343
343
* Params : h - host adapter
344
344
* : SCpnt - Command to queue
345
345
* Returns : 0 - success, else error
346
346
*/
347
-
extern int fas216_queue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt);
347
+
extern enum scsi_qc_status fas216_queue_command(struct Scsi_Host *h,
348
+
struct scsi_cmnd *SCpnt);
348
349
349
-
/* Function: int fas216_noqueue_command(struct Scsi_Host *h, struct scsi_cmnd *SCpnt)
350
+
/* Function: enum scsi_qc_status fas216_noqueue_command(struct Scsi_Host *h,
351
+
* struct scsi_cmnd *SCpnt)
350
352
* Purpose : queue a command for adapter to process, and process it to completion.
351
353
* Params : h - host adapter
352
354
* : SCpnt - Command to queue
353
355
* Returns : 0 - success, else error
354
356
*/
355
-
extern int fas216_noqueue_command(struct Scsi_Host *, struct scsi_cmnd *);
357
+
extern enum scsi_qc_status fas216_noqueue_command(struct Scsi_Host *h,
358
+
struct scsi_cmnd *SCpnt);
356
359
357
360
/* Function: irqreturn_t fas216_intr (FAS216_Info *info)
358
361
* Purpose : handle interrupts from the interface to progress a command
+1
-1
drivers/scsi/atp870u.c
+1
-1
drivers/scsi/atp870u.c
···
617
617
*
618
618
* Queue a command to the ATP queue. Called with the host lock held.
619
619
*/
620
-
static int atp870u_queuecommand_lck(struct scsi_cmnd *req_p)
620
+
static enum scsi_qc_status atp870u_queuecommand_lck(struct scsi_cmnd *req_p)
621
621
{
622
622
void (*done)(struct scsi_cmnd *) = scsi_done;
623
623
unsigned char c;
+3
-2
drivers/scsi/bfa/bfad_im.c
+3
-2
drivers/scsi/bfa/bfad_im.c
···
24
24
struct scsi_transport_template *bfad_im_scsi_transport_template;
25
25
struct scsi_transport_template *bfad_im_scsi_vport_transport_template;
26
26
static void bfad_im_itnim_work_handler(struct work_struct *work);
27
-
static int bfad_im_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmnd);
27
+
static enum scsi_qc_status bfad_im_queuecommand(struct Scsi_Host *h,
28
+
struct scsi_cmnd *cmnd);
28
29
static int bfad_im_sdev_init(struct scsi_device *sdev);
29
30
static void bfad_im_fc_rport_add(struct bfad_im_port_s *im_port,
30
31
struct bfad_itnim_s *itnim);
···
1200
1199
/*
1201
1200
* Scsi_Host template entry, queue a SCSI command to the BFAD.
1202
1201
*/
1203
-
static int bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd)
1202
+
static enum scsi_qc_status bfad_im_queuecommand_lck(struct scsi_cmnd *cmnd)
1204
1203
{
1205
1204
void (*done)(struct scsi_cmnd *) = scsi_done;
1206
1205
struct bfad_im_port_s *im_port =
+2
-1
drivers/scsi/bnx2fc/bnx2fc.h
+2
-1
drivers/scsi/bnx2fc/bnx2fc.h
···
498
498
struct bnx2fc_cmd *bnx2fc_cmd_alloc(struct bnx2fc_rport *tgt);
499
499
struct bnx2fc_cmd *bnx2fc_elstm_alloc(struct bnx2fc_rport *tgt, int type);
500
500
void bnx2fc_cmd_release(struct kref *ref);
501
-
int bnx2fc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd);
501
+
enum scsi_qc_status bnx2fc_queuecommand(struct Scsi_Host *host,
502
+
struct scsi_cmnd *sc_cmd);
502
503
int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba);
503
504
int bnx2fc_send_fw_fcoe_destroy_msg(struct bnx2fc_hba *hba);
504
505
int bnx2fc_send_session_ofld_req(struct fcoe_port *port,
+2
-2
drivers/scsi/bnx2fc/bnx2fc_io.c
+2
-2
drivers/scsi/bnx2fc/bnx2fc_io.c
···
1836
1836
*
1837
1837
* This is the IO strategy routine, called by SCSI-ML
1838
1838
**/
1839
-
int bnx2fc_queuecommand(struct Scsi_Host *host,
1840
-
struct scsi_cmnd *sc_cmd)
1839
+
enum scsi_qc_status bnx2fc_queuecommand(struct Scsi_Host *host,
1840
+
struct scsi_cmnd *sc_cmd)
1841
1841
{
1842
1842
struct fc_lport *lport = shost_priv(host);
1843
1843
struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
+2
-2
drivers/scsi/csiostor/csio_scsi.c
+2
-2
drivers/scsi/csiostor/csio_scsi.c
···
1775
1775
* - Kicks off the SCSI state machine for this IO.
1776
1776
* - Returns busy status on error.
1777
1777
*/
1778
-
static int
1779
-
csio_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmnd)
1778
+
static enum scsi_qc_status csio_queuecommand(struct Scsi_Host *host,
1779
+
struct scsi_cmnd *cmnd)
1780
1780
{
1781
1781
struct csio_lnode *ln = shost_priv(host);
1782
1782
struct csio_hw *hw = csio_lnode_to_hw(ln);
+1
-1
drivers/scsi/dc395x.c
+1
-1
drivers/scsi/dc395x.c
···
873
873
* and is expected to be held on return.
874
874
*
875
875
*/
876
-
static int dc395x_queue_command_lck(struct scsi_cmnd *cmd)
876
+
static enum scsi_qc_status dc395x_queue_command_lck(struct scsi_cmnd *cmd)
877
877
{
878
878
void (*done)(struct scsi_cmnd *) = scsi_done;
879
879
struct DeviceCtlBlk *dcb;
+2
-1
drivers/scsi/esas2r/esas2r.h
+2
-1
drivers/scsi/esas2r/esas2r.h
···
968
968
int esas2r_ioctl(struct scsi_device *dev, unsigned int cmd, void __user *arg);
969
969
u8 handle_hba_ioctl(struct esas2r_adapter *a,
970
970
struct atto_ioctl *ioctl_hba);
971
-
int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd);
971
+
enum scsi_qc_status esas2r_queuecommand(struct Scsi_Host *host,
972
+
struct scsi_cmnd *cmd);
972
973
int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh);
973
974
long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg);
974
975
+2
-1
drivers/scsi/esas2r/esas2r_main.c
+2
-1
drivers/scsi/esas2r/esas2r_main.c
···
818
818
return len;
819
819
}
820
820
821
-
int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
821
+
enum scsi_qc_status esas2r_queuecommand(struct Scsi_Host *host,
822
+
struct scsi_cmnd *cmd)
822
823
{
823
824
struct esas2r_adapter *a =
824
825
(struct esas2r_adapter *)cmd->device->host->hostdata;
+1
-1
drivers/scsi/esp_scsi.c
+1
-1
drivers/scsi/esp_scsi.c
···
952
952
scsi_track_queue_full(dev, lp->num_tagged - 1);
953
953
}
954
954
955
-
static int esp_queuecommand_lck(struct scsi_cmnd *cmd)
955
+
static enum scsi_qc_status esp_queuecommand_lck(struct scsi_cmnd *cmd)
956
956
{
957
957
struct scsi_device *dev = cmd->device;
958
958
struct esp *esp = shost_priv(dev->host);
+2
-1
drivers/scsi/fdomain.c
+2
-1
drivers/scsi/fdomain.c
···
402
402
return IRQ_HANDLED;
403
403
}
404
404
405
-
static int fdomain_queue(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
405
+
static enum scsi_qc_status fdomain_queue(struct Scsi_Host *sh,
406
+
struct scsi_cmnd *cmd)
406
407
{
407
408
struct scsi_pointer *scsi_pointer = fdomain_scsi_pointer(cmd);
408
409
struct fdomain *fd = shost_priv(cmd->device->host);
+2
-1
drivers/scsi/fnic/fnic.h
+2
-1
drivers/scsi/fnic/fnic.h
···
503
503
void fnic_flush_tx(struct work_struct *work);
504
504
void fnic_update_mac_locked(struct fnic *, u8 *new);
505
505
506
-
int fnic_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
506
+
enum scsi_qc_status fnic_queuecommand(struct Scsi_Host *shost,
507
+
struct scsi_cmnd *sc);
507
508
int fnic_abort_cmd(struct scsi_cmnd *);
508
509
int fnic_device_reset(struct scsi_cmnd *);
509
510
int fnic_eh_host_reset_handler(struct scsi_cmnd *sc);
+2
-1
drivers/scsi/fnic/fnic_scsi.c
+2
-1
drivers/scsi/fnic/fnic_scsi.c
···
454
454
return 0;
455
455
}
456
456
457
-
int fnic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
457
+
enum scsi_qc_status fnic_queuecommand(struct Scsi_Host *shost,
458
+
struct scsi_cmnd *sc)
458
459
{
459
460
struct request *const rq = scsi_cmd_to_rq(sc);
460
461
uint32_t mqtag = 0;
+4
-2
drivers/scsi/hpsa.c
+4
-2
drivers/scsi/hpsa.c
···
276
276
#define VPD_PAGE (1 << 8)
277
277
#define HPSA_SIMPLE_ERROR_BITS 0x03
278
278
279
-
static int hpsa_scsi_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
279
+
static enum scsi_qc_status hpsa_scsi_queue_command(struct Scsi_Host *h,
280
+
struct scsi_cmnd *cmd);
280
281
static void hpsa_scan_start(struct Scsi_Host *);
281
282
static int hpsa_scan_finished(struct Scsi_Host *sh,
282
283
unsigned long elapsed_time);
···
5668
5667
}
5669
5668
5670
5669
/* Running in struct Scsi_Host->host_lock less mode */
5671
-
static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
5670
+
static enum scsi_qc_status hpsa_scsi_queue_command(struct Scsi_Host *sh,
5671
+
struct scsi_cmnd *cmd)
5672
5672
{
5673
5673
struct ctlr_info *h;
5674
5674
struct hpsa_scsi_dev_t *dev;
+1
-1
drivers/scsi/hptiop.c
+1
-1
drivers/scsi/hptiop.c
···
993
993
return 0;
994
994
}
995
995
996
-
static int hptiop_queuecommand_lck(struct scsi_cmnd *scp)
996
+
static enum scsi_qc_status hptiop_queuecommand_lck(struct scsi_cmnd *scp)
997
997
{
998
998
struct Scsi_Host *host = scp->device->host;
999
999
struct hptiop_hba *hba = (struct hptiop_hba *)host->hostdata;
+2
-1
drivers/scsi/ibmvscsi/ibmvfc.c
+2
-1
drivers/scsi/ibmvscsi/ibmvfc.c
···
1960
1960
* Returns:
1961
1961
* 0 on success / other on failure
1962
1962
**/
1963
-
static int ibmvfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
1963
+
static enum scsi_qc_status ibmvfc_queuecommand(struct Scsi_Host *shost,
1964
+
struct scsi_cmnd *cmnd)
1964
1965
{
1965
1966
struct ibmvfc_host *vhost = shost_priv(shost);
1966
1967
struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
+5
-4
drivers/scsi/ibmvscsi/ibmvscsi.c
+5
-4
drivers/scsi/ibmvscsi/ibmvscsi.c
···
868
868
* Returns the value returned from ibmvscsi_send_crq(). (Zero for success)
869
869
* Note that this routine assumes that host_lock is held for synchronization
870
870
*/
871
-
static int ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
872
-
struct ibmvscsi_host_data *hostdata,
873
-
unsigned long timeout)
871
+
static enum scsi_qc_status
872
+
ibmvscsi_send_srp_event(struct srp_event_struct *evt_struct,
873
+
struct ibmvscsi_host_data *hostdata,
874
+
unsigned long timeout)
874
875
{
875
876
__be64 *crq_as_u64 = (__be64 *)&evt_struct->crq;
876
877
int request_status = 0;
···
1041
1040
* @cmnd: struct scsi_cmnd to be executed
1042
1041
* @done: Callback function to be called when cmd is completed
1043
1042
*/
1044
-
static int ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd)
1043
+
static enum scsi_qc_status ibmvscsi_queuecommand_lck(struct scsi_cmnd *cmnd)
1045
1044
{
1046
1045
void (*done)(struct scsi_cmnd *) = scsi_done;
1047
1046
struct srp_cmd *srp_cmd;
+1
-1
drivers/scsi/imm.c
+1
-1
drivers/scsi/imm.c
+1
-1
drivers/scsi/initio.c
+1
-1
drivers/scsi/initio.c
···
2606
2606
* zero if successful or indicate a host busy condition if not (which
2607
2607
* will cause the mid layer to call us again later with the command)
2608
2608
*/
2609
-
static int i91u_queuecommand_lck(struct scsi_cmnd *cmd)
2609
+
static enum scsi_qc_status i91u_queuecommand_lck(struct scsi_cmnd *cmd)
2610
2610
{
2611
2611
struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata;
2612
2612
struct scsi_ctrl_blk *cmnd;
+2
-2
drivers/scsi/ipr.c
+2
-2
drivers/scsi/ipr.c
···
6242
6242
* SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6243
6243
* SCSI_MLQUEUE_HOST_BUSY if host is busy
6244
6244
**/
6245
-
static int ipr_queuecommand(struct Scsi_Host *shost,
6246
-
struct scsi_cmnd *scsi_cmd)
6245
+
static enum scsi_qc_status ipr_queuecommand(struct Scsi_Host *shost,
6246
+
struct scsi_cmnd *scsi_cmd)
6247
6247
{
6248
6248
struct ipr_ioa_cfg *ioa_cfg;
6249
6249
struct ipr_resource_entry *res;
+2
-2
drivers/scsi/ips.c
+2
-2
drivers/scsi/ips.c
···
230
230
*/
231
231
static int ips_eh_abort(struct scsi_cmnd *);
232
232
static int ips_eh_reset(struct scsi_cmnd *);
233
-
static int ips_queue(struct Scsi_Host *, struct scsi_cmnd *);
233
+
static enum scsi_qc_status ips_queue(struct Scsi_Host *, struct scsi_cmnd *);
234
234
static const char *ips_info(struct Scsi_Host *);
235
235
static irqreturn_t do_ipsintr(int, void *);
236
236
static int ips_hainit(ips_ha_t *);
···
1017
1017
/* Linux obtains io_request_lock before calling this function */
1018
1018
/* */
1019
1019
/****************************************************************************/
1020
-
static int ips_queue_lck(struct scsi_cmnd *SC)
1020
+
static enum scsi_qc_status ips_queue_lck(struct scsi_cmnd *SC)
1021
1021
{
1022
1022
void (*done)(struct scsi_cmnd *) = scsi_done;
1023
1023
ips_ha_t *ha;
+2
-1
drivers/scsi/libfc/fc_fcp.c
+2
-1
drivers/scsi/libfc/fc_fcp.c
···
1854
1854
*
1855
1855
* This is the i/o strategy routine, called by the SCSI layer.
1856
1856
*/
1857
-
int fc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc_cmd)
1857
+
enum scsi_qc_status fc_queuecommand(struct Scsi_Host *shost,
1858
+
struct scsi_cmnd *sc_cmd)
1858
1859
{
1859
1860
struct fc_lport *lport = shost_priv(shost);
1860
1861
struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
+2
-1
drivers/scsi/libiscsi.c
+2
-1
drivers/scsi/libiscsi.c
···
1747
1747
FAILURE_SESSION_NOT_READY,
1748
1748
};
1749
1749
1750
-
int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
1750
+
enum scsi_qc_status iscsi_queuecommand(struct Scsi_Host *host,
1751
+
struct scsi_cmnd *sc)
1751
1752
{
1752
1753
struct iscsi_cls_session *cls_session;
1753
1754
struct iscsi_host *ihost;
+2
-1
drivers/scsi/libsas/sas_scsi_host.c
+2
-1
drivers/scsi/libsas/sas_scsi_host.c
···
157
157
return task;
158
158
}
159
159
160
-
int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
160
+
enum scsi_qc_status sas_queuecommand(struct Scsi_Host *host,
161
+
struct scsi_cmnd *cmd)
161
162
{
162
163
struct sas_internal *i = to_sas_internal(host->transportt);
163
164
struct domain_device *dev = cmd_to_domain_dev(cmd);
+4
-4
drivers/scsi/lpfc/lpfc_scsi.c
+4
-4
drivers/scsi/lpfc/lpfc_scsi.c
···
5233
5233
* 0 - Success
5234
5234
* SCSI_MLQUEUE_HOST_BUSY - Block all devices served by this host temporarily.
5235
5235
**/
5236
-
static int
5237
-
lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
5236
+
static enum scsi_qc_status lpfc_queuecommand(struct Scsi_Host *shost,
5237
+
struct scsi_cmnd *cmnd)
5238
5238
{
5239
5239
struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5240
5240
struct lpfc_hba *phba = vport->phba;
···
6743
6743
return false;
6744
6744
}
6745
6745
6746
-
static int
6747
-
lpfc_no_command(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
6746
+
static enum scsi_qc_status lpfc_no_command(struct Scsi_Host *shost,
6747
+
struct scsi_cmnd *cmnd)
6748
6748
{
6749
6749
return SCSI_MLQUEUE_HOST_BUSY;
6750
6750
}
+1
-1
drivers/scsi/mac53c94.c
+1
-1
drivers/scsi/mac53c94.c
···
66
66
static void cmd_done(struct fsc_state *, int result);
67
67
static void set_dma_cmds(struct fsc_state *, struct scsi_cmnd *);
68
68
69
-
static int mac53c94_queue_lck(struct scsi_cmnd *cmd)
69
+
static enum scsi_qc_status mac53c94_queue_lck(struct scsi_cmnd *cmd)
70
70
{
71
71
struct fsc_state *state;
72
72
+9
-8
drivers/scsi/megaraid.c
+9
-8
drivers/scsi/megaraid.c
···
372
372
*
373
373
* The command queuing entry point for the mid-layer.
374
374
*/
375
-
static int megaraid_queue_lck(struct scsi_cmnd *scmd)
375
+
static enum scsi_qc_status megaraid_queue_lck(struct scsi_cmnd *scmd)
376
376
{
377
377
adapter_t *adapter;
378
378
scb_t *scb;
379
-
int busy=0;
379
+
enum scsi_qc_status busy = 0;
380
380
unsigned long flags;
381
381
382
382
adapter = (adapter_t *)scmd->device->host->hostdata;
···
518
518
* boot settings.
519
519
*/
520
520
static scb_t *
521
-
mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd, int *busy)
521
+
mega_build_cmd(adapter_t *adapter, struct scsi_cmnd *cmd,
522
+
enum scsi_qc_status *busy)
522
523
{
523
524
mega_passthru *pthru;
524
525
scb_t *scb;
···
641
640
}
642
641
643
642
if(!(scb = mega_allocate_scb(adapter, cmd))) {
644
-
*busy = 1;
643
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
645
644
return NULL;
646
645
}
647
646
···
689
688
690
689
/* Allocate a SCB and initialize passthru */
691
690
if(!(scb = mega_allocate_scb(adapter, cmd))) {
692
-
*busy = 1;
691
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
693
692
return NULL;
694
693
}
695
694
pthru = scb->pthru;
···
731
730
732
731
/* Allocate a SCB and initialize mailbox */
733
732
if(!(scb = mega_allocate_scb(adapter, cmd))) {
734
-
*busy = 1;
733
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
735
734
return NULL;
736
735
}
737
736
mbox = (mbox_t *)scb->raw_mbox;
···
871
870
872
871
/* Allocate a SCB and initialize mailbox */
873
872
if(!(scb = mega_allocate_scb(adapter, cmd))) {
874
-
*busy = 1;
873
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
875
874
return NULL;
876
875
}
877
876
···
899
898
else {
900
899
/* Allocate a SCB and initialize passthru */
901
900
if(!(scb = mega_allocate_scb(adapter, cmd))) {
902
-
*busy = 1;
901
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
903
902
return NULL;
904
903
}
905
904
+4
-2
drivers/scsi/megaraid.h
+4
-2
drivers/scsi/megaraid.h
···
962
962
static int issue_scb(adapter_t *, scb_t *);
963
963
static int mega_setup_mailbox(adapter_t *);
964
964
965
-
static int megaraid_queue (struct Scsi_Host *, struct scsi_cmnd *);
966
-
static scb_t * mega_build_cmd(adapter_t *, struct scsi_cmnd *, int *);
965
+
static enum scsi_qc_status megaraid_queue(struct Scsi_Host *,
966
+
struct scsi_cmnd *);
967
+
static scb_t *mega_build_cmd(adapter_t *, struct scsi_cmnd *,
968
+
enum scsi_qc_status *);
967
969
static void __mega_runpendq(adapter_t *);
968
970
static int issue_scb_block(adapter_t *, u_char *);
969
971
+13
-10
drivers/scsi/megaraid/megaraid_mbox.c
+13
-10
drivers/scsi/megaraid/megaraid_mbox.c
···
109
109
static void megaraid_mbox_display_scb(adapter_t *, scb_t *);
110
110
static void megaraid_mbox_setup_device_map(adapter_t *);
111
111
112
-
static int megaraid_queue_command(struct Scsi_Host *, struct scsi_cmnd *);
113
-
static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *, int *);
112
+
static enum scsi_qc_status megaraid_queue_command(struct Scsi_Host *,
113
+
struct scsi_cmnd *);
114
+
static scb_t *megaraid_mbox_build_cmd(adapter_t *, struct scsi_cmnd *,
115
+
enum scsi_qc_status *);
114
116
static void megaraid_mbox_runpendq(adapter_t *, scb_t *);
115
117
static void megaraid_mbox_prepare_pthru(adapter_t *, scb_t *,
116
118
struct scsi_cmnd *);
···
1436
1434
*
1437
1435
* Queue entry point for mailbox based controllers.
1438
1436
*/
1439
-
static int megaraid_queue_command_lck(struct scsi_cmnd *scp)
1437
+
static enum scsi_qc_status megaraid_queue_command_lck(struct scsi_cmnd *scp)
1440
1438
{
1441
1439
void (*done)(struct scsi_cmnd *) = scsi_done;
1442
1440
adapter_t *adapter;
1443
1441
scb_t *scb;
1444
-
int if_busy;
1442
+
enum scsi_qc_status if_busy;
1445
1443
1446
1444
adapter = SCP2ADAPTER(scp);
1447
1445
scp->result = 0;
···
1479
1477
* firmware. We also complete certain commands without sending them to firmware.
1480
1478
*/
1481
1479
static scb_t *
1482
-
megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp, int *busy)
1480
+
megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp,
1481
+
enum scsi_qc_status *busy)
1483
1482
{
1484
1483
mraid_device_t *rdev = ADAP2RAIDDEV(adapter);
1485
1484
int channel;
···
1519
1516
1520
1517
if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1521
1518
scp->result = (DID_ERROR << 16);
1522
-
*busy = 1;
1519
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
1523
1520
return NULL;
1524
1521
}
1525
1522
···
1602
1599
/* Allocate a SCB and initialize passthru */
1603
1600
if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1604
1601
scp->result = (DID_ERROR << 16);
1605
-
*busy = 1;
1602
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
1606
1603
return NULL;
1607
1604
}
1608
1605
···
1647
1644
*/
1648
1645
if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1649
1646
scp->result = (DID_ERROR << 16);
1650
-
*busy = 1;
1647
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
1651
1648
return NULL;
1652
1649
}
1653
1650
ccb = (mbox_ccb_t *)scb->ccb;
···
1743
1740
*/
1744
1741
if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1745
1742
scp->result = (DID_ERROR << 16);
1746
-
*busy = 1;
1743
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
1747
1744
return NULL;
1748
1745
}
1749
1746
···
1811
1808
// Allocate a SCB and initialize passthru
1812
1809
if (!(scb = megaraid_alloc_scb(adapter, scp))) {
1813
1810
scp->result = (DID_ERROR << 16);
1814
-
*busy = 1;
1811
+
*busy = SCSI_MLQUEUE_HOST_BUSY;
1815
1812
return NULL;
1816
1813
}
1817
1814
+2
-2
drivers/scsi/megaraid/megaraid_sas_base.c
+2
-2
drivers/scsi/megaraid/megaraid_sas_base.c
···
1781
1781
* @shost: adapter SCSI host
1782
1782
* @scmd: SCSI command to be queued
1783
1783
*/
1784
-
static int
1785
-
megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
1784
+
static enum scsi_qc_status megasas_queue_command(struct Scsi_Host *shost,
1785
+
struct scsi_cmnd *scmd)
1786
1786
{
1787
1787
struct megasas_instance *instance;
1788
1788
struct MR_PRIV_DEVICE *mr_device_priv_data;
+1
-1
drivers/scsi/mesh.c
+1
-1
drivers/scsi/mesh.c
+2
-2
drivers/scsi/mpi3mr/mpi3mr_os.c
+2
-2
drivers/scsi/mpi3mr/mpi3mr_os.c
···
5029
5029
* SCSI_MLQUEUE_DEVICE_BUSY when the device is busy.
5030
5030
* SCSI_MLQUEUE_HOST_BUSY when the host queue is full.
5031
5031
*/
5032
-
static int mpi3mr_qcmd(struct Scsi_Host *shost,
5033
-
struct scsi_cmnd *scmd)
5032
+
static enum scsi_qc_status mpi3mr_qcmd(struct Scsi_Host *shost,
5033
+
struct scsi_cmnd *scmd)
5034
5034
{
5035
5035
struct mpi3mr_ioc *mrioc = shost_priv(shost);
5036
5036
struct mpi3mr_stgt_priv_data *stgt_priv_data;
+2
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
+2
-2
drivers/scsi/mpt3sas/mpt3sas_scsih.c
···
5422
5422
* SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or
5423
5423
* SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full
5424
5424
*/
5425
-
static int
5426
-
scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
5425
+
static enum scsi_qc_status scsih_qcmd(struct Scsi_Host *shost,
5426
+
struct scsi_cmnd *scmd)
5427
5427
{
5428
5428
struct MPT3SAS_ADAPTER *ioc = shost_priv(shost);
5429
5429
struct MPT3SAS_DEVICE *sas_device_priv_data;
+2
-2
drivers/scsi/mvumi.c
+2
-2
drivers/scsi/mvumi.c
···
2077
2077
* @shost: Scsi host to queue command on
2078
2078
* @scmd: SCSI command to be queued
2079
2079
*/
2080
-
static int mvumi_queue_command(struct Scsi_Host *shost,
2081
-
struct scsi_cmnd *scmd)
2080
+
static enum scsi_qc_status mvumi_queue_command(struct Scsi_Host *shost,
2081
+
struct scsi_cmnd *scmd)
2082
2082
{
2083
2083
struct mvumi_cmd *cmd;
2084
2084
struct mvumi_hba *mhba;
+6
-6
drivers/scsi/myrb.c
+6
-6
drivers/scsi/myrb.c
···
1260
1260
return SUCCESS;
1261
1261
}
1262
1262
1263
-
static int myrb_pthru_queuecommand(struct Scsi_Host *shost,
1264
-
struct scsi_cmnd *scmd)
1263
+
static enum scsi_qc_status myrb_pthru_queuecommand(struct Scsi_Host *shost,
1264
+
struct scsi_cmnd *scmd)
1265
1265
{
1266
1266
struct request *rq = scsi_cmd_to_rq(scmd);
1267
1267
struct myrb_hba *cb = shost_priv(shost);
···
1416
1416
scsi_sg_copy_from_buffer(scmd, data, 8);
1417
1417
}
1418
1418
1419
-
static int myrb_ldev_queuecommand(struct Scsi_Host *shost,
1420
-
struct scsi_cmnd *scmd)
1419
+
static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
1420
+
struct scsi_cmnd *scmd)
1421
1421
{
1422
1422
struct myrb_hba *cb = shost_priv(shost);
1423
1423
struct myrb_cmdblk *cmd_blk = scsi_cmd_priv(scmd);
···
1603
1603
return 0;
1604
1604
}
1605
1605
1606
-
static int myrb_queuecommand(struct Scsi_Host *shost,
1607
-
struct scsi_cmnd *scmd)
1606
+
static enum scsi_qc_status myrb_queuecommand(struct Scsi_Host *shost,
1607
+
struct scsi_cmnd *scmd)
1608
1608
{
1609
1609
struct scsi_device *sdev = scmd->device;
1610
1610
+2
-2
drivers/scsi/myrs.c
+2
-2
drivers/scsi/myrs.c
···
1581
1581
scsi_sg_copy_from_buffer(scmd, modes, mode_len);
1582
1582
}
1583
1583
1584
-
static int myrs_queuecommand(struct Scsi_Host *shost,
1585
-
struct scsi_cmnd *scmd)
1584
+
static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
1585
+
struct scsi_cmnd *scmd)
1586
1586
{
1587
1587
struct request *rq = scsi_cmd_to_rq(scmd);
1588
1588
struct myrs_hba *cs = shost_priv(shost);
+1
-1
drivers/scsi/ncr53c8xx.c
+1
-1
drivers/scsi/ncr53c8xx.c
···
7852
7852
return 0;
7853
7853
}
7854
7854
7855
-
static int ncr53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
7855
+
static enum scsi_qc_status ncr53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
7856
7856
{
7857
7857
struct ncr_cmd_priv *cmd_priv = scsi_cmd_priv(cmd);
7858
7858
void (*done)(struct scsi_cmnd *) = scsi_done;
+3
-2
drivers/scsi/nsp32.c
+3
-2
drivers/scsi/nsp32.c
···
185
185
static int nsp32_show_info (struct seq_file *, struct Scsi_Host *);
186
186
187
187
static int nsp32_detect (struct pci_dev *pdev);
188
-
static int nsp32_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
188
+
static enum scsi_qc_status nsp32_queuecommand(struct Scsi_Host *,
189
+
struct scsi_cmnd *);
189
190
static const char *nsp32_info (struct Scsi_Host *);
190
191
static int nsp32_release (struct Scsi_Host *);
191
192
···
906
905
return TRUE;
907
906
}
908
907
909
-
static int nsp32_queuecommand_lck(struct scsi_cmnd *SCpnt)
908
+
static enum scsi_qc_status nsp32_queuecommand_lck(struct scsi_cmnd *SCpnt)
910
909
{
911
910
void (*done)(struct scsi_cmnd *) = scsi_done;
912
911
nsp32_hw_data *data = (nsp32_hw_data *)SCpnt->device->host->hostdata;
+1
-1
drivers/scsi/pcmcia/nsp_cs.c
+1
-1
drivers/scsi/pcmcia/nsp_cs.c
+2
-1
drivers/scsi/pcmcia/nsp_cs.h
+2
-1
drivers/scsi/pcmcia/nsp_cs.h
···
294
294
static const char *nsp_info (struct Scsi_Host *shpnt);
295
295
static int nsp_show_info (struct seq_file *m,
296
296
struct Scsi_Host *host);
297
-
static int nsp_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *SCpnt);
297
+
static enum scsi_qc_status nsp_queuecommand(struct Scsi_Host *h,
298
+
struct scsi_cmnd *SCpnt);
298
299
299
300
/* Error handler */
300
301
/*static int nsp_eh_abort (struct scsi_cmnd *SCpnt);*/
+1
-1
drivers/scsi/pcmcia/sym53c500_cs.c
+1
-1
drivers/scsi/pcmcia/sym53c500_cs.c
+2
-2
drivers/scsi/pmcraid.c
+2
-2
drivers/scsi/pmcraid.c
···
3242
3242
* SCSI_MLQUEUE_DEVICE_BUSY if device is busy
3243
3243
* SCSI_MLQUEUE_HOST_BUSY if host is busy
3244
3244
*/
3245
-
static int pmcraid_queuecommand_lck(struct scsi_cmnd *scsi_cmd)
3245
+
static enum scsi_qc_status pmcraid_queuecommand_lck(struct scsi_cmnd *scsi_cmd)
3246
3246
{
3247
3247
struct pmcraid_instance *pinstance;
3248
3248
struct pmcraid_resource_entry *res;
3249
3249
struct pmcraid_ioarcb *ioarcb;
3250
+
enum scsi_qc_status rc = 0;
3250
3251
struct pmcraid_cmd *cmd;
3251
3252
u32 fw_version;
3252
-
int rc = 0;
3253
3253
3254
3254
pinstance =
3255
3255
(struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
+1
-1
drivers/scsi/ppa.c
+1
-1
drivers/scsi/ppa.c
+1
-1
drivers/scsi/ps3rom.c
+1
-1
drivers/scsi/ps3rom.c
···
201
201
return 0;
202
202
}
203
203
204
-
static int ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
204
+
static enum scsi_qc_status ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
205
205
{
206
206
struct ps3rom_private *priv = shost_priv(cmd->device->host);
207
207
struct ps3_storage_device *dev = priv->dev;
+2
-2
drivers/scsi/qedf/qedf.h
+2
-2
drivers/scsi/qedf/qedf.h
···
487
487
488
488
extern struct qedf_cmd_mgr *qedf_cmd_mgr_alloc(struct qedf_ctx *qedf);
489
489
extern void qedf_cmd_mgr_free(struct qedf_cmd_mgr *cmgr);
490
-
extern int qedf_queuecommand(struct Scsi_Host *host,
491
-
struct scsi_cmnd *sc_cmd);
490
+
extern enum scsi_qc_status qedf_queuecommand(struct Scsi_Host *host,
491
+
struct scsi_cmnd *sc_cmd);
492
492
extern void qedf_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb);
493
493
extern u8 *qedf_get_src_mac(struct fc_lport *lport);
494
494
extern void qedf_fip_recv(struct qedf_ctx *qedf, struct sk_buff *skb);
+2
-2
drivers/scsi/qedf/qedf_io.c
+2
-2
drivers/scsi/qedf/qedf_io.c
···
930
930
return false;
931
931
}
932
932
933
-
int
934
-
qedf_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc_cmd)
933
+
enum scsi_qc_status qedf_queuecommand(struct Scsi_Host *host,
934
+
struct scsi_cmnd *sc_cmd)
935
935
{
936
936
struct fc_lport *lport = shost_priv(host);
937
937
struct qedf_ctx *qedf = lport_priv(lport);
+10
-8
drivers/scsi/qla1280.c
+10
-8
drivers/scsi/qla1280.c
···
406
406
static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
407
407
static int qla1280_abort_isp(struct scsi_qla_host *);
408
408
#ifdef QLA_64BIT_PTR
409
-
static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
409
+
static enum scsi_qc_status qla1280_64bit_start_scsi(struct scsi_qla_host *,
410
+
struct srb *);
410
411
#else
411
-
static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
412
+
static enum scsi_qc_status qla1280_32bit_start_scsi(struct scsi_qla_host *,
413
+
struct srb *);
412
414
#endif
413
415
static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
414
416
static void qla1280_poll(struct scsi_qla_host *);
···
684
682
* handling). Unfortunately, it sometimes calls the scheduler in interrupt
685
683
* context which is a big NO! NO!.
686
684
**************************************************************************/
687
-
static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
685
+
static enum scsi_qc_status qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
688
686
{
689
687
struct Scsi_Host *host = cmd->device->host;
690
688
struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
691
689
struct srb *sp = scsi_cmd_priv(cmd);
692
-
int status;
690
+
enum scsi_qc_status status;
693
691
694
692
sp->cmd = cmd;
695
693
sp->flags = 0;
···
2732
2730
* 0 = success, was able to issue command.
2733
2731
*/
2734
2732
#ifdef QLA_64BIT_PTR
2735
-
static int
2733
+
static enum scsi_qc_status
2736
2734
qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2737
2735
{
2738
2736
struct device_reg __iomem *reg = ha->iobase;
···
2740
2738
cmd_a64_entry_t *pkt;
2741
2739
__le32 *dword_ptr;
2742
2740
dma_addr_t dma_handle;
2743
-
int status = 0;
2741
+
enum scsi_qc_status status = 0;
2744
2742
int cnt;
2745
2743
int req_cnt;
2746
2744
int seg_cnt;
···
2986
2984
* Returns:
2987
2985
* 0 = success, was able to issue command.
2988
2986
*/
2989
-
static int
2987
+
static enum scsi_qc_status
2990
2988
qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2991
2989
{
2992
2990
struct device_reg __iomem *reg = ha->iobase;
2993
2991
struct scsi_cmnd *cmd = sp->cmd;
2994
2992
struct cmd_entry *pkt;
2995
2993
__le32 *dword_ptr;
2996
-
int status = 0;
2994
+
enum scsi_qc_status status = 0;
2997
2995
int cnt;
2998
2996
int req_cnt;
2999
2997
int seg_cnt;
+7
-6
drivers/scsi/qla2xxx/qla_os.c
+7
-6
drivers/scsi/qla2xxx/qla_os.c
···
402
402
struct req_que **, struct rsp_que **);
403
403
static void qla2x00_free_fw_dump(struct qla_hw_data *);
404
404
static void qla2x00_mem_free(struct qla_hw_data *);
405
-
int qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
406
-
struct qla_qpair *qpair);
405
+
static enum scsi_qc_status qla2xxx_mqueuecommand(struct Scsi_Host *host,
406
+
struct scsi_cmnd *cmd,
407
+
struct qla_qpair *qpair);
407
408
408
409
/* -------------------------------------------------------------------------- */
409
410
static void qla_init_base_qpair(struct scsi_qla_host *vha, struct req_que *req,
···
859
858
complete(comp);
860
859
}
861
860
862
-
static int
863
-
qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
861
+
static enum scsi_qc_status qla2xxx_queuecommand(struct Scsi_Host *host,
862
+
struct scsi_cmnd *cmd)
864
863
{
865
864
scsi_qla_host_t *vha = shost_priv(host);
866
865
fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
···
982
981
}
983
982
984
983
/* For MQ supported I/O */
985
-
int
984
+
static enum scsi_qc_status
986
985
qla2xxx_mqueuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd,
987
-
struct qla_qpair *qpair)
986
+
struct qla_qpair *qpair)
988
987
{
989
988
scsi_qla_host_t *vha = shost_priv(host);
990
989
fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
+4
-2
drivers/scsi/qla4xxx/ql4_os.c
+4
-2
drivers/scsi/qla4xxx/ql4_os.c
···
155
155
/*
156
156
* SCSI host template entry points
157
157
*/
158
-
static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd);
158
+
static enum scsi_qc_status qla4xxx_queuecommand(struct Scsi_Host *h,
159
+
struct scsi_cmnd *cmd);
159
160
static int qla4xxx_eh_abort(struct scsi_cmnd *cmd);
160
161
static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd);
161
162
static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd);
···
4108
4107
* completion handling). Unfortunately, it sometimes calls the scheduler
4109
4108
* in interrupt context which is a big NO! NO!.
4110
4109
**/
4111
-
static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
4110
+
static enum scsi_qc_status qla4xxx_queuecommand(struct Scsi_Host *host,
4111
+
struct scsi_cmnd *cmd)
4112
4112
{
4113
4113
struct scsi_qla_host *ha = to_qla_host(host);
4114
4114
struct ddb_entry *ddb_entry = cmd->device->hostdata;
+1
-1
drivers/scsi/qlogicfas408.c
+1
-1
drivers/scsi/qlogicfas408.c
···
464
464
* Queued command
465
465
*/
466
466
467
-
static int qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd)
467
+
static enum scsi_qc_status qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd)
468
468
{
469
469
void (*done)(struct scsi_cmnd *) = scsi_done;
470
470
struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
+2
-1
drivers/scsi/qlogicfas408.h
+2
-1
drivers/scsi/qlogicfas408.h
···
104
104
#define get_priv_by_host(x) (struct qlogicfas408_priv *)&((x)->hostdata[0])
105
105
106
106
irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id);
107
-
int qlogicfas408_queuecommand(struct Scsi_Host *h, struct scsi_cmnd * cmd);
107
+
enum scsi_qc_status qlogicfas408_queuecommand(struct Scsi_Host *h,
108
+
struct scsi_cmnd *cmd);
108
109
int qlogicfas408_biosparam(struct scsi_device * disk,
109
110
struct gendisk *unused,
110
111
sector_t capacity, int ip[]);
+1
-1
drivers/scsi/qlogicpti.c
+1
-1
drivers/scsi/qlogicpti.c
···
1015
1015
*
1016
1016
* "This code must fly." -davem
1017
1017
*/
1018
-
static int qlogicpti_queuecommand_lck(struct scsi_cmnd *Cmnd)
1018
+
static enum scsi_qc_status qlogicpti_queuecommand_lck(struct scsi_cmnd *Cmnd)
1019
1019
{
1020
1020
void (*done)(struct scsi_cmnd *) = scsi_done;
1021
1021
struct Scsi_Host *host = Cmnd->device->host;
+5
-4
drivers/scsi/scsi_debug.c
+5
-4
drivers/scsi/scsi_debug.c
···
9284
9284
set_host_byte(scp, res ? DID_OK : DID_ERROR);
9285
9285
}
9286
9286
9287
-
static int scsi_debug_process_reserved_command(struct Scsi_Host *shost,
9288
-
struct scsi_cmnd *scp)
9287
+
static enum scsi_qc_status
9288
+
scsi_debug_process_reserved_command(struct Scsi_Host *shost,
9289
+
struct scsi_cmnd *scp)
9289
9290
{
9290
9291
struct sdebug_internal_cmd *internal_cmd = scsi_cmd_priv(scp);
9291
9292
···
9304
9303
return 0;
9305
9304
}
9306
9305
9307
-
static int scsi_debug_queuecommand(struct Scsi_Host *shost,
9308
-
struct scsi_cmnd *scp)
9306
+
static enum scsi_qc_status scsi_debug_queuecommand(struct Scsi_Host *shost,
9307
+
struct scsi_cmnd *scp)
9309
9308
{
9310
9309
u8 sdeb_i;
9311
9310
struct scsi_device *sdp = scp->device;
+2
-1
drivers/scsi/smartpqi/smartpqi_init.c
+2
-1
drivers/scsi/smartpqi/smartpqi_init.c
···
6047
6047
return false;
6048
6048
}
6049
6049
6050
-
static int pqi_scsi_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
6050
+
static enum scsi_qc_status pqi_scsi_queue_command(struct Scsi_Host *shost,
6051
+
struct scsi_cmnd *scmd)
6051
6052
{
6052
6053
int rc;
6053
6054
struct pqi_ctrl_info *ctrl_info;
+2
-1
drivers/scsi/snic/snic.h
+2
-1
drivers/scsi/snic/snic.h
···
362
362
extern struct workqueue_struct *snic_event_queue;
363
363
extern const struct attribute_group *snic_host_groups[];
364
364
365
-
int snic_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
365
+
enum scsi_qc_status snic_queuecommand(struct Scsi_Host *shost,
366
+
struct scsi_cmnd *sc);
366
367
int snic_abort_cmd(struct scsi_cmnd *);
367
368
int snic_device_reset(struct scsi_cmnd *);
368
369
int snic_host_reset(struct scsi_cmnd *);
+2
-2
drivers/scsi/snic/snic_scsi.c
+2
-2
drivers/scsi/snic/snic_scsi.c
···
315
315
* Routine to send a scsi cdb to LLD
316
316
* Called with host_lock held and interrupts disabled
317
317
*/
318
-
int
319
-
snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
318
+
enum scsi_qc_status snic_queuecommand(struct Scsi_Host *shost,
319
+
struct scsi_cmnd *sc)
320
320
{
321
321
struct snic_tgt *tgt = NULL;
322
322
struct snic *snic = shost_priv(shost);
+1
-1
drivers/scsi/stex.c
+1
-1
drivers/scsi/stex.c
+2
-1
drivers/scsi/storvsc_drv.c
+2
-1
drivers/scsi/storvsc_drv.c
···
1714
1714
return allowed;
1715
1715
}
1716
1716
1717
-
static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
1717
+
static enum scsi_qc_status storvsc_queuecommand(struct Scsi_Host *host,
1718
+
struct scsi_cmnd *scmnd)
1718
1719
{
1719
1720
int ret;
1720
1721
struct hv_host_device *host_dev = shost_priv(host);
+1
-1
drivers/scsi/sym53c8xx_2/sym_glue.c
+1
-1
drivers/scsi/sym53c8xx_2/sym_glue.c
···
485
485
* queuecommand method. Entered with the host adapter lock held and
486
486
* interrupts disabled.
487
487
*/
488
-
static int sym53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
488
+
static enum scsi_qc_status sym53c8xx_queue_command_lck(struct scsi_cmnd *cmd)
489
489
{
490
490
struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
491
491
struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd);
+2
-2
drivers/scsi/virtio_scsi.c
+2
-2
drivers/scsi/virtio_scsi.c
···
561
561
return &vscsi->req_vqs[hwq];
562
562
}
563
563
564
-
static int virtscsi_queuecommand(struct Scsi_Host *shost,
565
-
struct scsi_cmnd *sc)
564
+
static enum scsi_qc_status virtscsi_queuecommand(struct Scsi_Host *shost,
565
+
struct scsi_cmnd *sc)
566
566
{
567
567
struct virtio_scsi *vscsi = shost_priv(shost);
568
568
struct virtio_scsi_vq *req_vq = virtscsi_pick_vq_mq(vscsi, sc);
+1
-1
drivers/scsi/vmw_pvscsi.c
+1
-1
drivers/scsi/vmw_pvscsi.c
+1
-1
drivers/scsi/wd33c93.c
+1
-1
drivers/scsi/wd33c93.c
···
302
302
msg[1] = offset;
303
303
}
304
304
305
-
static int wd33c93_queuecommand_lck(struct scsi_cmnd *cmd)
305
+
static enum scsi_qc_status wd33c93_queuecommand_lck(struct scsi_cmnd *cmd)
306
306
{
307
307
struct scsi_pointer *scsi_pointer = WD33C93_scsi_pointer(cmd);
308
308
struct WD33C93_hostdata *hostdata;
+2
-1
drivers/scsi/wd33c93.h
+2
-1
drivers/scsi/wd33c93.h
···
332
332
void wd33c93_init (struct Scsi_Host *instance, const wd33c93_regs regs,
333
333
dma_setup_t setup, dma_stop_t stop, int clock_freq);
334
334
int wd33c93_abort (struct scsi_cmnd *cmd);
335
-
int wd33c93_queuecommand (struct Scsi_Host *h, struct scsi_cmnd *cmd);
335
+
enum scsi_qc_status wd33c93_queuecommand(struct Scsi_Host *h,
336
+
struct scsi_cmnd *cmd);
336
337
void wd33c93_intr (struct Scsi_Host *instance);
337
338
int wd33c93_show_info(struct seq_file *, struct Scsi_Host *);
338
339
int wd33c93_write_info(struct Scsi_Host *, char *, int);
+2
-1
drivers/scsi/wd719x.c
+2
-1
drivers/scsi/wd719x.c
···
204
204
}
205
205
206
206
/* Build a SCB and send it to the card */
207
-
static int wd719x_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
207
+
static enum scsi_qc_status wd719x_queuecommand(struct Scsi_Host *sh,
208
+
struct scsi_cmnd *cmd)
208
209
{
209
210
int i, count_sg;
210
211
unsigned long flags;
+2
-2
drivers/scsi/xen-scsifront.c
+2
-2
drivers/scsi/xen-scsifront.c
···
603
603
wake_up(&info->wq_pause);
604
604
}
605
605
606
-
static int scsifront_queuecommand(struct Scsi_Host *shost,
607
-
struct scsi_cmnd *sc)
606
+
static enum scsi_qc_status scsifront_queuecommand(struct Scsi_Host *shost,
607
+
struct scsi_cmnd *sc)
608
608
{
609
609
struct vscsifrnt_info *info = shost_priv(shost);
610
610
struct vscsifrnt_shadow *shadow = scsi_cmd_priv(sc);
+2
-1
drivers/target/loopback/tcm_loop.c
+2
-1
drivers/target/loopback/tcm_loop.c
···
165
165
* ->queuecommand can be and usually is called from interrupt context, so
166
166
* defer the actual submission to a workqueue.
167
167
*/
168
-
static int tcm_loop_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
168
+
static enum scsi_qc_status tcm_loop_queuecommand(struct Scsi_Host *sh,
169
+
struct scsi_cmnd *sc)
169
170
{
170
171
struct tcm_loop_cmd *tl_cmd = scsi_cmd_priv(sc);
171
172
+4
-3
drivers/ufs/core/ufshcd.c
+4
-3
drivers/ufs/core/ufshcd.c
···
3033
3033
*
3034
3034
* Return: 0 for success, non-zero in case of failure.
3035
3035
*/
3036
-
static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
3036
+
static enum scsi_qc_status ufshcd_queuecommand(struct Scsi_Host *host,
3037
+
struct scsi_cmnd *cmd)
3037
3038
{
3038
3039
struct ufs_hba *hba = shost_priv(host);
3039
3040
int tag = scsi_cmd_to_rq(cmd)->tag;
···
3114
3113
return err;
3115
3114
}
3116
3115
3117
-
static int ufshcd_queue_reserved_command(struct Scsi_Host *host,
3118
-
struct scsi_cmnd *cmd)
3116
+
static enum scsi_qc_status ufshcd_queue_reserved_command(struct Scsi_Host *host,
3117
+
struct scsi_cmnd *cmd)
3119
3118
{
3120
3119
struct ufshcd_lrb *lrbp = scsi_cmd_priv(cmd);
3121
3120
struct request *rq = scsi_cmd_to_rq(cmd);
+3
-3
drivers/usb/image/microtek.c
+3
-3
drivers/usb/image/microtek.c
···
355
355
return result ? FAILED : SUCCESS;
356
356
}
357
357
358
-
static int
359
-
mts_scsi_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *srb);
358
+
static enum scsi_qc_status mts_scsi_queuecommand(struct Scsi_Host *shost,
359
+
struct scsi_cmnd *srb);
360
360
361
361
static void mts_transfer_cleanup( struct urb *transfer );
362
362
static void mts_do_sg(struct urb * transfer);
···
559
559
desc->context.data_pipe = pipe;
560
560
}
561
561
562
-
static int mts_scsi_queuecommand_lck(struct scsi_cmnd *srb)
562
+
static enum scsi_qc_status mts_scsi_queuecommand_lck(struct scsi_cmnd *srb)
563
563
{
564
564
mts_scsi_cmnd_callback callback = scsi_done;
565
565
struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]);
+1
-1
drivers/usb/storage/scsiglue.c
+1
-1
drivers/usb/storage/scsiglue.c
···
357
357
358
358
/* queue a command */
359
359
/* This is always called with scsi_lock(host) held */
360
-
static int queuecommand_lck(struct scsi_cmnd *srb)
360
+
static enum scsi_qc_status queuecommand_lck(struct scsi_cmnd *srb)
361
361
{
362
362
void (*done)(struct scsi_cmnd *) = scsi_done;
363
363
struct us_data *us = host_to_us(srb->device->host);
+1
-1
drivers/usb/storage/uas.c
+1
-1
drivers/usb/storage/uas.c
+2
-1
include/linux/libata.h
+2
-1
include/linux/libata.h
···
1150
1150
#else
1151
1151
#define ATA_SCSI_COMPAT_IOCTL /* empty */
1152
1152
#endif
1153
-
extern int ata_scsi_queuecmd(struct Scsi_Host *h, struct scsi_cmnd *cmd);
1153
+
extern enum scsi_qc_status ata_scsi_queuecmd(struct Scsi_Host *h,
1154
+
struct scsi_cmnd *cmd);
1154
1155
#if IS_REACHABLE(CONFIG_ATA)
1155
1156
bool ata_scsi_dma_need_drain(struct request *rq);
1156
1157
#else
+2
-1
include/scsi/libfc.h
+2
-1
include/scsi/libfc.h
···
959
959
/*
960
960
* SCSI INTERACTION LAYER
961
961
*****************************/
962
-
int fc_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
962
+
enum scsi_qc_status fc_queuecommand(struct Scsi_Host *shost,
963
+
struct scsi_cmnd *cmnd);
963
964
int fc_eh_abort(struct scsi_cmnd *);
964
965
int fc_eh_device_reset(struct scsi_cmnd *);
965
966
int fc_eh_host_reset(struct scsi_cmnd *);
+2
-1
include/scsi/libiscsi.h
+2
-1
include/scsi/libiscsi.h
···
392
392
extern int iscsi_eh_recover_target(struct scsi_cmnd *sc);
393
393
extern int iscsi_eh_session_reset(struct scsi_cmnd *sc);
394
394
extern int iscsi_eh_device_reset(struct scsi_cmnd *sc);
395
-
extern int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc);
395
+
extern enum scsi_qc_status iscsi_queuecommand(struct Scsi_Host *host,
396
+
struct scsi_cmnd *sc);
396
397
extern enum scsi_timeout_action iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc);
397
398
398
399
/*
+2
-1
include/scsi/libsas.h
+2
-1
include/scsi/libsas.h
···
689
689
690
690
int sas_phy_reset(struct sas_phy *phy, int hard_reset);
691
691
int sas_phy_enable(struct sas_phy *phy, int enable);
692
-
extern int sas_queuecommand(struct Scsi_Host *, struct scsi_cmnd *);
692
+
extern enum scsi_qc_status sas_queuecommand(struct Scsi_Host *host,
693
+
struct scsi_cmnd *cmd);
693
694
extern int sas_target_alloc(struct scsi_target *);
694
695
int sas_sdev_configure(struct scsi_device *dev, struct queue_limits *lim);
695
696
extern int sas_change_queue_depth(struct scsi_device *, int new_depth);
+8
-4
include/scsi/scsi_host.h
+8
-4
include/scsi/scsi_host.h
···
84
84
*
85
85
* STATUS: REQUIRED
86
86
*/
87
-
int (* queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
87
+
enum scsi_qc_status (*queuecommand)(struct Scsi_Host *,
88
+
struct scsi_cmnd *);
88
89
89
90
/*
90
91
* Queue a reserved command (BLK_MQ_REQ_RESERVED). The .queuecommand()
91
92
* documentation also applies to the .queue_reserved_command() callback.
92
93
*/
93
-
int (*queue_reserved_command)(struct Scsi_Host *, struct scsi_cmnd *);
94
+
enum scsi_qc_status (*queue_reserved_command)(struct Scsi_Host *,
95
+
struct scsi_cmnd *);
94
96
95
97
/*
96
98
* The commit_rqs function is used to trigger a hardware
···
527
525
*
528
526
*/
529
527
#define DEF_SCSI_QCMD(func_name) \
530
-
int func_name(struct Scsi_Host *shost, struct scsi_cmnd *cmd) \
528
+
enum scsi_qc_status func_name(struct Scsi_Host *shost, \
529
+
struct scsi_cmnd *cmd) \
531
530
{ \
532
531
unsigned long irq_flags; \
533
-
int rc; \
532
+
enum scsi_qc_status rc; \
533
+
\
534
534
spin_lock_irqsave(shost->host_lock, irq_flags); \
535
535
rc = func_name##_lck(cmd); \
536
536
spin_unlock_irqrestore(shost->host_lock, irq_flags); \