github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-06 21:58:01 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

SCSI misc on 20261024

Browse Source 
Small number of driver updates (mpi3mr, ufs, scsi_debug).  By far the
 biggest core change (at 4000+ lines) is the sense code rework to make
 our sense handling follow the 16 bit defines in the SCSI standard rather
 than our split ASC and ASCQ handling which ends up being confusing and
 difficult to grep.  The changes should all be functionally equivalent
 and so far the bots and AI seem to agree; the code has been incubating
 in -next since 16 September with one reported issue fixed.  The
 remaining updates are minor.
 
 Signed-off-by: James E.J. Bottomley <James.Bottomley@HansenPartnership.com>
 -----BEGIN PGP SIGNATURE-----
 
 iLgEABMIAGAWIQTnYEDbdso9F2cI+arnQslM7pishQUCatzJaBsUgAAAAAAEAA5t
 YW51MiwyLjUrMS4xMiwyLDImHGphbWVzLmJvdHRvbWxleUBoYW5zZW5wYXJ0bmVy
 c2hpcC5jb20ACgkQ50LJTO6YrIWW/wD/fmJBqJpD/epJBa98PyfDB1dopBBWzWHD
 mzDlHj9ESWMBAPKhvNYHJ6imR2ZuELrGtbhjD3BpmKz2KufphyeWdhEm
 =jmrS
 -----END PGP SIGNATURE-----

Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull SCSI updates from James Bottomley:
 "Small number of driver updates (mpi3mr, ufs, scsi_debug).

  By far the biggest core change (at 4000+ lines) is the sense code
  rework to make our sense handling follow the 16 bit defines in the
  SCSI standard rather than our split ASC and ASCQ handling which ends
  up being confusing and difficult to grep.

  The changes should all be functionally equivalent and so far the bots
  and AI seem to agree; the code has been incubating in -next since 16
  September with one reported issue fixed.

  The remaining updates are minor"

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (114 commits)
  scsi: ufs: rpmb: Fix power-on UNIT ATTENTION retry
  scsi: bfa: Use snprintf() in bfa_fcs_fabric_psymb_init()
  scsi: bfa: Use snprintf() in bfa_fcs_fabric_nsymb_init()
  scsi: MAINTAINERS: Remove Avri Altman as UFS reviewer
  scsi: st: Relock the door after a reset
  scsi: st: Restore the drive buffering mode after reset
  scsi: st: Record the tape position after a successful MTLOAD
  scsi: st: Restore changed drive settings after reset also for MTLOAD and MTRETEN
  scsi: scsi_debug: Validate the access parameters of WRITE ATOMIC (16)
  scsi: scsi_debug: Map the region written by WRITE ATOMIC (16)
  scsi: scsi_debug: Refuse a short WRITE ATOMIC (16) before writing it
  scsi: scsi_debug: Advance the write pointer over the data written
  scsi: scsi_debug: Do not write a partial physical block to a zoned device
  scsi: scsi_debug: Enforce physical block alignment of zoned writes
  scsi: scsi_debug: Report the residual of a write
  scsi: scsi_debug: Avoid 32-bit overflow in WRITE SCATTERED offsets
  scsi: scsi_debug: Evaluate scsi_debug_lbp() only once
  scsi: scsi_debug: Take the zone metadata lock before the data lock
  scsi: scsi_debug: Refuse a negative physblk_exp
  scsi: scsi_debug: Make atomic writes and ZBC emulation mutually exclusive
  ...
This commit is contained in:
Linus Torvalds 2026-10-24 14:30:22 -10:00
commit 6fba331225
170 changed files with 6247 additions and 3555 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Documentation/scsi/scsi_mid_low_api.rst
View File

@ -865,7 +865,7 @@ Details::
*
* Other types of errors that are detected immediately may be
* flagged by setting scp->result to an appropriate value,
* invoking the scp->scsi_done callback, and then returning 0
* invoking the scsi_done() function, and then returning 0
* from this function. If the command is not performed
* immediately (and the LLD is starting (or will start) the given
* command) then this function should place 0 in scp->result and
@ -873,11 +873,11 @@ Details::
*
* Command ownership. If the driver returns zero, it owns the
* command and must take responsibility for ensuring the
* scp->scsi_done callback is executed. Note: the driver may
* call scp->scsi_done before returning zero, but after it has
* called scp->scsi_done, it may not return any value other than
* scsi_done() function is called. Note: the driver may
* call scsi_done() before returning zero, but after it has
* called scsi_done(), it may not return any value other than
* zero. If the driver makes a non-zero return, it must not
* execute the command's scsi_done callback at any time.
* call scsi_done(scp) at any time.
*
* Locks: up to and including 2.6.36, struct Scsi_Host::host_lock
* held on entry (with "irqsave") and is expected to be
@ -887,16 +887,16 @@ Details::
* Calling context: in interrupt (soft irq) or process context
*
* Notes: This function should be relatively fast. Normally it
* will not wait for IO to complete. Hence the scp->scsi_done
* callback is invoked (often directly from an interrupt service
* will not wait for IO to complete. Hence the scsi_done()
* function is invoked (often directly from an interrupt service
* routine) some time after this function has returned. In some
* cases (e.g. pseudo adapter drivers that manufacture the
* response to a SCSI INQUIRY) the scp->scsi_done callback may be
* invoked before this function returns. If the scp->scsi_done
* callback is not invoked within a certain period the SCSI mid
* response to a SCSI INQUIRY) the scsi_done() function may be
* invoked before this function returns. If the scsi_done()
* function is not invoked within a certain period the SCSI mid
* level will commence error processing. If a status of CHECK
* CONDITION is placed in "result" when the scp->scsi_done
* callback is invoked, then the LLD driver should perform
* CONDITION is placed in "result" when the scsi_done()
* function is invoked, then the LLD driver should perform
* autosense and fill in the struct scsi_cmnd::sense_buffer
* array. The scsi_cmnd::sense_buffer array is zeroed prior to
* the mid level queuing a command to an LLD.
@ -1148,12 +1148,8 @@ The scsi_cmnd structure is defined in include/scsi/scsi_cmnd.h
Locks
=====
Each struct Scsi_Host instance has a spin_lock called struct
Scsi_Host::default_lock which is initialized in scsi_host_alloc() [found in
hosts.c]. Within the same function the struct Scsi_Host::host_lock pointer
is initialized to point at default_lock. Thereafter lock and unlock
operations performed by the mid level use the struct Scsi_Host::host_lock
pointer. Previously drivers could override the host_lock pointer but
this is not allowed anymore.
Scsi_Host::host_lock which is initialized in scsi_host_alloc() [found in
hosts.c].
Autosense

1
MAINTAINERS
View File

@ -28368,7 +28368,6 @@ F: lib/union_find.c
UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER
R: Alim Akhtar <alim.akhtar@samsung.com>
R: Avri Altman <avri.altman@wdc.com>
R: Bart Van Assche <bvanassche@acm.org>
L: linux-scsi@vger.kernel.org
S: Supported

17
drivers/ata/libata-eh.c
View File

@ -573,9 +573,9 @@ void ata_scsi_error(struct Scsi_Host *host)
int nr_timedout;
LIST_HEAD(eh_work_q);
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
list_splice_init(&host->eh_cmd_q, &eh_work_q);
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
/*
* First check what errors we got with ata_scsi_cmd_error_handler().
@ -1516,11 +1516,13 @@ static bool ata_eh_request_sense(struct ata_queued_cmd *qc)
err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
/* Ignore err_mask; ATA_ERR might be set */
if (tf.status & ATA_SENSE) {
if (ata_scsi_sense_is_valid(tf.lbah, tf.lbam, tf.lbal)) {
u16 sense_code = scsi_sense_code(tf.lbam, tf.lbal);
if (ata_scsi_sense_is_valid(tf.lbah, sense_code)) {
/* Set sense without also setting scsicmd->result */
scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
cmd->sense_buffer, tf.lbah,
tf.lbam, tf.lbal);
scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
cmd->sense_buffer, tf.lbah,
sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
return true;
}
@ -2094,7 +2096,8 @@ static void ata_eh_get_success_sense(struct ata_link *link)
continue;
/* This success command had sense data, but we failed to get. */
ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
ata_eh_done(link, dev, ATA_EH_GET_SUCCESS_SENSE);

20
drivers/ata/libata-sata.c
View File

@ -1588,7 +1588,7 @@ int ata_eh_get_ncq_success_sense(struct ata_link *link)
asc = sense[1];
ascq = sense[2];
if (!ata_scsi_sense_is_valid(sk, asc, ascq)) {
if (!ata_scsi_sense_is_valid(sk, scsi_sense_code(asc, ascq))) {
ret = -EIO;
continue;
}
@ -1605,9 +1605,9 @@ int ata_eh_get_ncq_success_sense(struct ata_link *link)
qc->result_tf.auxiliary = get_unaligned_le32(&sense[16]);
/* Set sense without also setting scsicmd->result */
scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
qc->scsicmd->sense_buffer, sk,
asc, ascq);
scsi_set_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE,
qc->scsicmd->sense_buffer, sk,
scsi_sense_code(asc, ascq));
qc->flags |= ATA_QCFLAG_SENSE_VALID;
/*
@ -1684,14 +1684,14 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
* stored the sense data in qc->result_tf.auxiliary.
*/
if (qc->result_tf.auxiliary) {
char sense_key, asc, ascq;
u16 sense_code;
u8 sense_key;
sense_key = (qc->result_tf.auxiliary >> 16) & 0xff;
asc = (qc->result_tf.auxiliary >> 8) & 0xff;
ascq = qc->result_tf.auxiliary & 0xff;
if (ata_scsi_sense_is_valid(sense_key, asc, ascq)) {
ata_scsi_set_sense(dev, qc->scsicmd, sense_key, asc,
ascq);
sense_code = qc->result_tf.auxiliary & 0xffff;
if (ata_scsi_sense_is_valid(sense_key, sense_code)) {
ata_scsi_set_sense(dev, qc->scsicmd, sense_key,
sense_code);
qc->flags |= ATA_QCFLAG_SENSE_VALID;
}
}

344
drivers/ata/libata-scsi.c
View File

@ -190,28 +190,25 @@ DEVICE_ATTR(unload_heads, S_IRUGO | S_IWUSR,
ata_scsi_park_show, ata_scsi_park_store);
EXPORT_SYMBOL_GPL(dev_attr_unload_heads);
bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq)
bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code)
{
/*
* If sk == NO_SENSE, and asc + ascq == NO ADDITIONAL SENSE INFORMATION,
* then there is no sense data to add.
*/
if (sk == 0 && asc == 0 && ascq == 0)
if (sense_key == NO_SENSE &&
sense_code == NO_ADDITIONAL_SENSE_INFORMATION)
return false;
/* If sk > COMPLETED, sense data is bogus. */
if (sk > COMPLETED)
if (sense_key > COMPLETED)
return false;
return true;
}
void ata_scsi_set_sense(struct ata_device *dev, struct scsi_cmnd *cmd,
u8 sk, u8 asc, u8 ascq)
u8 sk, u16 code)
{
bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE);
scsi_build_sense(cmd, d_sense, sk, asc, ascq);
scsi_set_sense(cmd, d_sense, sk, code);
}
static void ata_scsi_set_sense_information(struct ata_queued_cmd *qc)
@ -322,8 +319,7 @@ static void ata_scsi_set_passthru_sense_fields(struct ata_queued_cmd *qc)
static void ata_scsi_set_invalid_field(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field, u8 bit)
{
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x24, 0x0);
/* "Invalid field in CDB" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, bit, 1);
}
@ -331,8 +327,8 @@ static void ata_scsi_set_invalid_field(struct ata_device *dev,
static void ata_scsi_set_invalid_parameter(struct ata_device *dev,
struct scsi_cmnd *cmd, u16 field)
{
/* "Invalid field in parameter list" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x26, 0x0);
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
INVALID_FIELD_IN_PARAMETER_LIST);
scsi_set_sense_field_pointer(cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE,
field, 0xff, 0);
}
@ -531,7 +527,8 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (scsi_status_is_check_condition(cmd_result)) {
if (sshdr.sense_key == RECOVERED_ERROR &&
sshdr.asc == 0 && sshdr.ascq == 0x1d)
sshdr.sense_code ==
ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@ -619,7 +616,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
* check condition even if no error. Filter that. */
if (cmd_result & SAM_STAT_CHECK_CONDITION) {
if (sshdr.sense_key == RECOVERED_ERROR &&
sshdr.asc == 0 && sshdr.ascq == 0x1d)
sshdr.sense_code ==
ATA_PASS_THROUGH_INFORMATION_AVAILABLE)
cmd_result &= ~SAM_STAT_CHECK_CONDITION;
}
@ -798,79 +796,143 @@ static void ata_qc_set_pc_nbytes(struct ata_queued_cmd *qc)
qc->nbytes = scsi_bufflen(scmd) + qc->extrabytes;
}
struct ata_err_sense {
u8 err_mask;
u8 sense_key;
u16 sense_code;
};
/**
* ata_to_sense_error - convert ATA error to SCSI error
* @drv_stat: value contained in ATA status register
* @drv_err: value contained in ATA error register
* @sk: the sense key we'll fill out
* @asc: the additional sense code we'll fill out
* @ascq: the additional sense code qualifier we'll fill out
* @scode: the additional sense code and its qualifier we'll fill out
*
* Converts an ATA error into a SCSI error. Fill out pointers to
* SK, ASC, and ASCQ bytes for later use in fixed or descriptor
* the sense key and sense code for later use in fixed or descriptor
* format sense blocks.
*
* LOCKING:
* spin_lock_irqsave(host lock)
*/
static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
u8 *ascq)
static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u16 *scode)
{
int i;
/* Based on the 3ware driver translation table */
static const unsigned char sense_table[][4] = {
/* BBD|ECC|ID|MAR */
{0xd1, ABORTED_COMMAND, 0x00, 0x00},
// Device busy Aborted command
/* BBD|ECC|ID */
{0xd0, ABORTED_COMMAND, 0x00, 0x00},
// Device busy Aborted command
/* ECC|MC|MARK */
{0x61, HARDWARE_ERROR, 0x00, 0x00},
// Device fault Hardware error
/* ICRC|ABRT */ /* NB: ICRC & !ABRT is BBD */
{0x84, ABORTED_COMMAND, 0x47, 0x00},
// Data CRC error SCSI parity error
/* MC|ID|ABRT|TRK0|MARK */
{0x37, NOT_READY, 0x04, 0x00},
// Unit offline Not ready
/* MCR|MARK */
{0x09, NOT_READY, 0x04, 0x00},
// Unrecovered disk error Not ready
/* Bad address mark */
{0x01, MEDIUM_ERROR, 0x13, 0x00},
// Address mark not found for data field
/* TRK0 - Track 0 not found */
{0x02, HARDWARE_ERROR, 0x00, 0x00},
// Hardware error
/* Abort: 0x04 is not translated here, see below */
/* Media change request */
{0x08, NOT_READY, 0x04, 0x00},
// FIXME: faking offline
/* SRV/IDNF - ID not found */
{0x10, ILLEGAL_REQUEST, 0x21, 0x00},
// Logical address out of range
/* MC - Media Changed */
{0x20, UNIT_ATTENTION, 0x28, 0x00},
// Not ready to ready change, medium may have changed
/* ECC - Uncorrectable ECC error */
{0x40, MEDIUM_ERROR, 0x11, 0x04},
// Unrecovered read error
/* BBD - block marked bad */
{0x80, MEDIUM_ERROR, 0x11, 0x04},
// Block marked bad Medium error, unrecovered read error
{0xFF, 0xFF, 0xFF, 0xFF}, // END mark
static const struct ata_err_sense sense_table[] = {
{
/* BBD|ECC|ID|MAR - Device busy */
0xd1,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* BBD|ECC|ID - Device busy */
0xd0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* ECC|MC|MARK - Device fault */
0x61,
HARDWARE_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* ICRC|ABRT - Data CRC error */
/* NB: ICRC & !ABRT is BBD */
0x84,
ABORTED_COMMAND,
SCSI_PARITY_ERROR
},
{
/* MC|ID|ABRT|TRK0|MARK - Unit offline */
0x37,
NOT_READY,
LU_NOT_READY
},
{
/* MCR|MARK - Unrecovered disk error */
0x09,
NOT_READY,
LU_NOT_READY
},
{
/* Bad address mark */
0x01,
MEDIUM_ERROR,
ADDRESS_MARK_NOT_FOUND_FOR_DATA_FIELD
},
{
/* TRK0 - Track 0 not found */
0x02,
HARDWARE_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* Abort: 0x04 is not translated here, see below */
/* Media change request */
0x08,
NOT_READY,
LU_NOT_READY
},
{
/* SRV/IDNF - ID not found */
0x10,
ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE
},
{
/* MC - Media Changed */
0x20,
UNIT_ATTENTION,
NOT_READY_TO_READY_CHANGE_MEDIUM_MAY_HAVE_CHANGED
},
{
/* ECC - Uncorrectable ECC error */
0x40,
MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
},
{
/* BBD - block marked bad */
0x80,
MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED
},
{
/* END mark */
0xFF, 0xFF, 0xFFFF
},
};
static const unsigned char stat_table[][4] = {
/* Busy: must be first because BUSY means no other bits valid */
{ ATA_BUSY, ABORTED_COMMAND, 0x00, 0x00 },
/* Device fault: INTERNAL TARGET FAILURE */
{ ATA_DF, HARDWARE_ERROR, 0x44, 0x00 },
/* Corrected data error */
{ ATA_CORR, RECOVERED_ERROR, 0x00, 0x00 },
{ 0xFF, 0xFF, 0xFF, 0xFF }, /* END mark */
static const struct ata_err_sense stat_table[] = {
{
/*
* Busy: must be first because BUSY means no other bits
* valid.
*/
ATA_BUSY,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* Device fault */
ATA_DF,
HARDWARE_ERROR,
INTERNAL_TARGET_FAILURE
},
{
/* Corrected data error */
ATA_CORR,
RECOVERED_ERROR,
NO_ADDITIONAL_SENSE_INFORMATION
},
{
/* END mark */
0xFF, 0xFF, 0xFFFF
},
};
/*
@ -882,13 +944,12 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
if (drv_err) {
/* Look for drv_err */
for (i = 0; sense_table[i][0] != 0xFF; i++) {
for (i = 0; sense_table[i].err_mask != 0xFF; i++) {
/* Look for best matches first */
if ((sense_table[i][0] & drv_err) ==
sense_table[i][0]) {
*sk = sense_table[i][1];
*asc = sense_table[i][2];
*ascq = sense_table[i][3];
if ((sense_table[i].err_mask & drv_err) ==
sense_table[i].err_mask) {
*sk = sense_table[i].sense_key;
*scode = sense_table[i].sense_code;
return;
}
}
@ -899,11 +960,10 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* has only the ABRT bit set, we decode drv_stat. ABRT by itself
* is not descriptive enough.
*/
for (i = 0; stat_table[i][0] != 0xFF; i++) {
if (stat_table[i][0] & drv_stat) {
*sk = stat_table[i][1];
*asc = stat_table[i][2];
*ascq = stat_table[i][3];
for (i = 0; stat_table[i].err_mask != 0xFF; i++) {
if (stat_table[i].err_mask & drv_stat) {
*sk = stat_table[i].sense_key;
*scode = stat_table[i].sense_code;
return;
}
}
@ -913,8 +973,7 @@ static void ata_to_sense_error(u8 drv_stat, u8 drv_err, u8 *sk, u8 *asc,
* that won't cause people to do things like return a disk wrongly.
*/
*sk = ABORTED_COMMAND;
*asc = 0x00;
*ascq = 0x00;
*scode = NO_ADDITIONAL_SENSE_INFORMATION;
}
/*
@ -937,40 +996,41 @@ static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
u8 sense_key, asc, ascq;
u16 sense_code;
u8 sense_key;
if (!(qc->flags & ATA_QCFLAG_RTF_FILLED)) {
ata_dev_dbg(dev,
"missing result TF: can't generate ATA PT sense data\n");
if (qc->err_mask)
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
return;
}
/*
* Use ata_to_sense_error() to map status register bits
* onto sense key, asc & ascq.
* Use ata_to_sense_error() to map status register bits onto sense key
* and sense code.
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
ata_to_sense_error(tf->status, tf->error,
&sense_key, &asc, &ascq);
ata_scsi_set_sense(qc->dev, cmd, sense_key, asc, ascq);
} else {
/*
* ATA PASS-THROUGH INFORMATION AVAILABLE
*
* Note: we are supposed to call ata_scsi_set_sense(), which
* respects the D_SENSE bit, instead of unconditionally
* generating the sense data in descriptor format. However,
* because hdparm, hddtemp, and udisks incorrectly assume sense
* data in descriptor format, without even looking at the
* RESPONSE CODE field in the returned sense data (to see which
* format the returned sense data is in), we are stuck with
* being bug compatible with older kernels.
*/
scsi_build_sense(cmd, 1, RECOVERED_ERROR, 0, 0x1D);
&sense_key, &sense_code);
ata_scsi_set_sense(qc->dev, cmd, sense_key, sense_code);
return;
}
/*
* Note: we are supposed to call ata_scsi_set_sense(), which respects
* the D_SENSE bit, instead of unconditionally generating the sense data
* in descriptor format. However, because hdparm, hddtemp, and udisks
* incorrectly assume sense data in descriptor format, without even
* looking at the RESPONSE CODE field in the returned sense data (to see
* which format the returned sense data is in), we are stuck with being
* bug compatible with older kernels.
*/
scsi_set_sense(cmd, 1, RECOVERED_ERROR,
ATA_PASS_THROUGH_INFORMATION_AVAILABLE);
}
/**
@ -987,19 +1047,18 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
struct ata_device *dev = qc->dev;
struct scsi_cmnd *cmd = qc->scsicmd;
struct ata_taskfile *tf = &qc->result_tf;
u8 sense_key, asc, ascq;
if (ata_dev_disabled(dev)) {
/* Device disabled after error recovery */
/* LOGICAL UNIT NOT READY, HARD RESET REQUIRED */
ata_scsi_set_sense(dev, cmd, NOT_READY, 0x04, 0x21);
ata_scsi_set_sense(dev, cmd, NOT_READY,
LU_NOT_READY_HARD_RESET_REQUIRED);
return;
}
if (ata_id_is_locked(dev->id)) {
/* Security locked */
/* LOGICAL UNIT ACCESS NOT AUTHORIZED */
ata_scsi_set_sense(dev, cmd, DATA_PROTECT, 0x74, 0x71);
ata_scsi_set_sense(dev, cmd, DATA_PROTECT,
LU_ACCESS_NOT_AUTHORIZED);
return;
}
@ -1014,9 +1073,12 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
*/
if (qc->err_mask ||
tf->status & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
u16 sense_code;
u8 sense_key;
ata_to_sense_error(tf->status, tf->error,
&sense_key, &asc, &ascq);
ata_scsi_set_sense(dev, cmd, sense_key, asc, ascq);
&sense_key, &sense_code);
ata_scsi_set_sense(dev, cmd, sense_key, sense_code);
return;
}
@ -1025,7 +1087,8 @@ static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
"Could not decode error 0x%x, status 0x%x (err_mask=0x%x)\n",
tf->error, tf->status, qc->err_mask);
aborted:
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
void ata_scsi_sdev_config(struct scsi_device *sdev)
@ -1279,7 +1342,8 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
/* Ignore IMMED bit (cdb[1] & 0x1), violates sat-r05 */
if (!ata_dev_power_init_tf(qc->dev, &qc->tf, cdb[4] & 0x1)) {
ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(qc->dev, scmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
return 1;
}
@ -1507,8 +1571,8 @@ static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
/* "Logical Block Address out of range" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@ -1644,8 +1708,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
return 1;
out_of_range:
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x21, 0x0);
/* "Logical Block Address out of range" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
return 1;
nothing_to_do:
@ -2021,7 +2085,8 @@ static void ata_scsi_rbuf_fill(struct ata_device *dev, struct scsi_cmnd *cmd,
len = actor(dev, cmd, ata_scsi_rbuf);
if (len) {
if (WARN_ON(len > ATA_SCSI_RBUF_SIZE)) {
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND, 0, 0);
ata_scsi_set_sense(dev, cmd, ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
spin_unlock_irqrestore(&ata_scsi_rbuf_lock, flags);
return;
}
@ -2899,8 +2964,8 @@ static unsigned int ata_scsiop_mode_sense(struct ata_device *dev,
return 0;
saving_not_supp:
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x39, 0x0);
/* "Saving parameters not supported" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
SAVING_PARAMETERS_NOT_SUPPORTED);
return 0;
}
@ -3742,12 +3807,12 @@ static unsigned int ata_scsi_write_same_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(dev, scmd, fp, bp);
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
invalid_opcode:
/* "Invalid command operation code" */
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4209,8 +4274,8 @@ static unsigned int ata_scsi_zbc_in_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@ -4287,8 +4352,8 @@ static unsigned int ata_scsi_zbc_out_xlat(struct ata_queued_cmd *qc)
ata_scsi_set_invalid_field(qc->dev, scmd, fp, 0xff);
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
}
@ -4639,8 +4704,8 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc)
return 1;
invalid_param_len:
/* "Parameter list length error" */
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST, 0x1a, 0x0);
ata_scsi_set_sense(qc->dev, scmd, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
return 1;
skip:
@ -4799,7 +4864,8 @@ ata_scsi_get_phys_element_status_xlat(struct ata_queued_cmd *qc)
/* ATA_CMD_GET_PHYS_ELEMENT_STATUS is a DMA command. */
if (!(dev->flags & ATA_DFLAG_DEPOP) || !ata_dma_enabled(dev)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4844,7 +4910,8 @@ ata_scsi_remove_element_and_truncate_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4886,7 +4953,8 @@ ata_scsi_remove_element_and_modify_zones_xlat(struct ata_queued_cmd *qc)
u32 id;
if (!(dev->flags & ATA_DFLAG_DEPOP_MODIFY)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -4914,7 +4982,8 @@ ata_scsi_restore_elements_and_rebuild_xlat(struct ata_queued_cmd *qc)
struct ata_taskfile *tf = &qc->tf;
if (!(dev->flags & ATA_DFLAG_DEPOP_RESTORE)) {
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST, 0x20, 0x0);
ata_scsi_set_sense(dev, scmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
return 1;
}
@ -5074,7 +5143,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
break;
case REQUEST_SENSE:
ata_scsi_set_sense(dev, cmd, 0, 0, 0);
ata_scsi_set_sense(dev, cmd, NO_SENSE,
NO_ADDITIONAL_SENSE_INFORMATION);
break;
/* if we reach this, then writeback caching is disabled,
@ -5103,8 +5173,8 @@ static void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd)
/* all other commands */
default:
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST, 0x20, 0x0);
/* "Invalid command operation code" */
ata_scsi_set_sense(dev, cmd, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
break;
}

5
drivers/ata/libata.h
View File

@ -164,9 +164,10 @@ extern int ata_scsi_add_hosts(struct ata_host *host,
const struct scsi_host_template *sht);
extern void ata_scsi_scan_host(struct ata_port *ap, int sync);
extern bool ata_scsi_offline_dev(struct ata_device *dev);
extern bool ata_scsi_sense_is_valid(u8 sk, u8 asc, u8 ascq);
extern bool ata_scsi_sense_is_valid(u8 sense_key, u16 sense_code);
extern void ata_scsi_set_sense(struct ata_device *dev,
struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq);
struct scsi_cmnd *cmd, u8 sense_key,
u16 sense_code);
extern void ata_scsi_media_change_notify(struct ata_device *dev);
extern void ata_scsi_hotplug(struct work_struct *work);
extern void ata_scsi_dev_rescan(struct work_struct *work);

10
drivers/cdrom/cdrom.c
View File

@ -345,9 +345,8 @@ int cdrom_dummy_generic_packet(struct cdrom_device_info *cdi,
struct packet_command *cgc)
{
if (cgc->sshdr) {
cgc->sshdr->sense_key = 0x05;
cgc->sshdr->asc = 0x20;
cgc->sshdr->ascq = 0x00;
cgc->sshdr->sense_key = ILLEGAL_REQUEST;
cgc->sshdr->sense_code = INVALID_COMMAND_OP_CODE;
}
cgc->stat = -EIO;
@ -2979,9 +2978,8 @@ static noinline int mmc_ioctl_cdrom_read_data(struct cdrom_device_info *cdi,
cgc->sshdr = &sshdr;
cgc->data_direction = CGC_DATA_READ;
ret = cdrom_read_block(cdi, cgc, lba, 1, format, blocksize);
if (ret && sshdr.sense_key == 0x05 &&
sshdr.asc == 0x20 &&
sshdr.ascq == 0x00) {
if (ret && sshdr.sense_key == ILLEGAL_REQUEST &&
sshdr.sense_code == INVALID_COMMAND_OP_CODE) {
/*
* SCSI-II devices are not required to support
* READ_CD, so let's try switching block size

8
drivers/message/fusion/mptfc.c
View File

@ -196,20 +196,20 @@ mptfc_block_error_handler(struct fc_rport *rport)
hd = shost_priv(shost);
ioc = hd->ioc;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY
|| (loops > 0 && ioc->active == 0)) {
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
"mptfc_block_error_handler.%d: %s, port status is "
"%x, active flag %d, deferring recovery.\n",
ioc->name, ioc->sh->host_no,
dev_name(&rport->dev), ready, ioc->active));
msleep(1000);
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
loops --;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
if (ready == DID_NO_CONNECT || ioc->active == 0) {
dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT

30
drivers/s390/scsi/zfcp_erp.c
View File

@ -95,11 +95,11 @@ static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
zfcp_erp_action_dismiss(&port->erp_action);
else {
spin_lock(port->adapter->scsi_host->host_lock);
spin_lock(&port->adapter->scsi_host->host_lock);
__shost_for_each_device(sdev, port->adapter->scsi_host)
if (sdev_to_zfcp(sdev)->port == port)
zfcp_erp_action_dismiss_lun(sdev);
spin_unlock(port->adapter->scsi_host->host_lock);
spin_unlock(&port->adapter->scsi_host->host_lock);
}
}
@ -670,11 +670,11 @@ static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
{
struct scsi_device *sdev;
spin_lock(port->adapter->scsi_host->host_lock);
spin_lock(&port->adapter->scsi_host->host_lock);
__shost_for_each_device(sdev, port->adapter->scsi_host)
if (sdev_to_zfcp(sdev)->port == port)
_zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
spin_unlock(port->adapter->scsi_host->host_lock);
spin_unlock(&port->adapter->scsi_host->host_lock);
}
static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
@ -1429,7 +1429,7 @@ static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
write_unlock_irqrestore(&adapter->erp_lock, flags);
return;
}
spin_lock(shost->host_lock);
spin_lock(&shost->host_lock);
__shost_for_each_device(sdev, shost) {
struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
int lun_status;
@ -1451,7 +1451,7 @@ static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
* or meanwhile blocked [new LUN recovery triggered]
*/
zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
spin_unlock(shost->host_lock);
spin_unlock(&shost->host_lock);
write_unlock_irqrestore(&adapter->erp_lock, flags);
return;
}
@ -1460,7 +1460,7 @@ static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
* and no ERP of severity >= port was meanwhile triggered elsewhere
*/
zfcp_scsi_schedule_rport_register(port);
spin_unlock(shost->host_lock);
spin_unlock(&shost->host_lock);
write_unlock_irqrestore(&adapter->erp_lock, flags);
}
@ -1713,10 +1713,10 @@ void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
if (adapter->scsi_host == NULL)
return;
spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
spin_lock_irqsave(&adapter->scsi_host->host_lock, flags);
__shost_for_each_device(sdev, adapter->scsi_host)
atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
spin_unlock_irqrestore(&adapter->scsi_host->host_lock, flags);
}
/**
@ -1757,13 +1757,13 @@ void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
if (adapter->scsi_host == NULL)
return;
spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
spin_lock_irqsave(&adapter->scsi_host->host_lock, flags);
__shost_for_each_device(sdev, adapter->scsi_host) {
atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
if (clear_counter)
atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
}
spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
spin_unlock_irqrestore(&adapter->scsi_host->host_lock, flags);
}
/**
@ -1784,12 +1784,12 @@ void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
if (!common_mask)
return;
spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
spin_lock_irqsave(&port->adapter->scsi_host->host_lock, flags);
__shost_for_each_device(sdev, port->adapter->scsi_host)
if (sdev_to_zfcp(sdev)->port == port)
atomic_or(common_mask,
&sdev_to_zfcp(sdev)->status);
spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
spin_unlock_irqrestore(&port->adapter->scsi_host->host_lock, flags);
}
/**
@ -1814,7 +1814,7 @@ void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
if (clear_counter)
atomic_set(&port->erp_counter, 0);
spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
spin_lock_irqsave(&port->adapter->scsi_host->host_lock, flags);
__shost_for_each_device(sdev, port->adapter->scsi_host)
if (sdev_to_zfcp(sdev)->port == port) {
atomic_andnot(common_mask,
@ -1822,7 +1822,7 @@ void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
if (clear_counter)
atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
}
spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
spin_unlock_irqrestore(&port->adapter->scsi_host->host_lock, flags);
}
/**

2
drivers/s390/scsi/zfcp_ext.h
View File

@ -176,7 +176,7 @@ extern void zfcp_scsi_schedule_rport_register(struct zfcp_port *);
extern void zfcp_scsi_schedule_rport_block(struct zfcp_port *);
extern void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *);
extern void zfcp_scsi_set_prot(struct zfcp_adapter *);
extern void zfcp_scsi_dif_sense_error(struct scsi_cmnd *, int);
extern void zfcp_scsi_dif_sense_error(struct scsi_cmnd *, u16);
extern void zfcp_scsi_shost_update_config_data(
struct zfcp_adapter *const adapter,
const struct fsf_qtcb_bottom_config *const bottom,

9
drivers/s390/scsi/zfcp_fsf.c
View File

@ -2485,13 +2485,16 @@ static void zfcp_fsf_fcp_cmnd_handler(struct zfcp_fsf_req *req)
set_host_byte(scpnt, DID_ERROR);
goto skip_fsfstatus;
case FSF_BLOCK_GUARD_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x1);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
goto skip_fsfstatus;
case FSF_APP_TAG_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x2);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
goto skip_fsfstatus;
case FSF_REF_TAG_CHECK_FAILURE:
zfcp_scsi_dif_sense_error(scpnt, 0x3);
zfcp_scsi_dif_sense_error(scpnt,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
goto skip_fsfstatus;
}
BUILD_BUG_ON(sizeof(struct fcp_resp_with_ext) > FSF_FCP_RSP_SIZE);

6
drivers/s390/scsi/zfcp_scsi.c
View File

@ -849,14 +849,14 @@ void zfcp_scsi_set_prot(struct zfcp_adapter *adapter)
/**
* zfcp_scsi_dif_sense_error - Report DIF/DIX error as driver sense error
* @scmd: The SCSI command to report the error for
* @ascq: The ASCQ to put in the sense buffer
* @sense_code: The combined ASC and ASCQ to put in the sense buffer
*
* See the error handling in sd_done for the sense codes used here.
* Set DID_SOFT_ERROR to retry the request, if possible.
*/
void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, int ascq)
void zfcp_scsi_dif_sense_error(struct scsi_cmnd *scmd, u16 sense_code)
{
scsi_build_sense(scmd, 1, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(scmd, 1, ILLEGAL_REQUEST, sense_code);
set_host_byte(scmd, DID_SOFT_ERROR);
}

4
drivers/s390/scsi/zfcp_sysfs.c
View File

@ -270,7 +270,7 @@ static bool zfcp_sysfs_port_in_use(struct zfcp_port *const port)
if (atomic_read(&port->units) > 0)
goto unlock_port_units_mutex; /* zfcp_unit(s) under port */
spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
spin_lock_irqsave(&adapter->scsi_host->host_lock, flags);
__shost_for_each_device(sdev, adapter->scsi_host) {
const struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
@ -288,7 +288,7 @@ static bool zfcp_sysfs_port_in_use(struct zfcp_port *const port)
in_use = false;
unlock_host_lock:
spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
spin_unlock_irqrestore(&adapter->scsi_host->host_lock, flags);
unlock_port_units_mutex:
mutex_unlock(&zfcp_sysfs_port_units_mutex);
return in_use;

20
drivers/scsi/3w-9xxx.c
View File

@ -160,7 +160,7 @@ static ssize_t twa_show_stats(struct device *dev,
unsigned long flags = 0;
ssize_t len;
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
len = sysfs_emit(buf, "3w-9xxx Driver version: %s\n"
"Current commands posted: %4d\n"
"Max commands posted: %4d\n"
@ -183,7 +183,7 @@ static ssize_t twa_show_stats(struct device *dev,
tw_dev->max_sector_count,
tw_dev->num_resets,
tw_dev->aen_count);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
return len;
} /* End twa_show_stats() */
@ -694,7 +694,7 @@ static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
/* See which ioctl we are doing */
switch (cmd) {
case TW_IOCTL_FIRMWARE_PASS_THROUGH:
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
twa_get_request_id(tw_dev, &request_id);
/* Flag internal command */
@ -712,7 +712,7 @@ static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
/* Now post the command packet to the controller */
twa_post_command_packet(tw_dev, request_id, 1);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
@ -734,11 +734,11 @@ static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
/* Now complete the io */
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
tw_dev->posted_request_count--;
tw_dev->state[request_id] = TW_S_COMPLETED;
twa_free_request_id(tw_dev, request_id);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
break;
case TW_IOCTL_GET_COMPATIBILITY_INFO:
tw_ioctl->driver_command.status = 0;
@ -1223,7 +1223,7 @@ static irqreturn_t twa_interrupt(int irq, void *dev_instance)
int handled = 0;
/* Get the per adapter lock */
spin_lock(tw_dev->host->host_lock);
spin_lock(&tw_dev->host->host_lock);
/* Read the registers */
status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
@ -1372,7 +1372,7 @@ static irqreturn_t twa_interrupt(int irq, void *dev_instance)
}
twa_interrupt_bail:
spin_unlock(tw_dev->host->host_lock);
spin_unlock(&tw_dev->host->host_lock);
return IRQ_RETVAL(handled);
} /* End twa_interrupt() */
@ -1585,7 +1585,7 @@ static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
set_bit(TW_IN_RESET, &tw_dev->flags);
TW_DISABLE_INTERRUPTS(tw_dev);
TW_MASK_COMMAND_INTERRUPT(tw_dev);
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
/* Abort all requests that are in progress */
for (i = 0; i < TW_Q_LENGTH; i++) {
@ -1616,7 +1616,7 @@ static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
tw_dev->pending_tail = TW_Q_START;
tw_dev->reset_print = 0;
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
if (twa_reset_sequence(tw_dev, 1))
goto out;

28
drivers/scsi/3w-sas.c
View File

@ -108,9 +108,9 @@ static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj,
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
return ret;
} /* End twl_sysfs_aen_read() */
@ -139,9 +139,9 @@ static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj,
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
return ret;
} /* End twl_sysfs_compat_info() */
@ -165,7 +165,7 @@ static ssize_t twl_show_stats(struct device *dev,
unsigned long flags = 0;
ssize_t len;
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
len = sysfs_emit(buf, "3w-sas Driver version: %s\n"
"Current commands posted: %4d\n"
"Max commands posted: %4d\n"
@ -184,7 +184,7 @@ static ssize_t twl_show_stats(struct device *dev,
tw_dev->max_sector_count,
tw_dev->num_resets,
tw_dev->aen_count);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
return len;
} /* End twl_show_stats() */
@ -763,7 +763,7 @@ static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
/* See which ioctl we are doing */
switch (cmd) {
case TW_IOCTL_FIRMWARE_PASS_THROUGH:
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
twl_get_request_id(tw_dev, &request_id);
/* Flag internal command */
@ -781,7 +781,7 @@ static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
/* Now post the command packet to the controller */
twl_post_command_packet(tw_dev, request_id);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
@ -803,11 +803,11 @@ static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long
memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
/* Now complete the io */
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
tw_dev->posted_request_count--;
tw_dev->state[request_id] = TW_S_COMPLETED;
twl_free_request_id(tw_dev, request_id);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
break;
default:
retval = -ENOTTY;
@ -1125,7 +1125,7 @@ static irqreturn_t twl_interrupt(int irq, void *dev_instance)
struct scsi_cmnd *cmd;
TW_Command_Full *full_command_packet;
spin_lock(tw_dev->host->host_lock);
spin_lock(&tw_dev->host->host_lock);
/* Read host interrupt status */
reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
@ -1229,7 +1229,7 @@ static irqreturn_t twl_interrupt(int irq, void *dev_instance)
}
twl_interrupt_bail:
spin_unlock(tw_dev->host->host_lock);
spin_unlock(&tw_dev->host->host_lock);
return IRQ_RETVAL(handled);
} /* End twl_interrupt() */
@ -1360,7 +1360,7 @@ static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_res
TWL_MASK_INTERRUPTS(tw_dev);
TWL_CLEAR_DB_INTERRUPT(tw_dev);
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
/* Abort all requests that are in progress */
for (i = 0; i < TW_Q_LENGTH; i++) {
@ -1386,7 +1386,7 @@ static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_res
tw_dev->free_tail = TW_Q_START;
tw_dev->posted_request_count = 0;
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
if (twl_reset_sequence(tw_dev, 1))
goto out;

27
drivers/scsi/3w-xxxx.c
View File

@ -495,7 +495,7 @@ static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
unsigned long flags = 0;
ssize_t len;
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
len = sysfs_emit(buf, "3w-xxxx Driver version: %s\n"
"Current commands posted: %4d\n"
"Max commands posted: %4d\n"
@ -518,7 +518,7 @@ static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
tw_dev->max_sector_count,
tw_dev->num_resets,
tw_dev->aen_count);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
return len;
} /* End tw_show_stats() */
@ -935,7 +935,7 @@ static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long a
dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
memset(tw_ioctl->data_buffer, 0, data_buffer_length);
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
if (tw_dev->aen_head == tw_dev->aen_tail) {
tw_aen_code = TW_AEN_QUEUE_EMPTY;
} else {
@ -946,12 +946,12 @@ static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long a
tw_dev->aen_head = tw_dev->aen_head + 1;
}
}
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
break;
case TW_CMD_PACKET_WITH_DATA:
dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
tw_state_request_start(tw_dev, &request_id);
@ -983,7 +983,7 @@ static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long a
/* Now post the command packet to the controller */
tw_post_command_packet(tw_dev, request_id);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
@ -1005,11 +1005,11 @@ static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long a
memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
/* Now complete the io */
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
tw_dev->posted_request_count--;
tw_dev->state[request_id] = TW_S_COMPLETED;
tw_state_request_finish(tw_dev, request_id);
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
break;
default:
retval = -ENOTTY;
@ -1296,7 +1296,7 @@ static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
set_bit(TW_IN_RESET, &tw_dev->flags);
TW_DISABLE_INTERRUPTS(tw_dev);
TW_MASK_COMMAND_INTERRUPT(tw_dev);
spin_lock_irqsave(tw_dev->host->host_lock, flags);
spin_lock_irqsave(&tw_dev->host->host_lock, flags);
/* Abort all requests that are in progress */
for (i=0;i<TW_Q_LENGTH;i++) {
@ -1325,7 +1325,7 @@ static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
tw_dev->pending_tail = TW_Q_START;
tw_dev->reset_print = 0;
spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
spin_unlock_irqrestore(&tw_dev->host->host_lock, flags);
if (tw_reset_sequence(tw_dev)) {
printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
@ -1977,7 +1977,8 @@ static enum scsi_qc_status tw_scsi_queue_lck(struct scsi_cmnd *SCpnt)
printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
tw_dev->state[request_id] = TW_S_COMPLETED;
tw_state_request_finish(tw_dev, request_id);
scsi_build_sense(SCpnt, 1, ILLEGAL_REQUEST, 0x20, 0);
scsi_set_sense(SCpnt, 1, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
done(SCpnt);
retval = 0;
}
@ -2005,7 +2006,7 @@ static irqreturn_t tw_interrupt(int irq, void *dev_instance)
int handled = 0;
/* Get the host lock for io completions */
spin_lock(tw_dev->host->host_lock);
spin_lock(&tw_dev->host->host_lock);
/* Read the registers */
status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
@ -2185,7 +2186,7 @@ static irqreturn_t tw_interrupt(int irq, void *dev_instance)
}
tw_interrupt_bail:
spin_unlock(tw_dev->host->host_lock);
spin_unlock(&tw_dev->host->host_lock);
return IRQ_RETVAL(handled);
} /* End tw_interrupt() */

16
drivers/scsi/53c700.c
View File

@ -1499,7 +1499,7 @@ NCR_700_intr(int irq, void *dev_id)
* lock to enter the done routines. When that happens, we
* need to ensure that for this driver, the host lock and the
* queue lock point to the same thing. */
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
if((istat = NCR_700_readb(host, ISTAT_REG))
& (SCSI_INT_PENDING | DMA_INT_PENDING)) {
__u32 dsps;
@ -1747,7 +1747,7 @@ NCR_700_intr(int irq, void *dev_id)
}
}
out_unlock:
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
return IRQ_RETVAL(handled);
}
@ -1948,27 +1948,27 @@ NCR_700_host_reset(struct scsi_cmnd * SCp)
/* In theory, eh_complete should always be null because the
* eh is single threaded, but just in case we're handling a
* reset via sg or something */
spin_lock_irq(SCp->device->host->host_lock);
spin_lock_irq(&SCp->device->host->host_lock);
while (hostdata->eh_complete != NULL) {
spin_unlock_irq(SCp->device->host->host_lock);
spin_unlock_irq(&SCp->device->host->host_lock);
msleep_interruptible(100);
spin_lock_irq(SCp->device->host->host_lock);
spin_lock_irq(&SCp->device->host->host_lock);
}
hostdata->eh_complete = &complete;
NCR_700_internal_bus_reset(SCp->device->host);
NCR_700_chip_reset(SCp->device->host);
spin_unlock_irq(SCp->device->host->host_lock);
spin_unlock_irq(&SCp->device->host->host_lock);
wait_for_completion(&complete);
spin_lock_irq(SCp->device->host->host_lock);
spin_lock_irq(&SCp->device->host->host_lock);
hostdata->eh_complete = NULL;
/* Revalidate the transport parameters of the failing device */
if(hostdata->fast)
spi_schedule_dv_device(SCp->device);
spin_unlock_irq(SCp->device->host->host_lock);
spin_unlock_irq(&SCp->device->host->host_lock);
return SUCCESS;
}

20
drivers/scsi/BusLogic.c
View File

@ -2744,7 +2744,7 @@ static irqreturn_t blogic_inthandler(int irq_ch, void *devid)
/*
Acquire exclusive access to Host Adapter.
*/
spin_lock_irqsave(adapter->scsi_host->host_lock, processor_flag);
spin_lock_irqsave(&adapter->scsi_host->host_lock, processor_flag);
/*
Handle Interrupts appropriately for each Host Adapter type.
*/
@ -2812,7 +2812,7 @@ static irqreturn_t blogic_inthandler(int irq_ch, void *devid)
/*
Release exclusive access to Host Adapter.
*/
spin_unlock_irqrestore(adapter->scsi_host->host_lock, processor_flag);
spin_unlock_irqrestore(&adapter->scsi_host->host_lock, processor_flag);
return IRQ_HANDLED;
}
@ -2864,12 +2864,12 @@ static int blogic_hostreset(struct scsi_cmnd *SCpnt)
struct blogic_tgt_stats *stats = &adapter->tgt_stats[id];
int rc;
spin_lock_irq(SCpnt->device->host->host_lock);
spin_lock_irq(&SCpnt->device->host->host_lock);
blogic_inc_count(&stats->adapter_reset_req);
rc = blogic_resetadapter(adapter, false);
spin_unlock_irq(SCpnt->device->host->host_lock);
spin_unlock_irq(&SCpnt->device->host->host_lock);
return rc;
}
@ -2915,9 +2915,9 @@ static enum scsi_qc_status blogic_qcmd_lck(struct scsi_cmnd *command)
*/
ccb = blogic_alloc_ccb(adapter);
if (ccb == NULL) {
spin_unlock_irq(adapter->scsi_host->host_lock);
spin_unlock_irq(&adapter->scsi_host->host_lock);
blogic_delay(1);
spin_lock_irq(adapter->scsi_host->host_lock);
spin_lock_irq(&adapter->scsi_host->host_lock);
ccb = blogic_alloc_ccb(adapter);
if (ccb == NULL) {
command->result = DID_ERROR << 16;
@ -3062,10 +3062,10 @@ static enum scsi_qc_status blogic_qcmd_lck(struct scsi_cmnd *command)
be initiated soon.
*/
if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START, ccb)) {
spin_unlock_irq(adapter->scsi_host->host_lock);
spin_unlock_irq(&adapter->scsi_host->host_lock);
blogic_warn("Unable to write Outgoing Mailbox - Pausing for 1 second\n", adapter);
blogic_delay(1);
spin_lock_irq(adapter->scsi_host->host_lock);
spin_lock_irq(&adapter->scsi_host->host_lock);
if (!blogic_write_outbox(adapter, BLOGIC_MBOX_START,
ccb)) {
blogic_warn("Still unable to write Outgoing Mailbox - Host Adapter Dead?\n", adapter);
@ -3212,9 +3212,9 @@ static int blogic_resetadapter(struct blogic_adapter *adapter, bool hard_reset)
*/
if (hard_reset) {
spin_unlock_irq(adapter->scsi_host->host_lock);
spin_unlock_irq(&adapter->scsi_host->host_lock);
blogic_delay(adapter->bus_settle_time);
spin_lock_irq(adapter->scsi_host->host_lock);
spin_lock_irq(&adapter->scsi_host->host_lock);
}
for (tgt_id = 0; tgt_id < adapter->maxdev; tgt_id++) {

4
drivers/scsi/a100u2w.c
View File

@ -1058,9 +1058,9 @@ static irqreturn_t inia100_intr(int irqno, void *devid)
unsigned long flags;
irqreturn_t res;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
res = orc_interrupt(host);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return res;
}

4
drivers/scsi/a2091.c
View File

@ -39,9 +39,9 @@ static irqreturn_t a2091_intr(int irq, void *data)
if (!(status & (ISTR_INT_F | ISTR_INT_P)) || !(status & ISTR_INTS))
return IRQ_NONE;
spin_lock_irqsave(instance->host_lock, flags);
spin_lock_irqsave(&instance->host_lock, flags);
wd33c93_intr(instance);
spin_unlock_irqrestore(instance->host_lock, flags);
spin_unlock_irqrestore(&instance->host_lock, flags);
return IRQ_HANDLED;
}

4
drivers/scsi/a3000.c
View File

@ -41,9 +41,9 @@ static irqreturn_t a3000_intr(int irq, void *data)
if (!(status & ISTR_INT_P))
return IRQ_NONE;
if (status & ISTR_INTS) {
spin_lock_irqsave(instance->host_lock, flags);
spin_lock_irqsave(&instance->host_lock, flags);
wd33c93_intr(instance);
spin_unlock_irqrestore(instance->host_lock, flags);
spin_unlock_irqrestore(&instance->host_lock, flags);
return IRQ_HANDLED;
}
pr_warn("Non-serviced A3000 SCSI-interrupt? ISTR = %02x\n", status);

8
drivers/scsi/aacraid/commsup.c
View File

@ -1487,7 +1487,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
*/
aac_adapter_disable_int(aac);
if (aac->thread && aac->thread->pid != current->pid) {
spin_unlock_irq(host->host_lock);
spin_unlock_irq(&host->host_lock);
kthread_stop(aac->thread);
aac->thread = NULL;
jafo = 1;
@ -1612,7 +1612,7 @@ static int _aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
}
if (jafo) {
spin_lock_irq(host->host_lock);
spin_lock_irq(&host->host_lock);
}
return retval;
}
@ -1644,11 +1644,11 @@ int aac_reset_adapter(struct aac_dev *aac, int forced, u8 reset_type)
/* Quiesce build, flush cache, write through mode */
if (forced < 2)
aac_send_shutdown(aac);
spin_lock_irqsave(host->host_lock, flagv);
spin_lock_irqsave(&host->host_lock, flagv);
bled = forced ? forced :
(aac_check_reset != 0 && aac_check_reset != 1);
retval = _aac_reset_adapter(aac, bled, reset_type);
spin_unlock_irqrestore(host->host_lock, flagv);
spin_unlock_irqrestore(&host->host_lock, flagv);
unblock_retval = scsi_host_unblock(host, SDEV_RUNNING);
if (!retval)

8
drivers/scsi/advansys.c
View File

@ -7072,9 +7072,9 @@ static int advansys_reset(struct scsi_cmnd *scp)
ret = FAILED;
break;
}
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
AdvISR(adv_dvc);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
}
ASC_DBG(1, "ret %d\n", ret);
@ -7138,7 +7138,7 @@ static irqreturn_t advansys_interrupt(int irq, void *dev_id)
unsigned long flags;
ASC_DBG(2, "boardp 0x%p\n", boardp);
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (ASC_NARROW_BOARD(boardp)) {
if (AscIsIntPending(shost->io_port)) {
result = IRQ_HANDLED;
@ -7153,7 +7153,7 @@ static irqreturn_t advansys_interrupt(int irq, void *dev_id)
ASC_STATS(shost, interrupt);
}
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
ASC_DBG(1, "end\n");
return result;

20
drivers/scsi/aha1542.c
View File

@ -306,7 +306,7 @@ static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
#endif
number_serviced = 0;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
while (1) {
flag = inb(INTRFLAGS(sh->io_port));
@ -339,7 +339,7 @@ static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
} while (mbi != aha1542->aha1542_last_mbi_used);
if (mb[mbi].status == 0) {
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
/* Hmm, no mail. Must have read it the last time around */
if (!number_serviced)
shost_printk(KERN_WARNING, sh, "interrupt received, but no mail.\n");
@ -367,7 +367,7 @@ static irqreturn_t aha1542_interrupt(int irq, void *dev_id)
tmp_cmd = aha1542->int_cmds[mbo];
if (!tmp_cmd) {
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
shost_printk(KERN_WARNING, sh, "Unexpected interrupt\n");
shost_printk(KERN_WARNING, sh, "tarstat=%x, hastat=%x idlun=%x ccb#=%d\n", ccb[mbo].tarstat,
ccb[mbo].hastat, ccb[mbo].idlun, mbo);
@ -461,7 +461,7 @@ static enum scsi_qc_status aha1542_queuecommand(struct Scsi_Host *sh,
* is how the host adapter will scan for them
*/
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
mbo = aha1542->aha1542_last_mbo_used + 1;
if (mbo >= AHA1542_MAILBOXES)
mbo = 0;
@ -518,7 +518,7 @@ static enum scsi_qc_status aha1542_queuecommand(struct Scsi_Host *sh,
#endif
mb[mbo].status = 1;
aha1542_outb(cmd->device->host->io_port, CMD_START_SCSI);
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return 0;
}
@ -873,7 +873,7 @@ static int aha1542_dev_reset(struct scsi_cmnd *cmd)
int mbo;
struct ccb *ccb = aha1542->ccb;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
mbo = aha1542->aha1542_last_mbo_used + 1;
if (mbo >= AHA1542_MAILBOXES)
mbo = 0;
@ -913,7 +913,7 @@ static int aha1542_dev_reset(struct scsi_cmnd *cmd)
* target
*/
aha1542_outb(sh->io_port, CMD_START_SCSI);
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
scmd_printk(KERN_WARNING, cmd,
"Trying device reset for target\n");
@ -928,7 +928,7 @@ static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
unsigned long flags;
int i;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
/*
* This does a scsi reset for all devices on the bus.
* In principle, we could also reset the 1542 - should
@ -939,7 +939,7 @@ static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
if (!wait_mask(STATUS(cmd->device->host->io_port),
STATMASK, IDLE, STST | DIAGF | INVDCMD | DF | CDF, 0)) {
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return FAILED;
}
@ -978,7 +978,7 @@ static int aha1542_reset(struct scsi_cmnd *cmd, u8 reset_cmd)
}
}
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return SUCCESS;
}

12
drivers/scsi/aha1740.c
View File

@ -225,7 +225,7 @@ static irqreturn_t aha1740_intr_handle(int irq, void *dev_id)
if (!host)
panic("aha1740.c: Irq from unknown host!\n");
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
base = host->io_port;
number_serviced = 0;
edev = HOSTDATA(host)->edev;
@ -315,7 +315,7 @@ static irqreturn_t aha1740_intr_handle(int irq, void *dev_id)
number_serviced++;
}
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
return IRQ_RETVAL(handled);
}
@ -353,7 +353,7 @@ static enum scsi_qc_status aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
#endif
/* locate an available ecb */
spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
spin_lock_irqsave(&SCpnt->device->host->host_lock, flags);
ecbno = host->last_ecb_used + 1; /* An optimization */
if (ecbno >= AHA1740_ECBS)
ecbno = 0;
@ -372,7 +372,7 @@ static enum scsi_qc_status aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
doubles as reserved flag */
host->last_ecb_used = ecbno;
spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
spin_unlock_irqrestore(&SCpnt->device->host->host_lock, flags);
#ifdef DEBUG
printk("Sending command (%d %x)...", ecbno, done);
@ -465,7 +465,7 @@ static enum scsi_qc_status aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
unsigned int base = SCpnt->device->host->io_port;
DEB(printk("aha1740[%d] critical section\n",ecbno));
spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
spin_lock_irqsave(&SCpnt->device->host->host_lock, flags);
for (loopcnt = 0; ; loopcnt++) {
if (inb(G2STAT(base)) & G2STAT_MBXOUT) break;
if (loopcnt == LOOPCNT_WARN) {
@ -485,7 +485,7 @@ static enum scsi_qc_status aha1740_queuecommand_lck(struct scsi_cmnd *SCpnt)
panic("aha1740.c: attn wait failed!\n");
}
outb(ATTN_START | (target & 7), ATTN(base)); /* Start it up */
spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
spin_unlock_irqrestore(&SCpnt->device->host->host_lock, flags);
DEB(printk("aha1740[%d] request queued.\n",ecbno));
} else
printk(KERN_ALERT "aha1740_queuecommand: done can't be NULL\n");

8
drivers/scsi/arm/eesox.c
View File

@ -124,14 +124,14 @@ eesoxscsi_terminator_ctl(struct Scsi_Host *host, int on_off)
struct eesoxscsi_info *info = (struct eesoxscsi_info *)host->hostdata;
unsigned long flags;
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
if (on_off)
info->control |= EESOX_TERM_ENABLE;
else
info->control &= ~EESOX_TERM_ENABLE;
writeb(info->control, info->ctl_port);
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
}
/* Prototype: void eesoxscsi_intr(irq, *dev_id, *regs)
@ -457,14 +457,14 @@ static ssize_t eesoxscsi_store_term(struct device *dev, struct device_attribute
unsigned long flags;
if (len > 1) {
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
if (buf[0] != '0') {
info->control |= EESOX_TERM_ENABLE;
} else {
info->control &= ~EESOX_TERM_ENABLE;
}
writeb(info->control, info->ctl_port);
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
}
return len;

20
drivers/scsi/arm/fas216.c
View File

@ -2295,7 +2295,7 @@ static enum scsi_qc_status fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
* However, we must re-enable interrupts, or else we'll be
* waiting forever.
*/
spin_unlock_irq(info->host->host_lock);
spin_unlock_irq(&info->host->host_lock);
while (!info->internal_done) {
/*
@ -2307,13 +2307,13 @@ static enum scsi_qc_status fas216_noqueue_command_lck(struct scsi_cmnd *SCpnt)
* to be some time (eg, disconnected).
*/
if (fas216_readb(info, REG_STAT) & STAT_INT) {
spin_lock_irq(info->host->host_lock);
spin_lock_irq(&info->host->host_lock);
fas216_intr(info);
spin_unlock_irq(info->host->host_lock);
spin_unlock_irq(&info->host->host_lock);
}
}
spin_lock_irq(info->host->host_lock);
spin_lock_irq(&info->host->host_lock);
scsi_done(SCpnt);
@ -2662,7 +2662,7 @@ int fas216_eh_host_reset(struct scsi_cmnd *SCpnt)
{
FAS216_Info *info = (FAS216_Info *)SCpnt->device->host->hostdata;
spin_lock_irq(info->host->host_lock);
spin_lock_irq(&info->host->host_lock);
fas216_checkmagic(info);
@ -2679,9 +2679,9 @@ int fas216_eh_host_reset(struct scsi_cmnd *SCpnt)
* IRQs if we sleep, but we must relock and disable
* IRQs after the sleep.
*/
spin_unlock_irq(info->host->host_lock);
spin_unlock_irq(&info->host->host_lock);
msleep(50 * 1000/100);
spin_lock_irq(info->host->host_lock);
spin_lock_irq(&info->host->host_lock);
/*
* Release the SCSI reset.
@ -2690,7 +2690,7 @@ int fas216_eh_host_reset(struct scsi_cmnd *SCpnt)
fas216_init_chip(info);
spin_unlock_irq(info->host->host_lock);
spin_unlock_irq(&info->host->host_lock);
return SUCCESS;
}
@ -2917,9 +2917,9 @@ int fas216_add(struct Scsi_Host *host, struct device *dev)
/*
* scsi standard says wait 250ms
*/
spin_unlock_irq(info->host->host_lock);
spin_unlock_irq(&info->host->host_lock);
msleep(100*1000/100);
spin_lock_irq(info->host->host_lock);
spin_lock_irq(&info->host->host_lock);
fas216_writeb(info, REG_CNTL1, info->scsi.cfg[0]);
fas216_readb(info, REG_INST);

12
drivers/scsi/atp870u.c
View File

@ -225,7 +225,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
/*
* Issue more commands
*/
spin_lock_irqsave(dev->host->host_lock, flags);
spin_lock_irqsave(&dev->host->host_lock, flags);
if (((dev->quhd[c] != dev->quend[c]) ||
(dev->last_cmd[c] != 0xff)) &&
(dev->in_snd[c] == 0)) {
@ -234,7 +234,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
#endif
send_s870(dev,c);
}
spin_unlock_irqrestore(dev->host->host_lock, flags);
spin_unlock_irqrestore(&dev->host->host_lock, flags);
/*
* Done
*/
@ -511,7 +511,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
*/
scsi_dma_unmap(workreq);
spin_lock_irqsave(dev->host->host_lock, flags);
spin_lock_irqsave(&dev->host->host_lock, flags);
scsi_done(workreq);
#ifdef ED_DBGP
printk("workreq->scsi_done\n");
@ -521,7 +521,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
*/
dev->id[c][target_id].curr_req = NULL;
dev->working[c]--;
spin_unlock_irqrestore(dev->host->host_lock, flags);
spin_unlock_irqrestore(&dev->host->host_lock, flags);
/*
* Take it back wide
*/
@ -533,7 +533,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
/*
* If there is stuff to send and nothing going then send it
*/
spin_lock_irqsave(dev->host->host_lock, flags);
spin_lock_irqsave(&dev->host->host_lock, flags);
if (((dev->last_cmd[c] != 0xff) ||
(dev->quhd[c] != dev->quend[c])) &&
(dev->in_snd[c] == 0)) {
@ -542,7 +542,7 @@ static irqreturn_t atp870u_intr_handle(int irq, void *dev_id)
#endif
send_s870(dev,c);
}
spin_unlock_irqrestore(dev->host->host_lock, flags);
spin_unlock_irqrestore(&dev->host->host_lock, flags);
dev->in_int[c] = 0;
return IRQ_HANDLED;
}

88
drivers/scsi/bfa/bfa_fcs.c
View File

@ -760,53 +760,16 @@ bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric)
bfa_ioc_get_adapter_model(&fabric->fcs->bfa->ioc, model);
/* Model name/number */
strscpy(port_cfg->sym_name.symname, model,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->sym_name.symname, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* Driver Version */
strlcat(port_cfg->sym_name.symname, driver_info->version,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->sym_name.symname, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* Host machine name */
strlcat(port_cfg->sym_name.symname,
driver_info->host_machine_name,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->sym_name.symname, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/*
* Host OS Info :
* If OS Patch Info is not there, do not truncate any bytes from the
* OS name string and instead copy the entire OS info string (64 bytes).
*/
if (driver_info->host_os_patch[0] == '\0') {
strlcat(port_cfg->sym_name.symname,
driver_info->host_os_name,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->sym_name.symname,
BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
} else {
strlcat(port_cfg->sym_name.symname,
driver_info->host_os_name,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->sym_name.symname,
BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* Append host OS Patch Info */
strlcat(port_cfg->sym_name.symname,
driver_info->host_os_patch,
BFA_SYMNAME_MAXLEN);
}
/* null terminate */
port_cfg->sym_name.symname[BFA_SYMNAME_MAXLEN - 1] = 0;
snprintf(port_cfg->sym_name.symname, BFA_SYMNAME_MAXLEN,
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s",
model, driver_info->version,
driver_info->host_machine_name,
driver_info->host_os_name,
driver_info->host_os_patch);
}
/*
@ -821,30 +784,13 @@ bfa_fcs_fabric_nsymb_init(struct bfa_fcs_fabric_s *fabric)
bfa_ioc_get_adapter_model(&fabric->fcs->bfa->ioc, model);
/* Model name/number */
strscpy(port_cfg->node_sym_name.symname, model,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->node_sym_name.symname,
BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* Driver Version */
strlcat(port_cfg->node_sym_name.symname, (char *)driver_info->version,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->node_sym_name.symname,
BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* Host machine name */
strlcat(port_cfg->node_sym_name.symname,
driver_info->host_machine_name,
BFA_SYMNAME_MAXLEN);
strlcat(port_cfg->node_sym_name.symname,
BFA_FCS_PORT_SYMBNAME_SEPARATOR,
BFA_SYMNAME_MAXLEN);
/* null terminate */
port_cfg->node_sym_name.symname[BFA_SYMNAME_MAXLEN - 1] = 0;
/* Model name/number, Driver Version, Host machine name */
snprintf(port_cfg->node_sym_name.symname, BFA_SYMNAME_MAXLEN,
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR
"%s" BFA_FCS_PORT_SYMBNAME_SEPARATOR,
model, (char *)driver_info->version,
driver_info->host_machine_name);
}
/*

4
drivers/scsi/bfa/bfad_bsg.c
View File

@ -2552,7 +2552,7 @@ static void bfad_reset_sdev_bflags(struct bfad_im_port_s *im_port,
struct scsi_device *sdev;
unsigned long flags;
spin_lock_irqsave(im_port->shost->host_lock, flags);
spin_lock_irqsave(&im_port->shost->host_lock, flags);
list_for_each_entry(itnim, &im_port->itnim_mapped_list, list_entry) {
sdev = __scsi_device_lookup(im_port->shost, itnim->channel,
itnim->scsi_tgt_id, 0);
@ -2563,7 +2563,7 @@ static void bfad_reset_sdev_bflags(struct bfad_im_port_s *im_port,
sdev->sdev_bflags &= ~scan_flags;
}
}
spin_unlock_irqrestore(im_port->shost->host_lock, flags);
spin_unlock_irqrestore(&im_port->shost->host_lock, flags);
}
/* Function to reset the LUN SCAN mode */

55
drivers/scsi/ch.c
View File

@ -122,38 +122,32 @@ static DEFINE_IDR(ch_index_idr);
static DEFINE_SPINLOCK(ch_index_lock);
static const struct {
unsigned char sense;
unsigned char asc;
unsigned char ascq;
int errno;
u8 sense_key;
u16 sense_code;
int errno;
} ch_err[] = {
/* Just filled in what looks right. Hav'nt checked any standard paper for
these errno assignments, so they may be wrong... */
{
.sense = ILLEGAL_REQUEST,
.asc = 0x21,
.ascq = 0x01,
.errno = EBADSLT, /* Invalid element address */
.sense_key = ILLEGAL_REQUEST,
.sense_code = INVALID_ELEMENT_ADDRESS,
.errno = EBADSLT,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x28,
.ascq = 0x01,
.errno = EBADE, /* Import or export element accessed */
.sense_key = ILLEGAL_REQUEST,
.sense_code = IMPORT_OR_EXPORT_ELEMENT_ACCESSED,
.errno = EBADE,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x3B,
.ascq = 0x0D,
.errno = EXFULL, /* Medium destination element full */
.sense_key = ILLEGAL_REQUEST,
.sense_code = MEDIUM_DESTINATION_ELEMENT_FULL,
.errno = EXFULL,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x3B,
.ascq = 0x0E,
.errno = EBADE, /* Medium source element empty */
.sense_key = ILLEGAL_REQUEST,
.sense_code = MEDIUM_SOURCE_ELEMENT_EMPTY,
.errno = EBADE,
},{
.sense = ILLEGAL_REQUEST,
.asc = 0x20,
.ascq = 0x00,
.errno = EBADRQC, /* Invalid command operation code */
.sense_key = ILLEGAL_REQUEST,
.sense_code = INVALID_COMMAND_OP_CODE,
.errno = EBADRQC,
},{
/* end of list */
}
@ -166,12 +160,10 @@ static int ch_find_errno(struct scsi_sense_hdr *sshdr)
int i,errno = 0;
/* Check to see if additional sense information is available */
if (scsi_sense_valid(sshdr) &&
sshdr->asc != 0) {
if (scsi_sense_valid(sshdr) && scsi_sense_asc(sshdr) != 0) {
for (i = 0; ch_err[i].errno != 0; i++) {
if (ch_err[i].sense == sshdr->sense_key &&
ch_err[i].asc == sshdr->asc &&
ch_err[i].ascq == sshdr->ascq) {
if (ch_err[i].sense_key == sshdr->sense_key &&
ch_err[i].sense_code == sshdr->sense_code) {
errno = -ch_err[i].errno;
break;
}
@ -190,9 +182,8 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
struct scsi_sense_hdr sshdr;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = 3,
.result = SAM_STAT_CHECK_CONDITION,
},

61
drivers/scsi/constants.c
View File

@ -292,7 +292,7 @@ bool scsi_opcode_sa_name(int opcode, int service_action,
}
struct error_info {
unsigned short code12; /* 0x0302 looks better than 0x03,0x02 */
unsigned short code; /* 0x0302 looks better than 0x03,0x02 */
unsigned short size;
};
@ -318,20 +318,46 @@ static const char *additional_text =
;
struct error_info2 {
unsigned char code1, code2_min, code2_max;
const char * str;
const char * fmt;
u8 asc;
u8 ascq_min;
u8 ascq_max;
const char *str;
const char *fmt;
};
static const struct error_info2 additional2[] =
{
{0x40, 0x00, 0x7f, "Ram failure", ""},
{0x40, 0x80, 0xff, "Diagnostic failure on component", ""},
{0x41, 0x00, 0xff, "Data path failure", ""},
{0x42, 0x00, 0xff, "Power-on or self-test failure", ""},
{0x4D, 0x00, 0xff, "Tagged overlapped commands", "task tag "},
{0x70, 0x00, 0xff, "Decompression exception", "short algorithm id of "},
{0, 0, 0, NULL, NULL}
{
ASC_RAM_FAILURE,
0x00, 0x7f,
"Ram failure", ""
},
{
ASC_RAM_FAILURE,
0x80, 0xff,
"Diagnostic failure on component", ""
},
{
ASC_DATA_PATH_FAILURE,
0x00, 0xff,
"Data path failure", ""
},
{
ASC_POWER_ON_OR_SELFTEST_FAILURE,
0x00, 0xff,
"Power-on or self-test failure", ""
},
{
ASC_TAGGED_OVERLAPPED_COMMANDS,
0x00, 0xff,
"Tagged overlapped commands", "task tag "
},
{
ASC_DECOMPRESSION_EXCEPTION_SHORT_ALGORITHM_ID,
0x00, 0xff,
"Decompression exception", "short algorithm id of "
},
{ 0, 0, 0, NULL, NULL }
};
/* description of the sense key values */
@ -375,22 +401,21 @@ EXPORT_SYMBOL(scsi_sense_key_string);
* This string may contain a "%x" and should be printed with ascq as arg.
*/
const char *
scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
scsi_extd_sense_format(const struct scsi_sense_hdr *sshdr, const char **fmt)
{
int i;
unsigned short code = ((asc << 8) | ascq);
unsigned offset = 0;
int i;
*fmt = NULL;
for (i = 0; i < ARRAY_SIZE(additional); i++) {
if (additional[i].code12 == code)
if (additional[i].code == sshdr->sense_code)
return additional_text + offset;
offset += additional[i].size;
}
for (i = 0; additional2[i].fmt; i++) {
if (additional2[i].code1 == asc &&
ascq >= additional2[i].code2_min &&
ascq <= additional2[i].code2_max) {
if (additional2[i].asc == scsi_sense_asc(sshdr) &&
scsi_sense_ascq(sshdr) >= additional2[i].ascq_min &&
scsi_sense_ascq(sshdr) <= additional2[i].ascq_max) {
*fmt = additional2[i].fmt;
return additional2[i].str;
}

4
drivers/scsi/csiostor/csio_attr.c
View File

@ -84,9 +84,9 @@ csio_reg_rnode(struct csio_rnode *rn)
ln->num_reg_rnodes++;
rport = rn->rport;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
*((struct csio_rnode **)rport->dd_data) = rn;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
sp = &rn->rn_sparm;
rport->maxframe_size = ntohs(sp->csp.sp_bb_data);

4
drivers/scsi/csiostor/csio_scsi.c
View File

@ -2256,14 +2256,14 @@ csio_scan_finished(struct Scsi_Host *shost, unsigned long time)
struct csio_lnode *ln = shost_priv(shost);
int rv = 1;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (!ln->hwp || csio_list_deleted(&ln->sm.sm_list))
goto out;
rv = csio_scan_done(ln, jiffies, time, csio_max_scan_tmo * HZ,
csio_delta_scan_tmo * HZ);
out:
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return rv;
}

18
drivers/scsi/dc395x.c
View File

@ -91,8 +91,8 @@
#endif
#define DC395x_LOCK_IO(dev,flags) spin_lock_irqsave(((struct Scsi_Host *)dev)->host_lock, flags)
#define DC395x_UNLOCK_IO(dev,flags) spin_unlock_irqrestore(((struct Scsi_Host *)dev)->host_lock, flags)
#define DC395x_LOCK_IO(dev,flags) spin_lock_irqsave(&((struct Scsi_Host *)dev)->host_lock, flags)
#define DC395x_UNLOCK_IO(dev,flags) spin_unlock_irqrestore(&((struct Scsi_Host *)dev)->host_lock, flags)
#define DC395x_read8(acb,address) (u8)(inb(acb->io_port_base + (address)))
#define DC395x_read16(acb,address) (u16)(inw(acb->io_port_base + (address)))
@ -1016,9 +1016,9 @@ static int dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
spin_lock_irq(&cmd->device->host->host_lock);
rc = __dc395x_eh_bus_reset(cmd);
spin_unlock_irq(cmd->device->host->host_lock);
spin_unlock_irq(&cmd->device->host->host_lock);
return rc;
}
@ -3808,13 +3808,11 @@ static void adapter_uninit_chip(struct AdapterCtlBlk *acb)
static void adapter_uninit(struct AdapterCtlBlk *acb)
{
unsigned long flags;
DC395x_LOCK_IO(acb->scsi_host, flags);
/* remove timers */
if (timer_pending(&acb->waiting_timer))
timer_delete(&acb->waiting_timer);
if (timer_pending(&acb->selto_timer))
timer_delete(&acb->selto_timer);
/* Drain the self-rearming timer; must not run under host_lock. */
timer_shutdown_sync(&acb->waiting_timer);
DC395x_LOCK_IO(acb->scsi_host, flags);
adapter_uninit_chip(acb);
adapter_remove_and_free_all_devices(acb);

55
drivers/scsi/device_handler/scsi_dh_alua.c
View File

@ -433,61 +433,43 @@ static enum scsi_disposition alua_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
/*
* LUN Not Accessible - ALUA state transition
*/
if (sense_hdr->sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
/*
* LUN Not Accessible - ALUA state transition
*/
if (sense_hdr->sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
alua_handle_state_transition(sdev);
return NEEDS_RETRY;
}
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED) {
/*
* Power On, Reset, or Bus Device Reset.
* Might have obscured a state transition,
* so schedule a recheck.
*/
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
/*
* Device internal reset
*/
if (sense_hdr->sense_code == DEVICE_INTERNAL_RESET)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
/*
* Mode Parameters Changed
*/
if (sense_hdr->sense_code == MODE_PARAMETERS_CHANGED)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
/*
* ALUA state changed
*/
if (sense_hdr->sense_code == ASYMMETRIC_ACCESS_STATE_CHANGED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
/*
* Implicit ALUA state transition failed
*/
if (sense_hdr->sense_code ==
IMPLICIT_ASYMMETRIC_ACCESS_STATE_TRANSITION_FAILED) {
alua_check(sdev, true);
return ADD_TO_MLQUEUE;
}
if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
/*
* Inquiry data has changed
*/
if (sense_hdr->sense_code == INQUIRY_DATA_HAS_CHANGED)
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
if (sense_hdr->sense_code == REPORTED_LUNS_DATA_HAS_CHANGED)
/*
* REPORTED_LUNS_DATA_HAS_CHANGED is reported
* when switching controllers on targets like
@ -517,12 +499,12 @@ static int alua_tur(struct scsi_device *sdev)
ALUA_FAILOVER_RETRIES, &sense_hdr);
if ((sense_hdr.sense_key == NOT_READY ||
sense_hdr.sense_key == UNIT_ATTENTION) &&
sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
sense_hdr.sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION)
return SCSI_DH_RETRY;
else if (retval)
if (retval)
return SCSI_DH_IO;
else
return SCSI_DH_OK;
return SCSI_DH_OK;
}
/*
@ -619,7 +601,8 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
* transition. So set the state to 'transitioning' directly.
*/
if (sense_hdr.sense_key == NOT_READY &&
sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a) {
sense_hdr.sense_code ==
LU_NOT_ACCESSIBLE_ASYMMETRIC_ACCESS_STATE_TRANSITION) {
transitioning_sense = true;
goto skip_rtpg;
}

28
drivers/scsi/device_handler/scsi_dh_emc.c
View File

@ -105,10 +105,10 @@ static int trespass_endio(struct scsi_device *sdev,
sdev_printk(KERN_ERR, sdev, "%s: Found valid sense data 0x%2x, "
"0x%2x, 0x%2x while sending CLARiiON trespass "
"command.\n", CLARIION_NAME, sshdr->sense_key,
sshdr->asc, sshdr->ascq);
scsi_sense_asc(sshdr), scsi_sense_ascq(sshdr));
if (sshdr->sense_key == 0x05 && sshdr->asc == 0x04 &&
sshdr->ascq == 0x00) {
if (sshdr->sense_key == ILLEGAL_REQUEST &&
sshdr->sense_code == LU_NOT_READY) {
/*
* Array based copy in progress -- do not send
* mode_select or copy will be aborted mid-stream.
@ -117,18 +117,18 @@ static int trespass_endio(struct scsi_device *sdev,
"progress while sending CLARiiON trespass "
"command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
} else if (sshdr->sense_key == 0x02 && sshdr->asc == 0x04 &&
sshdr->ascq == 0x03) {
/*
* LUN Not Ready - Manual Intervention Required
* indicates in-progress ucode upgrade (NDU).
*/
} else if (sshdr->sense_key == NOT_READY &&
sshdr->sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
/* Indicates in-progress ucode upgrade (NDU). */
sdev_printk(KERN_INFO, sdev, "%s: Detected in-progress "
"ucode upgrade NDU operation while sending "
"CLARiiON trespass command.\n", CLARIION_NAME);
err = SCSI_DH_DEV_TEMP_BUSY;
} else
} else {
err = SCSI_DH_DEV_FAILED;
}
return err;
}
@ -288,7 +288,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
{
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x03)
if (sense_hdr->sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED)
/*
* LUN Not Ready - Manual Intervention Required
* indicates this is a passive path.
@ -305,7 +306,7 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case ILLEGAL_REQUEST:
if (sense_hdr->asc == 0x25 && sense_hdr->ascq == 0x01)
if (sense_hdr->sense_code == scsi_sense_code(0x25, 0x01))
/*
* An array based copy is in progress. Do not
* fail the path, do not bypass to another PG,
@ -319,7 +320,8 @@ static enum scsi_disposition clariion_check_sense(struct scsi_device *sdev,
return SUCCESS;
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Unit Attention Code. This is the first IO
* to the new path, so just retry.

29
drivers/scsi/device_handler/scsi_dh_hp_sw.c
View File

@ -47,7 +47,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
switch (sshdr->sense_key) {
case NOT_READY:
if (sshdr->asc == 0x04 && sshdr->ascq == 2) {
if (sshdr->sense_code ==
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED) {
/*
* LUN not ready - Initialization command required
*
@ -61,8 +62,8 @@ static int tur_done(struct scsi_device *sdev, struct hp_sw_dh_data *h,
default:
sdev_printk(KERN_WARNING, sdev,
"%s: sending tur failed, sense %x/%x/%x\n",
HP_SW_NAME, sshdr->sense_key, sshdr->asc,
sshdr->ascq);
HP_SW_NAME, sshdr->sense_key,
scsi_sense_asc(sshdr), scsi_sense_ascq(sshdr));
break;
}
return ret;
@ -84,9 +85,8 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -133,14 +133,9 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
/*
* LUN not ready - manual intervention required
*
* Switch-over in progress, retry.
*/
.sense = NOT_READY,
.asc = 0x04,
.ascq = 0x03,
/* Switch-over in progress, retry. */
.sense_key = NOT_READY,
.sense_code = LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED,
.allowed = HP_SW_RETRIES,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -167,7 +162,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
switch (sshdr.sense_key) {
case NOT_READY:
if (sshdr.asc == 0x04 && sshdr.ascq == 3) {
if (sshdr.sense_code ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED) {
rc = SCSI_DH_RETRY;
break;
}
@ -176,7 +172,8 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
sdev_printk(KERN_WARNING, sdev,
"%s: sending start_stop_unit failed, "
"sense %x/%x/%x\n", HP_SW_NAME,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key, scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
rc = SCSI_DH_IO;
}

55
drivers/scsi/device_handler/scsi_dh_rdac.c
View File

@ -493,7 +493,8 @@ static int mode_select_handle_sense(struct scsi_device *sdev,
RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
"MODE_SELECT returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
sense_hdr->sense_key, scsi_sense_asc(sense_hdr),
scsi_sense_ascq(sense_hdr));
return SCSI_DH_IO;
}
@ -514,35 +515,29 @@ static void send_mode_select(struct work_struct *work)
REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER;
struct scsi_failure failure_defs[] = {
{
.sense = NO_SENSE,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = NO_SENSE,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = ABORTED_COMMAND,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = ABORTED_COMMAND,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
{
.sense = UNIT_ATTENTION,
.asc = SCMD_FAILURE_ASC_ANY,
.ascq = SCMD_FAILURE_ASCQ_ANY,
.sense_key = UNIT_ATTENTION,
.sense_code = SCMD_FAILURE_SENSE_CODE_ANY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* LUN Not Ready and is in the Process of Becoming Ready */
{
.sense = NOT_READY,
.asc = 0x04,
.ascq = 0x01,
.sense_key = NOT_READY,
.sense_code = LU_IS_IN_PROCESS_OF_BECOMING_READY,
.result = SAM_STAT_CHECK_CONDITION,
},
/* Command Lock contention */
/* Command Lock contention (not a standard sense code) */
{
.sense = ILLEGAL_REQUEST,
.asc = 0x91,
.ascq = 0x36,
.sense_key = ILLEGAL_REQUEST,
.sense_code = scsi_sense_code(0x91, 0x36),
.allowed = SCMD_FAILURE_NO_LIMIT,
.result = SAM_STAT_CHECK_CONDITION,
},
@ -674,33 +669,34 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
{
struct rdac_dh_data *h = sdev->handler_data;
RDAC_LOG(RDAC_LOG_SENSE, sdev, "array %s, ctlr %d, "
"I/O returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
RDAC_LOG(RDAC_LOG_SENSE, sdev,
"array %s, ctlr %d, I/O returned with sense %02x/%02x/%02x",
(char *) h->ctlr->array_name, h->ctlr->index,
sense_hdr->sense_key, scsi_sense_asc(sense_hdr),
scsi_sense_ascq(sense_hdr));
switch (sense_hdr->sense_key) {
case NOT_READY:
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
if (sense_hdr->sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY)
/* LUN Not Ready - Logical Unit Not Ready and is in
* the process of becoming ready
* Just retry.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
if (sense_hdr->sense_code == scsi_sense_code(0x04, 0x81))
/* LUN Not Ready - Storage firmware incompatible
* Manual code synchonisation required.
*
* Nothing we can do here. Try to bypass the path.
*/
return SUCCESS;
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
if (sense_hdr->sense_code == scsi_sense_code(0x04, 0xA1))
/* LUN Not Ready - Quiescense in progress
*
* Just retry and wait.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0xA1 && sense_hdr->ascq == 0x02)
if (sense_hdr->sense_code == scsi_sense_code(0xA1, 0x02))
/* LUN Not Ready - Quiescense in progress
* or has been achieved
* Just retry.
@ -708,7 +704,7 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
return ADD_TO_MLQUEUE;
break;
case ILLEGAL_REQUEST:
if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
if (sense_hdr->sense_code == scsi_sense_code(0x94, 0x01)) {
/* Invalid Request - Current Logical Unit Ownership.
* Controller is not the current owner of the LUN,
* Fail the path, so that the other path be used.
@ -718,12 +714,13 @@ static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
}
break;
case UNIT_ATTENTION:
if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
if (sense_hdr->sense_code ==
POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED)
/*
* Power On, Reset, or Bus Device Reset, just retry.
*/
return ADD_TO_MLQUEUE;
if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
if (sense_hdr->sense_code == scsi_sense_code(0x8b, 0x02))
/*
* Quiescence in progress , just retry.
*/

32
drivers/scsi/esp_scsi.c
View File

@ -2174,7 +2174,7 @@ irqreturn_t scsi_esp_intr(int irq, void *dev_id)
unsigned long flags;
irqreturn_t ret;
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
ret = IRQ_NONE;
if (esp->ops->irq_pending(esp)) {
ret = IRQ_HANDLED;
@ -2194,7 +2194,7 @@ irqreturn_t scsi_esp_intr(int irq, void *dev_id)
break;
}
}
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
return ret;
}
@ -2497,7 +2497,7 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
/* XXX This helps a lot with debugging but might be a bit
* XXX much for the final driver.
*/
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
shost_printk(KERN_ERR, esp->host, "Aborting command [%p:%02x]\n",
cmd, cmd->cmnd[0]);
ent = esp->active_cmd;
@ -2514,9 +2514,9 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
ent->cmd, ent->cmd->cmnd[0]);
}
esp_dump_cmd_log(esp);
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
ent = NULL;
list_for_each_entry(tmp, &esp->queued_cmds, list) {
@ -2579,12 +2579,12 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
goto out_failure;
}
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
if (!wait_for_completion_timeout(&eh_done, 5 * HZ)) {
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
ent->eh_done = NULL;
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
return FAILED;
}
@ -2592,7 +2592,7 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
return SUCCESS;
out_success:
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
return SUCCESS;
out_failure:
@ -2600,7 +2600,7 @@ static int esp_eh_abort_handler(struct scsi_cmnd *cmd)
* XXX since we know which target/lun in particular is
* XXX causing trouble.
*/
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
return FAILED;
}
@ -2612,7 +2612,7 @@ static int esp_eh_bus_reset_handler(struct scsi_cmnd *cmd)
init_completion(&eh_reset);
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
esp->eh_reset = &eh_reset;
@ -2624,14 +2624,14 @@ static int esp_eh_bus_reset_handler(struct scsi_cmnd *cmd)
esp->flags |= ESP_FLAG_RESETTING;
scsi_esp_cmd(esp, ESP_CMD_RS);
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
ssleep(esp_bus_reset_settle);
if (!wait_for_completion_timeout(&eh_reset, 5 * HZ)) {
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
esp->eh_reset = NULL;
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
return FAILED;
}
@ -2645,10 +2645,10 @@ static int esp_eh_host_reset_handler(struct scsi_cmnd *cmd)
struct esp *esp = shost_priv(cmd->device->host);
unsigned long flags;
spin_lock_irqsave(esp->host->host_lock, flags);
spin_lock_irqsave(&esp->host->host_lock, flags);
esp_bootup_reset(esp);
esp_reset_cleanup(esp);
spin_unlock_irqrestore(esp->host->host_lock, flags);
spin_unlock_irqrestore(&esp->host->host_lock, flags);
ssleep(esp_bus_reset_settle);

4
drivers/scsi/fcoe/fcoe.c
View File

@ -2705,7 +2705,7 @@ static void fcoe_vport_remove(struct fc_lport *lport)
fc_host = shost_to_fc_host(shost);
/* Loop through all the vports and mark them for deletion */
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
list_for_each_entry_safe(vport, next_vport, &fc_host->vports, peers) {
if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) {
continue;
@ -2715,7 +2715,7 @@ static void fcoe_vport_remove(struct fc_lport *lport)
&vport->vport_delete_work);
}
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
flush_workqueue(fc_host_work_q(shost));
}

16
drivers/scsi/fdomain.c
View File

@ -273,7 +273,7 @@ static void fdomain_work(struct work_struct *work)
int status;
int done = 0;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
if (scsi_pointer->phase & in_arbitration) {
status = inb(fd->base + REG_ASTAT);
@ -380,7 +380,7 @@ static void fdomain_work(struct work_struct *work)
fd->base + REG_ICTL);
}
out:
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
}
static irqreturn_t fdomain_irq(int irq, void *dev_id)
@ -416,7 +416,7 @@ static enum scsi_qc_status fdomain_queue(struct Scsi_Host *sh,
scsi_pointer->phase = in_arbitration;
scsi_set_resid(cmd, scsi_bufflen(cmd));
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
fd->cur_cmd = cmd;
@ -431,7 +431,7 @@ static enum scsi_qc_status fdomain_queue(struct Scsi_Host *sh,
/* Start arbitration */
outb(ACTL_ARB | ACTL_IRQEN | PARITY_MASK, fd->base + REG_ACTL);
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return 0;
}
@ -445,7 +445,7 @@ static int fdomain_abort(struct scsi_cmnd *cmd)
if (!fd->cur_cmd)
return FAILED;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
fdomain_make_bus_idle(fd);
fdomain_scsi_pointer(fd->cur_cmd)->phase |= aborted;
@ -453,7 +453,7 @@ static int fdomain_abort(struct scsi_cmnd *cmd)
/* Aborts are not done well. . . */
set_host_byte(fd->cur_cmd, DID_ABORT);
fdomain_finish_cmd(fd);
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return SUCCESS;
}
@ -463,9 +463,9 @@ static int fdomain_host_reset(struct scsi_cmnd *cmd)
struct fdomain *fd = shost_priv(sh);
unsigned long flags;
spin_lock_irqsave(sh->host_lock, flags);
spin_lock_irqsave(&sh->host_lock, flags);
fdomain_reset(fd->base);
spin_unlock_irqrestore(sh->host_lock, flags);
spin_unlock_irqrestore(&sh->host_lock, flags);
return SUCCESS;
}

4
drivers/scsi/gvp11.c
View File

@ -42,9 +42,9 @@ static irqreturn_t gvp11_intr(int irq, void *data)
if (!(status & GVP11_DMAC_INT_PENDING))
return IRQ_NONE;
spin_lock_irqsave(instance->host_lock, flags);
spin_lock_irqsave(&instance->host_lock, flags);
wd33c93_intr(instance);
spin_unlock_irqrestore(instance->host_lock, flags);
spin_unlock_irqrestore(&instance->host_lock, flags);
return IRQ_HANDLED;
}

17
drivers/scsi/hosts.c
View File

@ -73,7 +73,7 @@ static struct class shost_class = {
* transition is illegal.
**/
int scsi_host_set_state(struct Scsi_Host *shost, enum scsi_host_state state)
__must_hold(shost->host_lock)
__must_hold(&shost->host_lock)
{
enum scsi_host_state oldstate = READ_ONCE(shost->shost_state);
@ -168,14 +168,14 @@ void scsi_remove_host(struct Scsi_Host *shost)
unsigned long flags;
mutex_lock(&shost->scan_mutex);
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (scsi_host_set_state(shost, SHOST_CANCEL))
if (scsi_host_set_state(shost, SHOST_CANCEL_RECOVERY)) {
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
mutex_unlock(&shost->scan_mutex);
return;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
scsi_autopm_get_host(shost);
flush_workqueue(shost->tmf_work_q);
@ -193,10 +193,10 @@ void scsi_remove_host(struct Scsi_Host *shost)
kref_put(&shost->tagset_refcnt, scsi_mq_free_tags);
wait_for_completion(&shost->tagset_freed);
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (scsi_host_set_state(shost, SHOST_DEL))
BUG_ON(scsi_host_set_state(shost, SHOST_DEL_RECOVERY));
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
transport_unregister_device(&shost->shost_gendev);
device_unregister(&shost->shost_dev);
@ -277,7 +277,7 @@ int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
if (error)
goto out_disable_runtime_pm;
scoped_guard(spinlock_irq, shost->host_lock)
scoped_guard(spinlock_irq, &shost->host_lock)
scsi_host_set_state(shost, SHOST_RUNNING);
get_device(shost->shost_gendev.parent);
@ -414,8 +414,7 @@ struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *sht, int priv
if (!shost)
return NULL;
shost->host_lock = &shost->default_lock;
scoped_guard(spinlock_init, shost->host_lock)
scoped_guard(spinlock_init, &shost->host_lock)
shost->shost_state = SHOST_CREATED;
INIT_LIST_HEAD(&shost->__devices);
INIT_LIST_HEAD(&shost->__targets);

71
drivers/scsi/hpsa.c
View File

@ -353,14 +353,13 @@ static inline bool hpsa_is_cmd_idle(struct CommandList *c)
/* extract sense key, asc, and ascq from sense data. -1 means invalid. */
static void decode_sense_data(const u8 *sense_data, int sense_data_len,
u8 *sense_key, u8 *asc, u8 *ascq)
u8 *sense_key, u16 *sense_code)
{
struct scsi_sense_hdr sshdr;
bool rc;
*sense_key = -1;
*asc = -1;
*ascq = -1;
*sense_code = -1;
if (sense_data_len < 1)
return;
@ -368,15 +367,15 @@ static void decode_sense_data(const u8 *sense_data, int sense_data_len,
rc = scsi_normalize_sense(sense_data, sense_data_len, &sshdr);
if (rc) {
*sense_key = sshdr.sense_key;
*asc = sshdr.asc;
*ascq = sshdr.ascq;
*sense_code = sshdr.sense_code;
}
}
static int check_for_unit_attention(struct ctlr_info *h,
struct CommandList *c)
{
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
if (c->err_info->SenseLen > sizeof(c->err_info->SenseInfo))
@ -385,34 +384,35 @@ static int check_for_unit_attention(struct ctlr_info *h,
sense_len = c->err_info->SenseLen;
decode_sense_data(c->err_info->SenseInfo, sense_len,
&sense_key, &asc, &ascq);
if (sense_key != UNIT_ATTENTION || asc == 0xff)
&sense_key, &sense_code);
if (sense_key != UNIT_ATTENTION ||
scsi_sense_code_asc(sense_code) == 0xff)
return 0;
switch (asc) {
case STATE_CHANGED:
switch (scsi_sense_code_asc(sense_code)) {
case ASC_PARAMETERS_CHANGED:
dev_warn(&h->pdev->dev,
"%s: a state change detected, command retried\n",
h->devname);
break;
case LUN_FAILED:
case ASC_LU_HAS_NOT_SELF_CONFIGURED_YET:
dev_warn(&h->pdev->dev,
"%s: LUN failure detected\n", h->devname);
break;
case REPORT_LUNS_CHANGED:
case ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED:
dev_warn(&h->pdev->dev,
"%s: report LUN data changed\n", h->devname);
/*
* Note: this REPORT_LUNS_CHANGED condition only occurs on the external
* target (array) devices.
* Note: this ASC_TARGET_OPERATING_CONDITIONS_HAVE_CHANGED condition
* only occurs on the external target (array) devices.
*/
break;
case POWER_OR_RESET:
case ASC_POWER_ON_RESET_OR_BUS_DEVICE_RESET_OCCURRED:
dev_warn(&h->pdev->dev,
"%s: a power on or device reset detected\n",
h->devname);
break;
case UNIT_ATTENTION_CLEARED:
case ASC_COMMANDS_CLEARED_BY_ANOTHER_INITIATOR:
dev_warn(&h->pdev->dev,
"%s: unit attention cleared by another initiator\n",
h->devname);
@ -2562,10 +2562,8 @@ static void complete_scsi_command(struct CommandList *cp)
struct ErrorInfo *ei;
struct hpsa_scsi_dev_t *dev;
struct io_accel2_cmd *c2;
u8 sense_key;
u8 asc; /* additional sense code */
u8 ascq; /* additional sense code qualifier */
u16 sense_code;
unsigned long sense_data_size;
ei = cp->err_info;
@ -2666,18 +2664,19 @@ static void complete_scsi_command(struct CommandList *cp)
memcpy(cmd->sense_buffer, ei->SenseInfo, sense_data_size);
if (ei->ScsiStatus)
decode_sense_data(ei->SenseInfo, sense_data_size,
&sense_key, &asc, &ascq);
&sense_key, &sense_code);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
switch (sense_key) {
case ABORTED_COMMAND:
cmd->result |= DID_SOFT_ERROR << 16;
break;
case UNIT_ATTENTION:
if (asc == 0x3F && ascq == 0x0E)
if (sense_code ==
REPORTED_LUNS_DATA_HAS_CHANGED)
h->drv_req_rescan = 1;
break;
case ILLEGAL_REQUEST:
if (asc == 0x25 && ascq == 0x00) {
if (sense_code == LU_NOT_SUPPORTED) {
dev->removed = 1;
cmd->result = DID_NO_CONNECT << 16;
}
@ -2693,7 +2692,9 @@ static void complete_scsi_command(struct CommandList *cp)
"Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
"Returning result: 0x%x\n",
cp, ei->ScsiStatus,
sense_key, asc, ascq,
sense_key,
scsi_sense_code_asc(sense_code),
scsi_sense_code_ascq(sense_code),
cmd->result);
} else { /* scsi status is zero??? How??? */
dev_warn(&h->pdev->dev, "cp %p SCSI status was 0. "
@ -2919,7 +2920,8 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
{
const struct ErrorInfo *ei = cp->err_info;
struct device *d = &cp->h->pdev->dev;
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
switch (ei->CommandStatus) {
@ -2928,12 +2930,13 @@ static void hpsa_scsi_interpret_error(struct ctlr_info *h,
sense_len = sizeof(ei->SenseInfo);
else
sense_len = ei->SenseLen;
decode_sense_data(ei->SenseInfo, sense_len,
&sense_key, &asc, &ascq);
decode_sense_data(ei->SenseInfo, sense_len, &sense_key,
&sense_code);
hpsa_print_cmd(h, "SCSI status", cp);
if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION)
dev_warn(d, "SCSI Status = 02, Sense key = 0x%02x, ASC = 0x%02x, ASCQ = 0x%02x\n",
sense_key, asc, ascq);
sense_key, scsi_sense_code_asc(sense_code),
scsi_sense_code_ascq(sense_code));
else
dev_warn(d, "SCSI Status = 0x%02x\n", ei->ScsiStatus);
if (ei->ScsiStatus == 0)
@ -3868,12 +3871,10 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
{
struct CommandList *c;
unsigned char *sense;
u8 sense_key, asc, ascq;
u8 sense_key;
u16 sense_code;
int sense_len;
int rc, ldstat = 0;
#define ASC_LUN_NOT_READY 0x04
#define ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS 0x04
#define ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ 0x02
c = cmd_alloc(h);
@ -3889,7 +3890,7 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
sense_len = sizeof(c->err_info->SenseInfo);
else
sense_len = c->err_info->SenseLen;
decode_sense_data(sense, sense_len, &sense_key, &asc, &ascq);
decode_sense_data(sense, sense_len, &sense_key, &sense_code);
cmd_free(h, c);
/* Determine the reason for not ready state */
@ -3912,8 +3913,8 @@ static unsigned char hpsa_volume_offline(struct ctlr_info *h,
/* If VPD status page isn't available,
* use ASC/ASCQ to determine state
*/
if ((ascq == ASCQ_LUN_NOT_READY_FORMAT_IN_PROGRESS) ||
(ascq == ASCQ_LUN_NOT_READY_INITIALIZING_CMD_REQ))
if (sense_code == LU_NOT_READY_FORMAT_IN_PROGRESS ||
sense_code == LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)
return ldstat;
break;
default:
@ -6499,7 +6500,7 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h,
return -EINVAL;
if (ioc->buf_size > ioc->malloc_size * SG_ENTRIES_IN_CMD)
return -EINVAL;
buff = kcalloc(SG_ENTRIES_IN_CMD, sizeof(char *), GFP_KERNEL);
buff = kcalloc(SG_ENTRIES_IN_CMD, sizeof(*buff), GFP_KERNEL);
if (!buff) {
status = -ENOMEM;
goto cleanup1;

23
drivers/scsi/hpsa_cmd.h
View File

@ -63,29 +63,6 @@
#define CISS_TMF_WRONG_LUN 0x09
#define CISS_TMF_OVERLAPPED_TAG 0x0a
/* Unit Attentions ASC's as defined for the MSA2012sa */
#define POWER_OR_RESET 0x29
#define STATE_CHANGED 0x2a
#define UNIT_ATTENTION_CLEARED 0x2f
#define LUN_FAILED 0x3e
#define REPORT_LUNS_CHANGED 0x3f
/* Unit Attentions ASCQ's as defined for the MSA2012sa */
/* These ASCQ's defined for ASC = POWER_OR_RESET */
#define POWER_ON_RESET 0x00
#define POWER_ON_REBOOT 0x01
#define SCSI_BUS_RESET 0x02
#define MSA_TARGET_RESET 0x03
#define CONTROLLER_FAILOVER 0x04
#define TRANSCEIVER_SE 0x05
#define TRANSCEIVER_LVD 0x06
/* These ASCQ's defined for ASC = STATE_CHANGED */
#define RESERVATION_PREEMPTED 0x03
#define ASYM_ACCESS_CHANGED 0x06
#define LUN_CAPACITY_CHANGED 0x09
/* transfer direction */
#define XFER_NONE 0x00
#define XFER_WRITE 0x01

8
drivers/scsi/hptiop.c
View File

@ -385,9 +385,9 @@ static int iop_send_sync_msg(struct hptiop_hba *hba, u32 msg, u32 millisec)
hba->ops->post_msg(hba, msg);
for (i = 0; i < millisec; i++) {
spin_lock_irq(hba->host->host_lock);
spin_lock_irq(&hba->host->host_lock);
hba->ops->iop_intr(hba);
spin_unlock_irq(hba->host->host_lock);
spin_unlock_irq(&hba->host->host_lock);
if (hba->msg_done)
break;
msleep(1);
@ -836,9 +836,9 @@ static irqreturn_t hptiop_intr(int irq, void *dev_id)
int handled;
unsigned long flags;
spin_lock_irqsave(hba->host->host_lock, flags);
spin_lock_irqsave(&hba->host->host_lock, flags);
handled = hba->ops->iop_intr(hba);
spin_unlock_irqrestore(hba->host->host_lock, flags);
spin_unlock_irqrestore(&hba->host->host_lock, flags);
return handled;
}

262
drivers/scsi/ibmvscsi/ibmvfc-core.c
View File

@ -974,14 +974,14 @@ static int ibmvfc_reenable_crq_queue(struct ibmvfc_host *vhost)
if (rc)
dev_err(vhost->dev, "Error enabling adapter (rc=%d)\n", rc);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
spin_lock(vhost->crq.q_lock);
vhost->do_enquiry = 1;
vhost->using_channels = 0;
vhost->do_scsi_login = 0;
vhost->do_nvme_login = 0;
spin_unlock(vhost->crq.q_lock);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_reg_sub_crqs(vhost, &vhost->scsi_scrqs);
ibmvfc_reg_sub_crqs(vhost, &vhost->nvme_scrqs);
@ -1013,7 +1013,7 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
rc = plpar_hcall_norets(H_FREE_CRQ, vdev->unit_address);
} while (rc == H_BUSY || H_IS_LONG_BUSY(rc));
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
spin_lock(vhost->crq.q_lock);
vhost->state = IBMVFC_NO_CRQ;
vhost->logged_in = 0;
@ -1037,7 +1037,7 @@ static int ibmvfc_reset_crq(struct ibmvfc_host *vhost)
dev_warn(vhost->dev, "Couldn't register crq (rc=%d)\n", rc);
spin_unlock(vhost->crq.q_lock);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_reg_sub_crqs(vhost, &vhost->scsi_scrqs);
ibmvfc_reg_sub_crqs(vhost, &vhost->nvme_scrqs);
@ -1250,9 +1250,9 @@ static void ibmvfc_reset_host(struct ibmvfc_host *vhost)
{
unsigned long flags;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
__ibmvfc_reset_host(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -1318,9 +1318,9 @@ static struct ibmvfc_target *ibmvfc_get_target(struct scsi_target *starget)
struct ibmvfc_target *tgt;
unsigned long flags;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
tgt = __ibmvfc_get_target(starget);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return tgt;
}
@ -1336,7 +1336,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
struct ibmvfc_host *vhost = shost_priv(shost);
unsigned long flags;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (vhost->state == IBMVFC_ACTIVE) {
switch (be64_to_cpu(vhost->login_buf->resp.link_speed) / 100) {
case 1:
@ -1365,7 +1365,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
}
} else
fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
}
/**
@ -1380,7 +1380,7 @@ static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
struct ibmvfc_host *vhost = shost_priv(shost);
unsigned long flags;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
switch (vhost->state) {
case IBMVFC_INITIALIZING:
case IBMVFC_ACTIVE:
@ -1404,7 +1404,7 @@ static void ibmvfc_get_host_port_state(struct Scsi_Host *shost)
fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
break;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
}
/**
@ -1642,9 +1642,9 @@ static void ibmvfc_locked_done(struct ibmvfc_event *evt)
{
unsigned long flags;
spin_lock_irqsave(evt->vhost->host->host_lock, flags);
spin_lock_irqsave(&evt->vhost->host->host_lock, flags);
evt->_done(evt);
spin_unlock_irqrestore(evt->vhost->host->host_lock, flags);
spin_unlock_irqrestore(&evt->vhost->host->host_lock, flags);
}
/**
@ -1905,7 +1905,7 @@ static void ibmvfc_scsi_relogin(struct scsi_device *sdev)
struct ibmvfc_target *tgt;
unsigned long flags;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
list_for_each_entry(tgt, &vhost->scsi_scrqs.targets, queue) {
if (rport == tgt->rport) {
ibmvfc_del_tgt(tgt);
@ -1914,7 +1914,7 @@ static void ibmvfc_scsi_relogin(struct scsi_device *sdev)
}
ibmvfc_reinit_host(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -2147,17 +2147,17 @@ static int ibmvfc_bsg_timeout(struct bsg_job *job)
int rc;
ENTER;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
__ibmvfc_reset_host(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return 0;
}
vhost->aborting_passthru = 1;
evt = ibmvfc_get_reserved_event(&vhost->crq);
if (!evt) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return -ENOMEM;
}
@ -2181,7 +2181,7 @@ static int ibmvfc_bsg_timeout(struct bsg_job *job)
dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
port_id);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
LEAVE;
return rc;
@ -2205,7 +2205,7 @@ static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
int rc = 0, issue_login = 1;
ENTER;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
list_for_each_entry(tgt, &vhost->scsi_scrqs.targets, queue) {
if (tgt->scsi_id == port_id) {
issue_login = 0;
@ -2234,7 +2234,7 @@ static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
init_completion(&evt->comp);
rc = ibmvfc_send_event(evt, vhost, default_timeout);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rc)
return -EIO;
@ -2244,10 +2244,10 @@ static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
if (rsp_iu.plogi.common.status)
rc = -EIO;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
unlock_out:
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
LEAVE;
return rc;
}
@ -2332,17 +2332,17 @@ static int ibmvfc_bsg_request(struct bsg_job *job)
if (issue_login)
rc = ibmvfc_bsg_plogi(vhost, port_id);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (unlikely(rc || (rport && (rc = fc_remote_port_chkready(rport)))) ||
unlikely((rc = ibmvfc_host_chkready(vhost)))) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
goto out;
}
evt = ibmvfc_get_reserved_event(&vhost->crq);
if (!evt) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
rc = -ENOMEM;
goto out;
}
@ -2374,7 +2374,7 @@ static int ibmvfc_bsg_request(struct bsg_job *job)
evt->sync_iu = &rsp_iu;
init_completion(&evt->comp);
rc = ibmvfc_send_event(evt, vhost, 0);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rc) {
rc = -EIO;
@ -2388,9 +2388,9 @@ static int ibmvfc_bsg_request(struct bsg_job *job)
else
bsg_reply->reply_payload_rcv_len = rsp_len;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
bsg_reply->result = rc;
bsg_job_done(job, bsg_reply->result,
bsg_reply->reply_payload_rcv_len);
@ -2427,7 +2427,7 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
unsigned long flags;
int rsp_code = 0;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (vhost->state == IBMVFC_ACTIVE) {
if (vhost->using_channels)
evt = ibmvfc_get_event(&vhost->scsi_scrqs.scrqs[0]);
@ -2435,7 +2435,7 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
evt = ibmvfc_get_event(&vhost->crq);
if (!evt) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return -ENOMEM;
}
@ -2452,7 +2452,7 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
init_completion(&evt->comp);
rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rsp_rc != 0) {
sdev_printk(KERN_ERR, sdev, "Failed to send %s reset event. rc=%d\n",
@ -2479,9 +2479,9 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
} else
sdev_printk(KERN_INFO, sdev, "%s reset successful\n", desc);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return rsp_rc;
}
@ -2583,7 +2583,7 @@ static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
do {
wait = 0;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
for (q_index = 0; q_index < q_size; q_index++) {
spin_lock(&queues[q_index].l_lock);
for (i = 0; i < queues[q_index].evt_pool.size; i++) {
@ -2597,14 +2597,14 @@ static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
}
spin_unlock(&queues[q_index].l_lock);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (wait) {
timeout = wait_for_completion_timeout(&comp, timeout);
if (!timeout) {
wait = 0;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
for (q_index = 0; q_index < q_size; q_index++) {
spin_lock(&queues[q_index].l_lock);
for (i = 0; i < queues[q_index].evt_pool.size; i++) {
@ -2618,7 +2618,7 @@ static int ibmvfc_wait_for_ops(struct ibmvfc_host *vhost, void *device,
}
spin_unlock(&queues[q_index].l_lock);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (wait)
dev_err(vhost->dev, "Timed out waiting for aborted commands\n");
LEAVE;
@ -2684,7 +2684,7 @@ static int ibmvfc_cancel_all_mq(struct scsi_device *sdev, int type)
u16 status;
ENTER;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
num_hwq = vhost->scsi_scrqs.active_queues;
for (i = 0; i < num_hwq; i++) {
spin_lock(queues[i].q_lock);
@ -2702,7 +2702,7 @@ static int ibmvfc_cancel_all_mq(struct scsi_device *sdev, int type)
evt = ibmvfc_init_tmf(&queues[i], sdev, type);
if (!evt) {
spin_unlock(queues[i].q_lock);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return -ENOMEM;
}
evt->sync_iu = &queues[i].cancel_rsp;
@ -2712,7 +2712,7 @@ static int ibmvfc_cancel_all_mq(struct scsi_device *sdev, int type)
spin_unlock(queues[i].q_lock);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (list_empty(&cancelq)) {
if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
@ -2763,7 +2763,7 @@ static int ibmvfc_cancel_all_sq(struct scsi_device *sdev, int type)
ENTER;
found_evt = NULL;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
spin_lock(&vhost->crq.l_lock);
list_for_each_entry(evt, &vhost->crq.sent, queue_list) {
if (evt->cmnd && evt->cmnd->device == sdev) {
@ -2776,7 +2776,7 @@ static int ibmvfc_cancel_all_sq(struct scsi_device *sdev, int type)
if (!found_evt) {
if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
sdev_printk(KERN_INFO, sdev, "No events found to cancel\n");
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return 0;
}
@ -2786,7 +2786,7 @@ static int ibmvfc_cancel_all_sq(struct scsi_device *sdev, int type)
rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rsp_rc != 0) {
sdev_printk(KERN_ERR, sdev, "Failed to send cancel event. rc=%d\n", rsp_rc);
@ -2800,9 +2800,9 @@ static int ibmvfc_cancel_all_sq(struct scsi_device *sdev, int type)
wait_for_completion(&evt->comp);
status = be16_to_cpu(rsp.mad_common.status);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (status != IBMVFC_MAD_SUCCESS) {
sdev_printk(KERN_WARNING, sdev, "Cancel failed with rc=%x\n", status);
@ -2899,7 +2899,7 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
int rsp_code = 0;
found_evt = NULL;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
spin_lock(&vhost->crq.l_lock);
list_for_each_entry(evt, &vhost->crq.sent, queue_list) {
if (evt->cmnd && evt->cmnd->device == sdev) {
@ -2912,14 +2912,14 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
if (!found_evt) {
if (vhost->log_level > IBMVFC_DEFAULT_LOG_LEVEL)
sdev_printk(KERN_INFO, sdev, "No events found to abort\n");
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return 0;
}
if (vhost->state == IBMVFC_ACTIVE) {
evt = ibmvfc_get_event(&vhost->crq);
if (!evt) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return -ENOMEM;
}
ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_CMD_FORMAT);
@ -2938,7 +2938,7 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
rsp_rc = ibmvfc_send_event(evt, vhost, default_timeout);
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rsp_rc != 0) {
sdev_printk(KERN_ERR, sdev, "Failed to send abort. rc=%d\n", rsp_rc);
@ -2967,9 +2967,9 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
rc = ibmvfc_wait_for_ops(vhost, evt, ibmvfc_match_evt);
if (rc != SUCCESS) {
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_hard_reset_host(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
rsp_rc = 0;
}
@ -2994,9 +2994,9 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
sdev_printk(KERN_INFO, sdev, "Abort successful\n");
out:
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return rsp_rc;
}
@ -3176,7 +3176,7 @@ static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
if (rc == FAILED)
ibmvfc_issue_fc_host_lip(shost);
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
found = 0;
list_for_each_entry(tgt, &vhost->scsi_scrqs.targets, queue) {
if (tgt->scsi_id == rport->port_id) {
@ -3195,7 +3195,7 @@ static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
ibmvfc_reinit_host(vhost);
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
LEAVE;
}
@ -3468,7 +3468,7 @@ static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
struct ibmvfc_host *vhost = shost_priv(shost);
int done = 0;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (!vhost->scan_timeout)
done = 1;
else if (time >= (vhost->scan_timeout * HZ)) {
@ -3481,7 +3481,7 @@ static int ibmvfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
vhost->scan_timeout = init_timeout;
done = 1;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return done;
}
@ -3505,9 +3505,9 @@ static int ibmvfc_sdev_init(struct scsi_device *sdev)
if (!rport || fc_remote_port_chkready(rport))
return -ENXIO;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
sdev->hostdata = (void *)(unsigned long)vhost->task_set++;
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return 0;
}
@ -3527,9 +3527,9 @@ static int ibmvfc_target_alloc(struct scsi_target *starget)
struct ibmvfc_host *vhost = shost_priv(shost);
unsigned long flags = 0;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
starget->hostdata = (void *)(unsigned long)vhost->task_set++;
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return 0;
}
@ -3550,12 +3550,12 @@ static int ibmvfc_sdev_configure(struct scsi_device *sdev,
struct Scsi_Host *shost = sdev->host;
unsigned long flags = 0;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (sdev->type == TYPE_DISK) {
sdev->allow_restart = 1;
blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return 0;
}
@ -3646,9 +3646,9 @@ static ssize_t ibmvfc_show_log_level(struct device *dev,
unsigned long flags = 0;
int len;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
len = sysfs_emit(buf, "%d\n", vhost->log_level);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return len;
}
@ -3670,9 +3670,9 @@ static ssize_t ibmvfc_store_log_level(struct device *dev,
struct ibmvfc_host *vhost = shost_priv(shost);
unsigned long flags = 0;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
vhost->log_level = simple_strtoul(buf, NULL, 10);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return strlen(buf);
}
@ -3685,9 +3685,9 @@ static ssize_t ibmvfc_show_scsi_channels(struct device *dev,
unsigned long flags = 0;
int len;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
len = sysfs_emit(buf, "%d\n", scsi->desired_queues);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return len;
}
@ -3701,11 +3701,11 @@ static ssize_t ibmvfc_store_scsi_channels(struct device *dev,
unsigned long flags = 0;
unsigned int channels;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
channels = simple_strtoul(buf, NULL, 10);
scsi->desired_queues = min(channels, shost->nr_hw_queues);
ibmvfc_hard_reset_host(vhost);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return strlen(buf);
}
@ -3751,9 +3751,9 @@ static ssize_t ibmvfc_read_trace(struct file *filp, struct kobject *kobj,
count = size;
}
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
memcpy(buf, &src[off], count);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return count;
}
@ -3864,10 +3864,10 @@ static irqreturn_t ibmvfc_interrupt(int irq, void *dev_instance)
struct ibmvfc_host *vhost = (struct ibmvfc_host *)dev_instance;
unsigned long flags;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
vio_disable_interrupts(to_vio_dev(vhost->dev));
tasklet_schedule(&vhost->tasklet);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return IRQ_HANDLED;
}
@ -3889,7 +3889,7 @@ static void ibmvfc_tasklet(void *data)
int done = 0;
LIST_HEAD(evt_doneq);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
spin_lock(vhost->crq.q_lock);
while (!done) {
/* Pull all the valid messages off the async CRQ */
@ -3922,7 +3922,7 @@ static void ibmvfc_tasklet(void *data)
}
spin_unlock(vhost->crq.q_lock);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
list_for_each_entry_safe(evt, temp, &evt_doneq, queue_list) {
timer_delete(&evt->timer);
@ -4776,12 +4776,12 @@ static void ibmvfc_adisc_timeout(struct timer_list *t)
int rc;
tgt_dbg(tgt, "ADISC timeout\n");
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (vhost->abort_threads >= disc_threads ||
tgt->action != IBMVFC_TGT_ACTION_INIT_WAIT ||
vhost->state != IBMVFC_INITIALIZING ||
vhost->action != IBMVFC_HOST_ACTION_QUERY_TGTS) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return;
}
@ -4793,7 +4793,7 @@ static void ibmvfc_adisc_timeout(struct timer_list *t)
vhost->abort_threads--;
kref_put(&tgt->kref, ibmvfc_release_tgt);
__ibmvfc_reset_host(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return;
}
ibmvfc_init_event(evt, ibmvfc_tgt_adisc_cancel_done, IBMVFC_MAD_FORMAT);
@ -4821,7 +4821,7 @@ static void ibmvfc_adisc_timeout(struct timer_list *t)
__ibmvfc_reset_host(vhost);
} else
tgt_dbg(tgt, "Attempting to cancel ADISC\n");
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -5010,7 +5010,7 @@ static int ibmvfc_alloc_target(struct ibmvfc_host *vhost,
channels = &vhost->nvme_scrqs;
/* Look to see if we already have a target allocated for this SCSI ID or WWPN */
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
list_for_each_entry(tgt, &channels->targets, queue) {
if (tgt->wwpn == wwpn) {
wtgt = tgt;
@ -5062,7 +5062,7 @@ static int ibmvfc_alloc_target(struct ibmvfc_host *vhost,
ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
goto unlock_out;
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
tgt = mempool_alloc(vhost->tgt_pool, GFP_NOIO);
memset(tgt, 0, sizeof(*tgt));
@ -5074,12 +5074,12 @@ static int ibmvfc_alloc_target(struct ibmvfc_host *vhost,
timer_setup(&tgt->timer, ibmvfc_adisc_timeout, 0);
kref_init(&tgt->kref);
ibmvfc_init_tgt(tgt, ibmvfc_tgt_implicit_logout);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
tgt->cancel_key = vhost->task_set++;
list_add_tail(&tgt->queue, &channels->targets);
unlock_out:
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return 0;
}
@ -5853,9 +5853,9 @@ static int ibmvfc_work_to_do(struct ibmvfc_host *vhost)
unsigned long flags;
int rc;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
rc = __ibmvfc_work_to_do(vhost);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return rc;
}
@ -5890,14 +5890,14 @@ static void ibmvfc_tgt_add_nvme_rport(struct ibmvfc_target *tgt)
tgt_dbg(tgt, "Adding NVMe rport\n");
ibmvfc_nvme_register_remoteport(tgt);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
rport = tgt->nvme_remote_port;
if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
tgt_dbg(tgt, "Deleting NVMe rport\n");
list_del(&tgt->queue);
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_nvme_unregister_remoteport(tgt);
timer_delete_sync(&tgt->timer);
kref_put(&tgt->kref, ibmvfc_release_tgt);
@ -5906,11 +5906,11 @@ static void ibmvfc_tgt_add_nvme_rport(struct ibmvfc_target *tgt)
tgt_dbg(tgt, "Deleting NVMe rport with outstanding I/O\n");
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT);
tgt->init_retries = 0;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_nvme_unregister_remoteport(tgt);
return;
} else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return;
}
@ -5919,7 +5919,7 @@ static void ibmvfc_tgt_add_nvme_rport(struct ibmvfc_target *tgt)
tgt->target_id = tgt->nvme_remote_port->port_id;
} else
tgt_dbg(tgt, "NVMe rport add failed\n");
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -5935,13 +5935,13 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
tgt_dbg(tgt, "Adding rport\n");
rport = fc_remote_port_add(vhost->host, 0, &tgt->ids);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (rport && tgt->action == IBMVFC_TGT_ACTION_DEL_RPORT) {
tgt_dbg(tgt, "Deleting rport\n");
list_del(&tgt->queue);
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
fc_remote_port_delete(rport);
timer_delete_sync(&tgt->timer);
kref_put(&tgt->kref, ibmvfc_release_tgt);
@ -5951,11 +5951,11 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT);
tgt->rport = NULL;
tgt->init_retries = 0;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
fc_remote_port_delete(rport);
return;
} else if (rport && tgt->action == IBMVFC_TGT_ACTION_DELETED_RPORT) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return;
}
@ -5973,7 +5973,7 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
rport->supported_classes |= FC_COS_CLASS3;
} else
tgt_dbg(tgt, "rport add failed\n");
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -5991,7 +5991,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
int rc;
ibmvfc_log_ae(vhost, vhost->events_to_log);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
vhost->events_to_log = 0;
switch (vhost->action) {
case IBMVFC_HOST_ACTION_NONE:
@ -6000,12 +6000,12 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
break;
case IBMVFC_HOST_ACTION_RESET:
list_splice_init(&vhost->purge, &purge);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_complete_purge(&purge);
ibmvfc_nvme_unregister(vhost);
rc = ibmvfc_reset_crq(vhost);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (!rc || rc == H_CLOSED)
vio_enable_interrupts(to_vio_dev(vhost->dev));
if (vhost->action == IBMVFC_HOST_ACTION_RESET) {
@ -6026,11 +6026,11 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
break;
case IBMVFC_HOST_ACTION_REENABLE:
list_splice_init(&vhost->purge, &purge);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_complete_purge(&purge);
rc = ibmvfc_reenable_crq_queue(vhost);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
if (vhost->action == IBMVFC_HOST_ACTION_REENABLE) {
/*
* The only action we could have changed to would have
@ -6052,7 +6052,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
BUG_ON(vhost->state != IBMVFC_INITIALIZING);
if (vhost->delay_init) {
vhost->delay_init = 0;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ssleep(15);
return;
} else
@ -6098,7 +6098,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
}
if (ibmvfc_dev_logo_to_do(vhost)) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return;
}
@ -6109,7 +6109,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
tgt->rport = NULL;
list_del(&tgt->queue);
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rport)
fc_remote_port_delete(rport);
timer_delete_sync(&tgt->timer);
@ -6133,7 +6133,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
*/
if (rport && rport->fast_io_fail_tmo == -1)
tgt->move_login = 1;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (rport)
fc_remote_port_delete(rport);
return;
@ -6146,7 +6146,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
nvme_rport = tgt->nvme_remote_port;
list_del(&tgt->queue);
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DELETED_RPORT);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (nvme_rport)
ibmvfc_nvme_unregister_remoteport(tgt);
timer_delete_sync(&tgt->timer);
@ -6157,7 +6157,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
nvme_rport = tgt->nvme_remote_port;
ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_LOGOUT_DELETED_RPORT);
tgt->init_retries = 0;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (nvme_rport)
ibmvfc_nvme_unregister_remoteport(tgt);
return;
@ -6170,14 +6170,14 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
vhost->reinit = 0;
scsi_block_requests(vhost->host);
ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_QUERY);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
} else {
ibmvfc_set_host_state(vhost, IBMVFC_ACTIVE);
ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
wake_up(&vhost->init_wait_q);
schedule_work(&vhost->rport_add_work_q);
vhost->init_retries = 0;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
scsi_unblock_requests(vhost->host);
}
@ -6188,7 +6188,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
}
} else {
ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_NONE);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
scsi_unblock_requests(vhost->host);
wake_up(&vhost->init_wait_q);
return;
@ -6196,9 +6196,9 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
break;
case IBMVFC_HOST_ACTION_ALLOC_TGTS:
ibmvfc_set_host_action(vhost, IBMVFC_HOST_ACTION_TGT_INIT);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_alloc_targets(vhost);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
break;
case IBMVFC_HOST_ACTION_TGT_INIT:
list_for_each_entry(tgt, &vhost->scsi_scrqs.targets, queue) {
@ -6221,7 +6221,7 @@ static void ibmvfc_do_work(struct ibmvfc_host *vhost)
break;
}
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
/**
@ -6754,7 +6754,7 @@ static void ibmvfc_rport_add_thread(struct work_struct *work)
int did_work;
ENTER;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
do {
did_work = 0;
if (vhost->state != IBMVFC_ACTIVE)
@ -6767,19 +6767,19 @@ static void ibmvfc_rport_add_thread(struct work_struct *work)
kref_get(&tgt->kref);
rport = tgt->rport;
if (!rport) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_tgt_add_rport(tgt);
} else if (get_device(&rport->dev)) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
tgt_dbg(tgt, "Setting rport roles\n");
fc_remote_port_rolechg(rport, tgt->ids.roles);
put_device(&rport->dev);
} else {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
}
kref_put(&tgt->kref, ibmvfc_release_tgt);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
break;
}
}
@ -6791,16 +6791,16 @@ static void ibmvfc_rport_add_thread(struct work_struct *work)
kref_get(&tgt->kref);
nvme_rport = tgt->nvme_remote_port;
if (!nvme_rport) {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_tgt_add_nvme_rport(tgt);
} else {
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
if (IS_ENABLED(CONFIG_NVME_FC))
nvme_fc_rescan_remoteport(nvme_rport);
}
kref_put(&tgt->kref, ibmvfc_release_tgt);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
break;
}
}
@ -6808,7 +6808,7 @@ static void ibmvfc_rport_add_thread(struct work_struct *work)
if (vhost->state == IBMVFC_ACTIVE)
vhost->scan_complete = 1;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
LEAVE;
}
@ -6946,9 +6946,9 @@ static void ibmvfc_remove(struct vio_dev *vdev)
ENTER;
ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_wait_while_resetting(vhost);
kthread_stop(vhost->work_thread);
@ -6956,10 +6956,10 @@ static void ibmvfc_remove(struct vio_dev *vdev)
fc_remove_host(vhost->host);
scsi_remove_host(vhost->host);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_purge_requests(vhost, DID_ERROR);
list_splice_init(&vhost->purge, &purge);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_complete_purge(&purge);
ibmvfc_release_sub_crqs(vhost);
ibmvfc_release_crq_queue(vhost);
@ -6986,10 +6986,10 @@ static int ibmvfc_resume(struct device *dev)
struct ibmvfc_host *vhost = dev_get_drvdata(dev);
struct vio_dev *vdev = to_vio_dev(dev);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
vio_disable_interrupts(vdev);
tasklet_schedule(&vhost->tasklet);
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
return 0;
}

8
drivers/scsi/ibmvscsi/ibmvfc-nvme.c
View File

@ -208,7 +208,7 @@ static void ibmvfc_nvme_ls_abort(struct nvme_fc_local_port *lport,
if (!vhost->logged_in || !evt)
return;
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
kref_get(&tgt->kref);
ibmvfc_init_event(evt, ibmvfc_sync_nvme_completion, IBMVFC_MAD_FORMAT);
ibmvfc_init_ls_abort(evt, ls_abort);
@ -217,14 +217,14 @@ static void ibmvfc_nvme_ls_abort(struct nvme_fc_local_port *lport,
if (ibmvfc_send_event(evt, vhost, default_timeout))
goto out;
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
wait_for_completion(&evt->comp);
status = be16_to_cpu(rsp.mad_common.status);
spin_lock_irqsave(vhost->host->host_lock, flags);
spin_lock_irqsave(&vhost->host->host_lock, flags);
ibmvfc_free_event(evt);
out:
spin_unlock_irqrestore(vhost->host->host_lock, flags);
spin_unlock_irqrestore(&vhost->host->host_lock, flags);
ibmvfc_dbg(vhost, "ls_abort: cancel failed with rc=%x\n", status);
kref_put(&tgt->kref, ibmvfc_release_tgt);
}

86
drivers/scsi/ibmvscsi/ibmvscsi.c
View File

@ -785,13 +785,13 @@ static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
struct srp_event_struct *evt;
unsigned long flags;
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
while (!list_empty(&hostdata->sent)) {
evt = list_first_entry(&hostdata->sent, struct srp_event_struct, list);
list_del(&evt->list);
timer_delete(&evt->timer);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
if (evt->cmnd) {
evt->cmnd->result = (error_code << 16);
unmap_cmd_data(&evt->iu.srp.cmd, evt,
@ -802,9 +802,9 @@ static void purge_requests(struct ibmvscsi_host_data *hostdata, int error_code)
evt->iu.srp.login_req.opcode != SRP_LOGIN_REQ)
evt->done(evt);
free_event_struct(&evt->hostdata->pool, evt);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
}
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
}
/**
@ -818,9 +818,9 @@ static void ibmvscsi_set_request_limit(struct ibmvscsi_host_data *hostdata, int
{
unsigned long flags;
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
atomic_set(&hostdata->request_limit, limit);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
}
/**
@ -1221,9 +1221,9 @@ static int send_srp_login(struct ibmvscsi_host_data *hostdata)
*/
ibmvscsi_set_request_limit(hostdata, 0);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
rc = ibmvscsi_send_srp_event(evt_struct, hostdata, login_timeout * 2);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
dev_info(hostdata->dev, "sent SRP login\n");
return rc;
};
@ -1317,10 +1317,10 @@ static void send_mad_capabilities(struct ibmvscsi_host_data *hostdata)
req->common.length = cpu_to_be16(sizeof(hostdata->caps) -
sizeof(hostdata->caps.reserve));
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
dev_err(hostdata->dev, "couldn't send CAPABILITIES_REQ!\n");
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
};
/**
@ -1373,9 +1373,9 @@ static int enable_fast_fail(struct ibmvscsi_host_data *hostdata)
fast_fail_mad->common.type = cpu_to_be32(VIOSRP_ENABLE_FAST_FAIL);
fast_fail_mad->common.length = cpu_to_be16(sizeof(*fast_fail_mad));
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
rc = ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
return rc;
}
@ -1454,10 +1454,10 @@ static void send_mad_adapter_info(struct ibmvscsi_host_data *hostdata)
req->common.length = cpu_to_be16(sizeof(hostdata->madapter_info));
req->buffer = cpu_to_be64(hostdata->adapter_info_addr);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
if (ibmvscsi_send_srp_event(evt_struct, hostdata, info_timeout * 2))
dev_err(hostdata->dev, "couldn't send ADAPTER_INFO_REQ!\n");
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
};
/*
@ -1502,7 +1502,7 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
/* First, find this command in our sent list so we can figure
* out the correct tag
*/
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
wait_switch = jiffies + (init_timeout * HZ);
do {
found_evt = NULL;
@ -1514,13 +1514,13 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
}
if (!found_evt) {
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
return SUCCESS;
}
evt = get_event_struct(&hostdata->pool);
if (evt == NULL) {
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
sdev_printk(KERN_ERR, cmd->device,
"failed to allocate abort event\n");
return FAILED;
@ -1548,12 +1548,12 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
break;
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
msleep(10);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
} while (time_before(jiffies, wait_switch));
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
if (rsp_rc != 0) {
sdev_printk(KERN_ERR, cmd->device,
@ -1592,7 +1592,7 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
* The event is no longer in our list. Make sure it didn't
* complete while we were aborting
*/
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
found_evt = NULL;
list_for_each_entry(tmp_evt, &hostdata->sent, list) {
if (tmp_evt->cmnd == cmd) {
@ -1602,7 +1602,7 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
}
if (found_evt == NULL) {
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
sdev_printk(KERN_INFO, cmd->device, "aborted task tag 0x%llx completed\n",
tsk_mgmt->task_tag);
return SUCCESS;
@ -1616,7 +1616,7 @@ static int ibmvscsi_eh_abort_handler(struct scsi_cmnd *cmd)
unmap_cmd_data(&found_evt->iu.srp.cmd, found_evt,
found_evt->hostdata->dev);
free_event_struct(&found_evt->hostdata->pool, found_evt);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
atomic_inc(&hostdata->request_limit);
return SUCCESS;
}
@ -1638,12 +1638,12 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
u16 lun = lun_from_dev(cmd->device);
unsigned long wait_switch = 0;
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
wait_switch = jiffies + (init_timeout * HZ);
do {
evt = get_event_struct(&hostdata->pool);
if (evt == NULL) {
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
sdev_printk(KERN_ERR, cmd->device,
"failed to allocate reset event\n");
return FAILED;
@ -1670,12 +1670,12 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
if (rsp_rc != SCSI_MLQUEUE_HOST_BUSY)
break;
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
msleep(10);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
} while (time_before(jiffies, wait_switch));
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
if (rsp_rc != 0) {
sdev_printk(KERN_ERR, cmd->device,
@ -1712,7 +1712,7 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
/* We need to find all commands for this LUN that have not yet been
* responded to, and fail them with DID_RESET
*/
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
list_for_each_entry_safe(tmp_evt, pos, &hostdata->sent, list) {
if ((tmp_evt->cmnd) && (tmp_evt->cmnd->device == cmd->device)) {
if (tmp_evt->cmnd)
@ -1729,7 +1729,7 @@ static int ibmvscsi_eh_device_reset_handler(struct scsi_cmnd *cmd)
tmp_evt->done(tmp_evt);
}
}
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
return SUCCESS;
}
@ -1855,10 +1855,10 @@ static void ibmvscsi_handle_crq(struct viosrp_crq *crq,
* Lock the host_lock before messing with these structures, since we
* are running in a task context
*/
spin_lock_irqsave(evt_struct->hostdata->host->host_lock, flags);
spin_lock_irqsave(&evt_struct->hostdata->host->host_lock, flags);
list_del(&evt_struct->list);
free_event_struct(&evt_struct->hostdata->pool, evt_struct);
spin_unlock_irqrestore(evt_struct->hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&evt_struct->hostdata->host->host_lock, flags);
}
/**
@ -1876,12 +1876,12 @@ static int ibmvscsi_sdev_configure(struct scsi_device *sdev,
struct Scsi_Host *shost = sdev->host;
unsigned long lock_flags = 0;
spin_lock_irqsave(shost->host_lock, lock_flags);
spin_lock_irqsave(&shost->host_lock, lock_flags);
if (sdev->type == TYPE_DISK) {
sdev->allow_restart = 1;
blk_queue_rq_timeout(sdev->request_queue, 120 * HZ);
}
spin_unlock_irqrestore(shost->host_lock, lock_flags);
spin_unlock_irqrestore(&shost->host_lock, lock_flags);
return 0;
}
@ -2131,35 +2131,35 @@ static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
int rc;
char *action = "reset";
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
switch (hostdata->action) {
case IBMVSCSI_HOST_ACTION_UNBLOCK:
rc = 0;
break;
case IBMVSCSI_HOST_ACTION_RESET:
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
rc = ibmvscsi_reset_crq_queue(&hostdata->queue, hostdata);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
if (!rc)
rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
vio_enable_interrupts(to_vio_dev(hostdata->dev));
break;
case IBMVSCSI_HOST_ACTION_REENABLE:
action = "enable";
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
rc = ibmvscsi_reenable_crq_queue(&hostdata->queue, hostdata);
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
if (!rc)
rc = ibmvscsi_send_crq(hostdata, 0xC001000000000000LL, 0);
break;
case IBMVSCSI_HOST_ACTION_NONE:
default:
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
return;
}
hostdata->action = IBMVSCSI_HOST_ACTION_NONE;
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
if (rc) {
ibmvscsi_set_request_limit(hostdata, -1);
@ -2191,9 +2191,9 @@ static int ibmvscsi_work_to_do(struct ibmvscsi_host_data *hostdata)
unsigned long flags;
int rc;
spin_lock_irqsave(hostdata->host->host_lock, flags);
spin_lock_irqsave(&hostdata->host->host_lock, flags);
rc = __ibmvscsi_work_to_do(hostdata);
spin_unlock_irqrestore(hostdata->host->host_lock, flags);
spin_unlock_irqrestore(&hostdata->host->host_lock, flags);
return rc;
}

5
drivers/scsi/ibmvscsi_tgt/ibmvscsi_tgt.c
View File

@ -3757,9 +3757,8 @@ static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd)
dev_err(&vscsi->dev, "srp_transfer_data failed: %d\n", rc);
se_cmd->scsi_sense_length = 18;
memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length);
/* Logical Unit Communication Time-out asc/ascq = 0x0801 */
scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
0x08, 0x01);
scsi_set_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR,
LU_COMMUNICATION_TIMEOUT);
}
srp_build_response(vscsi, cmd, &len);

4
drivers/scsi/imm.c
View File

@ -781,10 +781,10 @@ static void imm_interrupt(struct work_struct *work)
imm_pb_dismiss(dev);
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
dev->cur_cmd = NULL;
scsi_done(cmd);
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
return;
}

8
drivers/scsi/initio.c
View File

@ -2507,9 +2507,9 @@ static irqreturn_t i91u_intr(int irqno, void *dev_id)
unsigned long flags;
int r;
spin_lock_irqsave(dev->host_lock, flags);
spin_lock_irqsave(&dev->host_lock, flags);
r = initio_isr((struct initio_host *)dev->hostdata);
spin_unlock_irqrestore(dev->host_lock, flags);
spin_unlock_irqrestore(&dev->host_lock, flags);
if (r)
return IRQ_HANDLED;
else
@ -2635,9 +2635,9 @@ static int i91u_bus_reset(struct scsi_cmnd * cmnd)
host = (struct initio_host *) cmnd->device->host->hostdata;
spin_lock_irq(cmnd->device->host->host_lock);
spin_lock_irq(&cmnd->device->host->host_lock);
initio_reset_scsi(host, 0);
spin_unlock_irq(cmnd->device->host->host_lock);
spin_unlock_irq(&cmnd->device->host->host_lock);
return SUCCESS;
}

324
drivers/scsi/ipr.c
View File

File diff suppressed because it is too large Load Diff

26
drivers/scsi/ips.c
View File

@ -794,7 +794,7 @@ int ips_eh_abort(struct scsi_cmnd *SC)
if (!ha->active)
return (FAILED);
spin_lock(host->host_lock);
spin_lock(&host->host_lock);
/* See if the command is on the copp queue */
item = ha->copp_waitlist.head;
@ -815,7 +815,7 @@ int ips_eh_abort(struct scsi_cmnd *SC)
ret = (FAILED);
}
spin_unlock(host->host_lock);
spin_unlock(&host->host_lock);
return ret;
}
@ -999,9 +999,9 @@ static int ips_eh_reset(struct scsi_cmnd *SC)
{
int rc;
spin_lock_irq(SC->device->host->host_lock);
spin_lock_irq(&SC->device->host->host_lock);
rc = __ips_eh_reset(SC);
spin_unlock_irq(SC->device->host->host_lock);
spin_unlock_irq(&SC->device->host->host_lock);
return rc;
}
@ -1221,16 +1221,16 @@ do_ipsintr(int irq, void *dev_id)
return IRQ_HANDLED;
}
spin_lock(host->host_lock);
spin_lock(&host->host_lock);
if (!ha->active) {
spin_unlock(host->host_lock);
spin_unlock(&host->host_lock);
return IRQ_HANDLED;
}
irqstatus = (*ha->func.intr) (ha);
spin_unlock(host->host_lock);
spin_unlock(&host->host_lock);
/* start the next command */
ips_next(ha, IPS_INTR_ON);
@ -2524,7 +2524,7 @@ ips_next(ips_ha_t * ha, int intr)
* this command won't time out
*/
if (intr == IPS_INTR_ON)
spin_lock(host->host_lock);
spin_lock(&host->host_lock);
if ((ha->subsys->param[3] & 0x300000)
&& (ha->scb_activelist.count == 0)) {
@ -2548,14 +2548,14 @@ ips_next(ips_ha_t * ha, int intr)
item = ips_removeq_copp_head(&ha->copp_waitlist);
ha->num_ioctl++;
if (intr == IPS_INTR_ON)
spin_unlock(host->host_lock);
spin_unlock(&host->host_lock);
scb->scsi_cmd = item->scsi_cmd;
kfree(item);
ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
if (intr == IPS_INTR_ON)
spin_lock(host->host_lock);
spin_lock(&host->host_lock);
switch (ret) {
case IPS_FAILURE:
if (scb->scsi_cmd) {
@ -2625,7 +2625,7 @@ ips_next(ips_ha_t * ha, int intr)
SC = ips_removeq_wait(&ha->scb_waitlist, q);
if (intr == IPS_INTR_ON)
spin_unlock(host->host_lock); /* Unlock HA after command is taken off queue */
spin_unlock(&host->host_lock); /* Unlock HA after command is taken off queue */
SC->result = DID_OK;
SC->host_scribble = NULL;
@ -2682,7 +2682,7 @@ ips_next(ips_ha_t * ha, int intr)
scb->dcdb.transfer_length = 0;
}
if (intr == IPS_INTR_ON)
spin_lock(host->host_lock);
spin_lock(&host->host_lock);
ret = ips_send_cmd(ha, scb);
@ -2721,7 +2721,7 @@ ips_next(ips_ha_t * ha, int intr)
} /* end while */
if (intr == IPS_INTR_ON)
spin_unlock(host->host_lock);
spin_unlock(&host->host_lock);
}
/****************************************************************************/

7
drivers/scsi/leapraid/leapraid_func.h
View File

@ -113,7 +113,6 @@
#define DESC_FORMAT_THRESHOLD 0x72
#define SENSE_KEY_MASK 0x0F
#define SCSI_SENSE_RESPONSE_CODE_MASK 0x7F
#define ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED 0x5D
#define LEAPRAID_LARGE_DISK_THRESHOLD 0x200000UL
#define LEAPRAID_LARGE_DISK_HEADS 255
#define LEAPRAID_LARGE_DISK_SECTORS 63
@ -126,12 +125,6 @@
#define LEAPRAID_SCSI_HOST_SHIFT 16
#define LEAPRAID_SCSI_DRIVER_SHIFT 24
/* SCSI ASC/ASCQ definitions. */
#define LEAPRAID_SCSI_ASCQ_DEFAULT 0x00
#define LEAPRAID_SCSI_ASC_POWER_ON_RESET 0x29
#define LEAPRAID_SCSI_ASC_INVALID_CMD_CODE 0x20
#define LEAPRAID_SCSI_ASCQ_POWER_ON_RESET 0x07
/* VPD Page 0x89 (ATA Information). */
#define LEAPRAID_VPD_PAGE_ATA_INFO 0x89
#define LEAPRAID_VPD_PG89_MAX_LEN 255

15
drivers/scsi/leapraid/leapraid_os.c
View File

@ -382,9 +382,8 @@ static void leapraid_handle_data_underrun(
} else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
scsiio_rep->scsi_state = LEAPRAID_SCSI_STATE_AUTOSENSE_VALID;
scsiio_rep->scsi_status = SAM_STAT_CHECK_CONDITION;
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
LEAPRAID_SCSI_ASC_INVALID_CMD_CODE,
LEAPRAID_SCSI_ASCQ_DEFAULT);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
}
}
@ -515,8 +514,9 @@ static void leapraid_scsiio_done_dispatch(
&sshdr))
dev_warn(&adapter->pdev->dev,
"Sense: key=0x%x asc=0x%x ascq=0x%x\n",
sshdr.sense_key, sshdr.asc,
sshdr.ascq);
sshdr.sense_key,
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
else
dev_warn(&adapter->pdev->dev,
"Sense: Invalid sense data\n");
@ -810,9 +810,8 @@ static bool leapraid_should_queuecommand(struct leapraid_adapter *adapter,
if (sdev_priv->block &&
scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION,
LEAPRAID_SCSI_ASC_POWER_ON_RESET,
LEAPRAID_SCSI_ASCQ_POWER_ON_RESET);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
goto scsiio_done;
}

8
drivers/scsi/libfc/fc_fcp.c
View File

@ -358,7 +358,7 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
unsigned long flags;
int can_queue;
spin_lock_irqsave(lport->host->host_lock, flags);
spin_lock_irqsave(&lport->host->host_lock, flags);
if (si->last_can_queue_ramp_up_time &&
(time_before(jiffies, si->last_can_queue_ramp_up_time +
@ -381,7 +381,7 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
"can_queue to %d.\n", can_queue);
unlock:
spin_unlock_irqrestore(lport->host->host_lock, flags);
spin_unlock_irqrestore(&lport->host->host_lock, flags);
}
/**
@ -401,7 +401,7 @@ static bool fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
int can_queue;
bool changed = false;
spin_lock_irqsave(lport->host->host_lock, flags);
spin_lock_irqsave(&lport->host->host_lock, flags);
if (si->last_can_queue_ramp_down_time &&
(time_before(jiffies, si->last_can_queue_ramp_down_time +
@ -418,7 +418,7 @@ static bool fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
changed = true;
unlock:
spin_unlock_irqrestore(lport->host->host_lock, flags);
spin_unlock_irqrestore(&lport->host->host_lock, flags);
return changed;
}

3
drivers/scsi/libiscsi.c
View File

@ -892,7 +892,8 @@ static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
ascq = session->tt->check_protection(task, &sector);
if (ascq) {
scsi_build_sense(sc, 1, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(sc, 1, ILLEGAL_REQUEST,
scsi_sense_code(ASC_ID_CRC_OR_ECC_ERROR, ascq));
scsi_set_sense_information(sc->sense_buffer,
SCSI_SENSE_BUFFERSIZE,
sector);

10
drivers/scsi/libsas/sas_scsi_host.c
View File

@ -436,13 +436,13 @@ int sas_eh_abort_handler(struct scsi_cmnd *cmd)
if (!i->dft->lldd_abort_task)
return FAILED;
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
/* We cannot do async aborts for SATA devices */
if (dev_is_sata(dev) && !host->host_eh_scheduled) {
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
return FAILED;
}
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
if (task)
res = i->dft->lldd_abort_task(task);
@ -714,9 +714,9 @@ void sas_scsi_recover_host(struct Scsi_Host *shost)
retry:
tries++;
retry = true;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
list_splice_init(&shost->eh_cmd_q, &eh_work_q);
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
pr_notice("Enter %s busy: %d failed: %d\n",
__func__, scsi_host_busy(shost), shost->host_failed);

30
drivers/scsi/lpfc/lpfc_els.c
View File

@ -7917,15 +7917,15 @@ lpfc_els_flush_rscn(struct lpfc_vport *vport)
struct lpfc_hba *phba = vport->phba;
int i;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (vport->fc_rscn_flush) {
/* Another thread is walking fc_rscn_id_list on this vport */
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return;
}
/* Indicate we are walking lpfc_els_flush_rscn on this vport */
vport->fc_rscn_flush = 1;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
lpfc_in_buf_free(phba, vport->fc_rscn_id_list[i]);
@ -7933,9 +7933,9 @@ lpfc_els_flush_rscn(struct lpfc_vport *vport)
}
clear_bit(FC_RSCN_MODE, &vport->fc_flag);
clear_bit(FC_RSCN_DISCOVERY, &vport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->fc_rscn_id_cnt = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
lpfc_can_disctmo(vport);
/* Indicate we are done walking this fc_rscn_id_list */
vport->fc_rscn_flush = 0;
@ -7972,15 +7972,15 @@ lpfc_rscn_payload_check(struct lpfc_vport *vport, uint32_t did)
if (test_bit(FC_RSCN_DISCOVERY, &vport->fc_flag))
return did;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (vport->fc_rscn_flush) {
/* Another thread is walking fc_rscn_id_list on this vport */
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return 0;
}
/* Indicate we are walking fc_rscn_id_list on this vport */
vport->fc_rscn_flush = 1;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
for (i = 0; i < vport->fc_rscn_id_cnt; i++) {
lp = vport->fc_rscn_id_list[i]->virt;
payload_len = be32_to_cpu(*lp++ & ~ELS_CMD_MASK);
@ -8234,10 +8234,10 @@ lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
}
}
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (vport->fc_rscn_flush) {
/* Another thread is walking fc_rscn_id_list on this vport */
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_RSCN_DISCOVERY, &vport->fc_flag);
/* Send back ACC */
lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
@ -8245,7 +8245,7 @@ lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
}
/* Indicate we are walking fc_rscn_id_list on this vport */
vport->fc_rscn_flush = 1;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
/* Get the array count after successfully have the token */
rscn_cnt = vport->fc_rscn_id_cnt;
/* If we are already processing an RSCN, save the received
@ -8538,14 +8538,14 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
* The vport state should go to LPFC_FLOGI only
* AFTER we issue a FLOGI, not receive one.
*/
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
fc_flag = vport->fc_flag;
port_state = vport->port_state;
/* Acking an unsol FLOGI. Count 1 for link bounce
* work-around.
*/
vport->rcv_flogi_cnt++;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_PT2PT, &vport->fc_flag);
clear_bit(FC_FABRIC, &vport->fc_flag);
clear_bit(FC_PUBLIC_LOOP, &vport->fc_flag);
@ -11190,9 +11190,9 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
break;
}
} else {
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->vpi_state |= LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
if (vport == phba->pport) {
if (phba->sli_rev < LPFC_SLI_REV4)
lpfc_issue_fabric_reglogin(vport);

44
drivers/scsi/lpfc/lpfc_hbadisc.c
View File

@ -1340,9 +1340,9 @@ lpfc_linkdown(struct lpfc_hba *phba)
}
clear_bit(FC_PT2PT, &phba->pport->fc_flag);
clear_bit(FC_PT2PT_PLOGI, &phba->pport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
phba->pport->rcv_flogi_cnt = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
}
return 0;
}
@ -1406,9 +1406,9 @@ lpfc_linkup_port(struct lpfc_vport *vport)
}
set_bit(FC_NDISC_ACTIVE, &vport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->fc_ns_retry = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
lpfc_setup_fdmi_mask(vport);
lpfc_linkup_cleanup_nodes(vport);
@ -1437,9 +1437,9 @@ lpfc_linkup(struct lpfc_hba *phba)
* absorbed without an ACQE. No lock here - in worker thread
* and discovery is synchronized.
*/
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
phba->pport->rcv_flogi_cnt = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return 0;
}
@ -3400,9 +3400,9 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
set_bit(FC_VFI_REGISTERED, &vport->fc_flag);
clear_bit(FC_VPORT_NEEDS_REG_VPI, &vport->fc_flag);
clear_bit(FC_VPORT_NEEDS_INIT_VPI, &vport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->vpi_state |= LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
/* In case SLI4 FC loopback test, we are ready */
if ((phba->sli_rev == LPFC_SLI_REV4) &&
@ -3943,9 +3943,9 @@ lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
}
set_bit(FC_VPORT_NEEDS_REG_VPI, &vport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->vpi_state &= ~LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
mempool_free(pmb, phba->mbox_mem_pool);
lpfc_cleanup_vports_rrqs(vport, NULL);
/*
@ -4010,9 +4010,9 @@ lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
}
clear_bit(FC_VPORT_NEEDS_REG_VPI, &vport->fc_flag);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->vpi_state |= LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
vport->num_disc_nodes = 0;
/* go thru NPR list and issue ELS PLOGIs */
if (atomic_read(&vport->fc_npr_cnt))
@ -5620,9 +5620,9 @@ lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did)
struct lpfc_nodelist *ndlp;
unsigned long iflags;
spin_lock_irqsave(shost->host_lock, iflags);
spin_lock_irqsave(&shost->host_lock, iflags);
ndlp = __lpfc_findnode_did(vport, did);
spin_unlock_irqrestore(shost->host_lock, iflags);
spin_unlock_irqrestore(&shost->host_lock, iflags);
return ndlp;
}
@ -6426,9 +6426,9 @@ lpfc_findnode_wwpn(struct lpfc_vport *vport, struct lpfc_name *wwpn)
struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
struct lpfc_nodelist *ndlp;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
ndlp = __lpfc_find_node(vport, lpfc_filter_by_wwpn, wwpn);
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return ndlp;
}
@ -6444,9 +6444,9 @@ lpfc_findnode_rpi(struct lpfc_vport *vport, uint16_t rpi)
struct lpfc_nodelist *ndlp;
unsigned long flags;
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
ndlp = __lpfc_findnode_rpi(vport, rpi);
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
return ndlp;
}
@ -6786,9 +6786,9 @@ lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
lpfc_sli4_unreg_all_rpis(vports[i]);
lpfc_mbx_unreg_vpi(vports[i]);
shost = lpfc_shost_from_vport(vports[i]);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_VPORT_NEEDS_INIT_VPI, &vports[i]->fc_flag);
}
lpfc_destroy_vport_work_array(phba, vports);
@ -6801,9 +6801,9 @@ lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
lpfc_sli4_unreg_all_rpis(phba->pport);
lpfc_mbx_unreg_vpi(phba->pport);
shost = lpfc_shost_from_vport(phba->pport);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
phba->pport->vpi_state &= ~LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_VPORT_NEEDS_INIT_VPI, &phba->pport->fc_flag);
}

16
drivers/scsi/lpfc/lpfc_init.c
View File

@ -3833,9 +3833,9 @@ lpfc_offline_prep(struct lpfc_hba *phba, int mbx_action)
if (test_bit(FC_UNLOADING, &vports[i]->load_flag))
continue;
shost = lpfc_shost_from_vport(vports[i]);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_VPORT_NEEDS_REG_VPI, &vports[i]->fc_flag);
clear_bit(FC_VFI_REGISTERED, &vports[i]->fc_flag);
@ -3926,9 +3926,9 @@ lpfc_offline(struct lpfc_hba *phba)
if (vports != NULL)
for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
shost = lpfc_shost_from_vport(vports[i]);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vports[i]->work_port_events = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
set_bit(FC_OFFLINE_MODE, &vports[i]->fc_flag);
}
lpfc_destroy_vport_work_array(phba, vports);
@ -4930,7 +4930,7 @@ int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
struct lpfc_hba *phba = vport->phba;
int stat = 0;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (test_bit(FC_UNLOADING, &vport->load_flag)) {
stat = 1;
@ -4965,7 +4965,7 @@ int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
stat = 1;
finished:
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return stat;
}
@ -9226,9 +9226,9 @@ lpfc_post_init_setup(struct lpfc_hba *phba)
lpfc_host_attrib_init(shost);
if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
lpfc_poll_start_timer(phba);
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
}
lpfc_printf_log(phba, KERN_INFO, LOG_INIT,

26
drivers/scsi/lpfc/lpfc_scsi.c
View File

@ -2848,7 +2848,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
}
out:
if (err_type == BGS_GUARD_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2857,7 +2858,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
sum, guard_tag);
} else if (err_type == BGS_REFTAG_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
@ -2867,7 +2869,8 @@ lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
ref_tag, start_ref_tag);
} else if (err_type == BGS_APPTAG_ERR_MASK) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
@ -2970,7 +2973,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_guard_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_guard_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2983,7 +2987,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_reftag_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_reftag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -2996,7 +3001,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd,
if (lpfc_bgs_get_apptag_err(bgstat)) {
ret = 1;
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
phba->bg_apptag_err_cnt++;
lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
@ -4272,7 +4278,7 @@ lpfc_fcp_io_cmd_wqe_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pwqeIn,
if (vport->cfg_max_scsicmpl_time &&
time_after(jiffies, lpfc_cmd->start_time +
msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (ndlp) {
if (ndlp->cmd_qdepth >
atomic_read(&ndlp->cmd_pending) &&
@ -4285,7 +4291,7 @@ lpfc_fcp_io_cmd_wqe_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pwqeIn,
ndlp->last_change_time = jiffies;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
}
lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);
@ -4552,7 +4558,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
if (vport->cfg_max_scsicmpl_time &&
time_after(jiffies, lpfc_cmd->start_time +
msecs_to_jiffies(vport->cfg_max_scsicmpl_time))) {
spin_lock_irqsave(shost->host_lock, flags);
spin_lock_irqsave(&shost->host_lock, flags);
if (pnode) {
if (pnode->cmd_qdepth >
atomic_read(&pnode->cmd_pending) &&
@ -4565,7 +4571,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
pnode->last_change_time = jiffies;
}
spin_unlock_irqrestore(shost->host_lock, flags);
spin_unlock_irqrestore(&shost->host_lock, flags);
}
lpfc_scsi_unprep_dma_buf(phba, lpfc_cmd);

4
drivers/scsi/lpfc/lpfc_sli.c
View File

@ -2886,9 +2886,9 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
!test_bit(FC_UNLOADING, &phba->pport->load_flag) &&
!pmb->u.mb.mbxStatus) {
shost = lpfc_shost_from_vport(vport);
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
vport->vpi_state |= LPFC_VPI_REGISTERED;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
clear_bit(FC_VPORT_NEEDS_REG_VPI, &vport->fc_flag);
}

8
drivers/scsi/mac53c94.c
View File

@ -107,7 +107,7 @@ static int mac53c94_host_reset(struct scsi_cmnd *cmd)
struct dbdma_regs __iomem *dma = state->dma;
unsigned long flags;
spin_lock_irqsave(cmd->device->host->host_lock, flags);
spin_lock_irqsave(&cmd->device->host->host_lock, flags);
writel((RUN|PAUSE|FLUSH|WAKE) << 16, &dma->control);
writeb(CMD_SCSI_RESET, &regs->command); /* assert RST */
@ -117,7 +117,7 @@ static int mac53c94_host_reset(struct scsi_cmnd *cmd)
mac53c94_init(state);
writeb(CMD_NOP, &regs->command);
spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
spin_unlock_irqrestore(&cmd->device->host->host_lock, flags);
return SUCCESS;
}
@ -182,9 +182,9 @@ static irqreturn_t do_mac53c94_interrupt(int irq, void *dev_id)
unsigned long flags;
struct Scsi_Host *dev = ((struct fsc_state *) dev_id)->current_req->device->host;
spin_lock_irqsave(dev->host_lock, flags);
spin_lock_irqsave(&dev->host_lock, flags);
mac53c94_interrupt(irq, dev_id);
spin_unlock_irqrestore(dev->host_lock, flags);
spin_unlock_irqrestore(&dev->host_lock, flags);
return IRQ_HANDLED;
}

8
drivers/scsi/megaraid.c
View File

@ -1592,9 +1592,11 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
epthru->reqsensearea, 14);
cmd->result = SAM_STAT_CHECK_CONDITION;
} else
scsi_build_sense(cmd, 0,
ABORTED_COMMAND, 0, 0);
} else {
scsi_set_sense(cmd, 0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
}
break;

2
drivers/scsi/megaraid/mega_common.h
View File

@ -37,8 +37,6 @@
#define PCI_CONF_AMISIG64 0xa4
#define MEGA_SCSI_INQ_EVPD 1
#define MEGA_INVALID_FIELD_IN_CDB 0x24
/**
* scb_t - scsi command control block

12
drivers/scsi/megaraid/megaraid_mbox.c
View File

@ -1577,8 +1577,8 @@ megaraid_mbox_build_cmd(adapter_t *adapter, struct scsi_cmnd *scp,
}
if (scp->cmnd[1] & MEGA_SCSI_INQ_EVPD) {
scsi_build_sense(scp, 0, ILLEGAL_REQUEST,
MEGA_INVALID_FIELD_IN_CDB, 0);
scsi_set_sense(scp, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
return NULL;
}
@ -2311,9 +2311,11 @@ megaraid_mbox_dpc(unsigned long devp)
epthru->reqsensearea, 14);
scp->result = SAM_STAT_CHECK_CONDITION;
} else
scsi_build_sense(scp, 0,
ABORTED_COMMAND, 0, 0);
} else {
scsi_set_sense(scp, 0,
ABORTED_COMMAND,
NO_ADDITIONAL_SENSE_INFORMATION);
}
}
break;

18
drivers/scsi/megaraid/megaraid_sas_base.c
View File

@ -2274,11 +2274,11 @@ megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
&& atomic_read(&instance->fw_outstanding) <
instance->throttlequeuedepth + 1) {
spin_lock_irqsave(instance->host->host_lock, flags);
spin_lock_irqsave(&instance->host->host_lock, flags);
instance->flag &= ~MEGASAS_FW_BUSY;
instance->host->can_queue = instance->cur_can_queue;
spin_unlock_irqrestore(instance->host->host_lock, flags);
spin_unlock_irqrestore(&instance->host->host_lock, flags);
}
}
@ -2955,13 +2955,13 @@ static enum scsi_timeout_action megasas_reset_timer(struct scsi_cmnd *scmd)
instance = (struct megasas_instance *)scmd->device->host->hostdata;
if (!(instance->flag & MEGASAS_FW_BUSY)) {
/* FW is busy, throttle IO */
spin_lock_irqsave(instance->host->host_lock, flags);
spin_lock_irqsave(&instance->host->host_lock, flags);
instance->host->can_queue = instance->throttlequeuedepth;
instance->last_time = jiffies;
instance->flag |= MEGASAS_FW_BUSY;
spin_unlock_irqrestore(instance->host->host_lock, flags);
spin_unlock_irqrestore(&instance->host->host_lock, flags);
}
return SCSI_EH_RESET_TIMER;
}
@ -3727,7 +3727,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
&& (cmd->frame->dcmd.mbox.b[1] == 1)) {
fusion->fast_path_io = 0;
spin_lock_irqsave(instance->host->host_lock, flags);
spin_lock_irqsave(&instance->host->host_lock, flags);
status = cmd->frame->hdr.cmd_status;
instance->map_update_cmd = NULL;
if (status != MFI_STAT_OK) {
@ -3737,7 +3737,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
else {
megasas_return_cmd(instance, cmd);
spin_unlock_irqrestore(
instance->host->host_lock,
&instance->host->host_lock,
flags);
break;
}
@ -3762,7 +3762,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
megasas_set_ld_removed_by_fw(instance);
megasas_sync_map_info(instance);
spin_unlock_irqrestore(instance->host->host_lock,
spin_unlock_irqrestore(&instance->host->host_lock,
flags);
break;
@ -3778,7 +3778,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
if ((opcode == MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&
(cmd->frame->dcmd.mbox.b[0] == 1)) {
spin_lock_irqsave(instance->host->host_lock, flags);
spin_lock_irqsave(&instance->host->host_lock, flags);
status = cmd->frame->hdr.cmd_status;
instance->jbod_seq_cmd = NULL;
megasas_return_cmd(instance, cmd);
@ -3791,7 +3791,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
} else
instance->use_seqnum_jbod_fp = false;
spin_unlock_irqrestore(instance->host->host_lock, flags);
spin_unlock_irqrestore(&instance->host->host_lock, flags);
break;
}

24
drivers/scsi/mesh.c
View File

@ -1016,9 +1016,9 @@ static irqreturn_t do_mesh_interrupt(int irq, void *dev_id)
struct mesh_state *ms = dev_id;
struct Scsi_Host *dev = ms->host;
spin_lock_irqsave(dev->host_lock, flags);
spin_lock_irqsave(&dev->host_lock, flags);
mesh_interrupt(ms);
spin_unlock_irqrestore(dev->host_lock, flags);
spin_unlock_irqrestore(&dev->host_lock, flags);
return IRQ_HANDLED;
}
@ -1708,7 +1708,7 @@ static int mesh_host_reset(struct scsi_cmnd *cmd)
printk(KERN_DEBUG "mesh_host_reset\n");
spin_lock_irqsave(ms->host->host_lock, flags);
spin_lock_irqsave(&ms->host->host_lock, flags);
if (ms->dma_started)
halt_dma(ms);
@ -1734,7 +1734,7 @@ static int mesh_host_reset(struct scsi_cmnd *cmd)
/* Complete pending commands */
handle_reset(ms);
spin_unlock_irqrestore(ms->host->host_lock, flags);
spin_unlock_irqrestore(&ms->host->host_lock, flags);
return SUCCESS;
}
@ -1771,14 +1771,14 @@ static int mesh_suspend(struct macio_dev *mdev, pm_message_t mesg)
return 0;
scsi_block_requests(ms->host);
spin_lock_irqsave(ms->host->host_lock, flags);
spin_lock_irqsave(&ms->host->host_lock, flags);
while(ms->phase != idle) {
spin_unlock_irqrestore(ms->host->host_lock, flags);
spin_unlock_irqrestore(&ms->host->host_lock, flags);
msleep(10);
spin_lock_irqsave(ms->host->host_lock, flags);
spin_lock_irqsave(&ms->host->host_lock, flags);
}
ms->phase = sleeping;
spin_unlock_irqrestore(ms->host->host_lock, flags);
spin_unlock_irqrestore(&ms->host->host_lock, flags);
disable_irq(ms->meshintr);
set_mesh_power(ms, 0);
@ -1795,9 +1795,9 @@ static int mesh_resume(struct macio_dev *mdev)
set_mesh_power(ms, 1);
mesh_init(ms);
spin_lock_irqsave(ms->host->host_lock, flags);
spin_lock_irqsave(&ms->host->host_lock, flags);
mesh_start(ms);
spin_unlock_irqrestore(ms->host->host_lock, flags);
spin_unlock_irqrestore(&ms->host->host_lock, flags);
enable_irq(ms->meshintr);
scsi_unblock_requests(ms->host);
@ -1818,7 +1818,7 @@ static int mesh_shutdown(struct macio_dev *mdev)
unsigned long flags;
printk(KERN_INFO "resetting MESH scsi bus(es)\n");
spin_lock_irqsave(ms->host->host_lock, flags);
spin_lock_irqsave(&ms->host->host_lock, flags);
mr = ms->mesh;
out_8(&mr->intr_mask, 0);
out_8(&mr->interrupt, INT_ERROR | INT_EXCEPTION | INT_CMDDONE);
@ -1826,7 +1826,7 @@ static int mesh_shutdown(struct macio_dev *mdev)
mesh_flush_io(mr);
udelay(30);
out_8(&mr->bus_status1, 0);
spin_unlock_irqrestore(ms->host->host_lock, flags);
spin_unlock_irqrestore(&ms->host->host_lock, flags);
return 0;
}

77
drivers/scsi/mpi3mr/mpi/mpi30_cnfg.h
View File

@ -72,6 +72,12 @@
#define MPI3_SECURITY_PGAD_SLOT_GROUP_SHIFT (8)
#define MPI3_SECURITY_PGAD_SLOT_MASK (0x000000ff)
#define MPI3_INSTANCE_PGAD_INSTANCE_MASK (0x0000ffff)
#define MPI3_INSTANCE_PGAD_INSTANCE_SHIFT (0)
#define MPI3_INTERFACE_PGAD_INTERFACE_MASK (0x0000000f)
#define MPI3_INTERFACE_PGAD_INTERFACE_SHIFT (0)
#define MPI3_INTERFACE_PGAD_INTERFACE_MPI (0)
#define MPI3_INTERFACE_PGAD_INTERFACE_NVME_VD (1)
#define MPI3_INTERFACE_PGAD_INTERFACE_NVME_PD (2)
struct mpi3_config_request {
__le16 host_tag;
u8 ioc_use_only02;
@ -492,10 +498,31 @@ struct mpi3_man10_istwi_ctrlr_entry {
};
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_MASK (0x000c)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_100K (0x0000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_400K (0x0004)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_100_KHZ (0x0000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_400_KHZ (0x0004)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_TARGET_ENABLED (0x0002)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_INITIATOR_ENABLED (0x0001)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_MASK (0xc000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_SHIFT (14)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_50_NS (0x0000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_10_NS (0x4000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_5_NS (0x8000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I2C_GLITCH_FLTR_0_NS (0xc000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_TYPE_MASK (0x3000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_TYPE_SHIFT (12)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_TYPE_I2C (0x0000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_TYPE_I3C (0x1000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_TYPE_AUTO (0x2000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_MASK (0x0e00)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_SHIFT (9)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_12_5_MHZ (0x0000)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_8_MHZ (0x0200)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_6_MHZ (0x0400)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_4_MHZ (0x0600)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_I3C_MAX_DATA_RATE_2_MHZ (0x0800)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_MASK (0x000c)
#define MPI3_MAN10_ISTWI_CTRLR_FLAGS_BUS_SPEED_SHIFT (0)
#ifndef MPI3_MAN10_ISTWI_CTRLR_MAX
#define MPI3_MAN10_ISTWI_CTRLR_MAX (1)
#endif
@ -1027,6 +1054,16 @@ struct mpi3_io_unit_page5 {
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SWITCH_ATTACHED (0x02)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_DIRECT_AND_EXPANDER (0x03)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_DIRECT_AND_SWITCH (0x03)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_HDD_SPINDOWN_MASK (0xc000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_HDD_SPINDOWN_NONE (0x0000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_HDD_SPINDOWN_ALL (0x4000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_HDD_SPINDOWN_FILTERED (0x8000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_HDD_SPINDOWN_RESERVED (0xc000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SYNC_CACHE_MASK (0x3000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SYNC_CACHE_ALL (0x0000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SYNC_CACHE_FILTERED (0x1000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SYNC_CACHE_NONE (0x2000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SYNC_CACHE_RESERVED (0x3000)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SATA_HDD_MASK (0x0300)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SATA_HDD_SHIFT (8)
#define MPI3_IOUNIT5_DEVICE_SHUTDOWN_SAS_HDD_MASK (0x00c0)
@ -1069,7 +1106,8 @@ struct mpi3_io_unit_page8 {
struct mpi3_config_page_header header;
u8 sb_mode;
u8 sb_state;
__le16 reserved0a;
u8 flags;
u8 reserved0b;
u8 num_slots;
u8 slots_available;
u8 current_key_encryption_algo;
@ -1088,6 +1126,8 @@ struct mpi3_io_unit_page8 {
#define MPI3_IOUNIT8_SBSTATE_SVN_UPDATE_PENDING (0x04)
#define MPI3_IOUNIT8_SBSTATE_KEY_UPDATE_PENDING (0x02)
#define MPI3_IOUNIT8_SBSTATE_SECURE_BOOT_ENABLED (0x01)
#define MPI3_IOUNIT8_FLAGS_FWQR_CAPABLE (0x80)
#define MPI3_IOUNIT8_FLAGS_FWQR_SECURED (0x40)
#define MPI3_IOUNIT8_SBMODE_CURRENT_KEY_IOUNIT17 (0x10)
#define MPI3_IOUNIT8_SBMODE_HARD_SECURE_RECERTIFIED (0x08)
struct mpi3_io_unit_page9 {
@ -1174,10 +1214,16 @@ struct mpi3_io_unit_page12 {
#define MPI3_IOUNIT12_FLAGS_NUMPASSES_32 (0x00000200)
#define MPI3_IOUNIT12_FLAGS_NUMPASSES_64 (0x00000300)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_MASK (0x00000003)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_SHIFT (0)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_DISABLED (0x00000000)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_500US (0x00000001)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_1MS (0x00000002)
#define MPI3_IOUNIT12_FLAGS_PASSPERIOD_2MS (0x00000003)
#define MPI3_IOUNIT12_FLAGS_INTERFACE_MASK (0x0000000c)
#define MPI3_IOUNIT12_FLAGS_INTERFACE_SHIFT (2)
#define MPI3_IOUNIT12_FLAGS_INTERFACE_MPI (0x00000000)
#define MPI3_IOUNIT12_FLAGS_INTERFACE_NVME_VD (0x00000004)
#define MPI3_IOUNIT12_FLAGS_INTERFACE_NVME_PD (0x00000008)
#ifndef MPI3_IOUNIT13_FUNC_MAX
#define MPI3_IOUNIT13_FUNC_MAX (1)
#endif
@ -1238,6 +1284,7 @@ struct mpi3_io_unit_page15 {
#define MPI3_IOUNIT15_PAGEVERSION (0x00)
#define MPI3_IOUNIT15_FLAGS_EPRINIT_INITREQUIRED (0x04)
#define MPI3_IOUNIT15_FLAGS_EPRSUPPORT_MASK (0x03)
#define MPI3_IOUNIT15_FLAGS_EPRSUPPORT_SHIFT (0)
#define MPI3_IOUNIT15_FLAGS_EPRSUPPORT_NOT_SUPPORTED (0x00)
#define MPI3_IOUNIT15_FLAGS_EPRSUPPORT_WITHOUT_POWER_BRAKE_GPIO (0x01)
#define MPI3_IOUNIT15_FLAGS_EPRSUPPORT_WITH_POWER_BRAKE_GPIO (0x02)
@ -1255,6 +1302,9 @@ struct mpi3_io_unit_page17 {
__le32 current_key[];
};
#define MPI3_IOUNIT17_PAGEVERSION (0x00)
#define MPI3_IOUNIT17_FLAGS_KEYROOT_MASK (0x01)
#define MPI3_IOUNIT17_FLAGS_KEYROOT_HW (0x00)
#define MPI3_IOUNIT17_FLAGS_KEYROOT_FW (0x01)
struct mpi3_io_unit_page18 {
struct mpi3_config_page_header header;
u8 flags;
@ -1640,11 +1690,28 @@ struct mpi3_security_page3 {
};
#define MPI3_SECURITY3_PAGEVERSION (0x00)
#define MPI3_SECURITY3_FLAGS_TYPE_MASK (0x0f)
#define MPI3_SECURITY3_FLAGS_TYPE_MASK (0x1f)
#define MPI3_SECURITY3_FLAGS_TYPE_SHIFT (0)
#define MPI3_SECURITY3_FLAGS_TYPE_NOT_VALID (0)
#define MPI3_SECURITY3_FLAGS_TYPE_MLDSA_PRIVATE (1)
#define MPI3_SECURITY3_FLAGS_TYPE_MLDSA_PUBLIC (2)
union mpi3_security_digest {
__le32 dword[16];
__le16 word[32];
u8 byte[64];
};
struct mpi3_security_page4 {
struct mpi3_config_page_header header;
__le32 reserved08[2];
union mpi3_security_mac mac;
union mpi3_security_nonce nonce;
u8 num_digests;
u8 hash_algorithm;
__le16 reserved92;
__le32 reserved94[3];
union mpi3_security_digest digest[];
};
#define MPI3_SECURITY4_PAGEVERSION (0x00)
struct mpi3_security_page10 {
struct mpi3_config_page_header header;
__le32 reserved08[2];
@ -2074,7 +2141,7 @@ struct mpi3_sas_phy3_phy_event_config {
#define MPI3_SASPHY3_EVENT_CODE_LCCONN_TIME (0xd5)
#define MPI3_SASPHY3_EVENT_CODE_SSP_TX_START_TRANSMIT (0xd6)
#define MPI3_SASPHY3_EVENT_CODE_SATA_TX_START (0xd7)
#define MPI3_SASPHY3_EVENT_CODE_SMP_TX_START_TRANSMT (0xd8)
#define MPI3_SASPHY3_EVENT_CODE_SMP_TX_START_TRANSMIT (0xd8)
#define MPI3_SASPHY3_EVENT_CODE_TX_SMP_BREAK_CONN (0xd9)
#define MPI3_SASPHY3_EVENT_CODE_SSP_RX_START_RECEIVE (0xda)
#define MPI3_SASPHY3_EVENT_CODE_SATA_RX_START_RECEIVE (0xdb)

7
drivers/scsi/mpi3mr/mpi/mpi30_image.h
View File

@ -18,7 +18,7 @@ struct mpi3_hash_exclusion_format {
__le32 size;
};
#define MPI3_IMAGE_HASH_EXCUSION_NUM (4)
#define MPI3_IMAGE_HASH_EXCLUSION_NUM (4)
struct mpi3_component_image_header {
__le32 signature0;
__le32 load_address;
@ -42,7 +42,7 @@ struct mpi3_component_image_header {
union mpi3_version_union rmc_interface_version;
union mpi3_version_union etp_interface_version;
struct mpi3_comp_image_version component_image_version;
struct mpi3_hash_exclusion_format hash_exclusion[MPI3_IMAGE_HASH_EXCUSION_NUM];
struct mpi3_hash_exclusion_format hash_exclusion[MPI3_IMAGE_HASH_EXCLUSION_NUM];
__le32 next_image_header_offset;
union mpi3_version_union security_version;
__le32 reserved84[31];
@ -347,7 +347,8 @@ struct mpi3_encrypted_hash_entry {
struct mpi3_encrypted_hash_data {
u8 image_version;
u8 num_hash;
__le16 reserved02;
u8 fw_num_hash;
u8 reserved03;
__le32 reserved04;
struct mpi3_encrypted_hash_entry encrypted_hash_entry[MPI3_ENCRYPTED_HASH_ENTRY_MAX];
};

15
drivers/scsi/mpi3mr/mpi/mpi30_ioc.h
View File

@ -428,10 +428,10 @@ struct mpi3_event_data_sas_discovery {
#define MPI3_EVENT_SAS_DISC_FLAGS_IN_PROGRESS (0x01)
#define MPI3_EVENT_SAS_DISC_RC_STARTED (0x01)
#define MPI3_EVENT_SAS_DISC_RC_COMPLETED (0x02)
#define MPI3_SAS_DISC_STATUS_MAX_ENCLOSURES_EXCEED (0x80000000)
#define MPI3_SAS_DISC_STATUS_MAX_EXPANDERS_EXCEED (0x40000000)
#define MPI3_SAS_DISC_STATUS_MAX_DEVICES_EXCEED (0x20000000)
#define MPI3_SAS_DISC_STATUS_MAX_TOPO_PHYS_EXCEED (0x10000000)
#define MPI3_SAS_DISC_STATUS_MAX_ENCLOSURES_EXCEEDED (0x80000000)
#define MPI3_SAS_DISC_STATUS_MAX_EXPANDERS_EXCEEDED (0x40000000)
#define MPI3_SAS_DISC_STATUS_MAX_DEVICES_EXCEEDED (0x20000000)
#define MPI3_SAS_DISC_STATUS_MAX_TOPO_PHYS_EXCEEDED (0x10000000)
#define MPI3_SAS_DISC_STATUS_INVALID_CEI (0x00010000)
#define MPI3_SAS_DISC_STATUS_FECEI_MISMATCH (0x00008000)
#define MPI3_SAS_DISC_STATUS_MULTIPLE_DEVICES_IN_SLOT (0x00004000)
@ -965,7 +965,7 @@ struct mpi3_ci_download_reply {
u8 flags;
u8 cache_dirty;
u8 pending_count;
u8 reserved13;
u8 additional_flags;
};
#define MPI3_CI_DOWNLOAD_FLAGS_DOWNLOAD_IN_PROGRESS (0x80)
@ -979,6 +979,11 @@ struct mpi3_ci_download_reply {
#define MPI3_CI_DOWNLOAD_FLAGS_ACTIVATION_STATUS_ONLINE_PENDING (0x04)
#define MPI3_CI_DOWNLOAD_FLAGS_ACTIVATION_STATUS_OFFLINE_PENDING (0x06)
#define MPI3_CI_DOWNLOAD_FLAGS_COMPATIBLE (0x01)
#define MPI3_CI_DOWNLOAD_ADDITIONALFLAGS_REDUNDANCYRESTORATION_MASK (0x03)
#define MPI3_CI_DOWNLOAD_ADDITIONALFLAGS_REDUNDANCYRESTORATION_SHIFT (0)
#define MPI3_CI_DOWNLOAD_ADDITIONALFLAGS_REDUNDANCYRESTORATION_NONE (0x00)
#define MPI3_CI_DOWNLOAD_ADDITIONALFLAGS_REDUNDANCYRESTORATION_PRIMARY (0x01)
#define MPI3_CI_DOWNLOAD_ADDITIONALFLAGS_REDUNDANCYRESTORATION_SECONDARY (0x02)
struct mpi3_ci_upload_request {
__le16 host_tag;
u8 ioc_use_only02;

2
drivers/scsi/mpi3mr/mpi/mpi30_transport.h
View File

@ -18,7 +18,7 @@ union mpi3_version_union {
#define MPI3_VERSION_MAJOR (3)
#define MPI3_VERSION_MINOR (0)
#define MPI3_VERSION_UNIT (39)
#define MPI3_VERSION_UNIT (41)
#define MPI3_VERSION_DEV (0)
#define MPI3_DEVHANDLE_INVALID (0xffff)
struct mpi3_sysif_oper_queue_indexes {

13
drivers/scsi/mpi3mr/mpi3mr.h
View File

@ -56,8 +56,8 @@ extern struct list_head mrioc_list;
extern int prot_mask;
extern atomic64_t event_counter;
#define MPI3MR_DRIVER_VERSION "8.17.0.3.50"
#define MPI3MR_DRIVER_RELDATE "09-January-2026"
#define MPI3MR_DRIVER_VERSION "8.18.0.8.50"
#define MPI3MR_DRIVER_RELDATE "26-June-2026"
#define MPI3MR_DRIVER_NAME "mpi3mr"
#define MPI3MR_DRIVER_LICENSE "GPL"
@ -125,6 +125,7 @@ extern atomic64_t event_counter;
#define MPI3MR_RESETTM_TIMEOUT 60
#define MPI3MR_RESET_HOST_IOWAIT_TIMEOUT 5
#define MPI3MR_TSUPDATE_INTERVAL 900
#define MPI3MR_EARLY_TSUPDATE_SECONDS 60
#define MPI3MR_DEFAULT_SHUTDOWN_TIME 120
#define MPI3MR_RAID_ERRREC_RESET_TIMEOUT 180
#define MPI3MR_PREPARE_FOR_RESET_TIMEOUT 180
@ -168,6 +169,7 @@ extern atomic64_t event_counter;
#define MPI3MR_DEFAULT_MDTS (128 * 1024)
#define MPI3MR_DEFAULT_PGSZEXP (12)
#define MPI3MR_MAX_PGSZEXP (27)
/* Command retry count definitions */
#define MPI3MR_DEV_RMHS_RETRY_COUNT 3
@ -177,7 +179,7 @@ extern atomic64_t event_counter;
#define MPI3MR_DEFAULT_SDEV_QD 32
/* Definitions for Threaded IRQ poll*/
#define MPI3MR_IRQ_POLL_SLEEP 20
#define MPI3MR_IRQ_POLL_SLEEP 2
#define MPI3MR_IRQ_POLL_TRIGGER_IOCOUNT 8
/* Definitions for the controller security status*/
@ -1118,6 +1120,7 @@ struct scmd_priv {
* @evtack_cmds_bitmap: Event Ack bitmap
* @delayed_evtack_cmds_list: Delayed event acknowledgment list
* @ts_update_counter: Timestamp update counter
* @early_ts_sync_done: Early (1 min) timestamp sync completed after load
* @ts_update_interval: Timestamp update interval
* @reset_in_progress: Reset in progress flag
* @unrecoverable: Controller unrecoverable flag
@ -1318,6 +1321,7 @@ struct mpi3mr_ioc {
struct list_head delayed_evtack_cmds_list;
u16 ts_update_counter;
u8 early_ts_sync_done;
u16 ts_update_interval;
u8 reset_in_progress;
u8 unrecoverable;
@ -1410,6 +1414,9 @@ struct mpi3mr_ioc {
struct dma_pool *trace_buf_pool;
struct segments *trace_buf;
u8 invalid_io_comp;
bool is_unload;
bool skip_dev_shutdown_on_unload;
};

87
drivers/scsi/mpi3mr/mpi3mr_app.c
View File

@ -141,25 +141,27 @@ void mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc *mrioc)
trace_min_size = fw_min_size = MPI3MR_DEFAULT_HDB_MIN_SZ;
} else {
trace_size = driver_pg1.host_diag_trace_max_size * 1024;
trace_dec_size = driver_pg1.host_diag_trace_decrement_size
trace_size = le16_to_cpu(driver_pg1.host_diag_trace_max_size) * 1024;
trace_dec_size = le16_to_cpu(driver_pg1.host_diag_trace_decrement_size)
* 1024;
trace_min_size = driver_pg1.host_diag_trace_min_size * 1024;
fw_size = driver_pg1.host_diag_fw_max_size * 1024;
fw_dec_size = driver_pg1.host_diag_fw_decrement_size * 1024;
fw_min_size = driver_pg1.host_diag_fw_min_size * 1024;
trace_min_size = le16_to_cpu(driver_pg1.host_diag_trace_min_size) * 1024;
fw_size = le16_to_cpu(driver_pg1.host_diag_fw_max_size) * 1024;
fw_dec_size = le16_to_cpu(driver_pg1.host_diag_fw_decrement_size) * 1024;
fw_min_size = le16_to_cpu(driver_pg1.host_diag_fw_min_size) * 1024;
dprint_init(mrioc,
"%s:trace diag buffer sizes read from driver\n"
"page1: maximum size = %dKB, decrement size = %dKB\n"
", minimum size = %dKB\n", __func__, driver_pg1.host_diag_trace_max_size,
driver_pg1.host_diag_trace_decrement_size,
driver_pg1.host_diag_trace_min_size);
", minimum size = %dKB\n", __func__,
le16_to_cpu(driver_pg1.host_diag_trace_max_size),
le16_to_cpu(driver_pg1.host_diag_trace_decrement_size),
le16_to_cpu(driver_pg1.host_diag_trace_min_size));
dprint_init(mrioc,
"%s:firmware diag buffer sizes read from driver\n"
"page1: maximum size = %dKB, decrement size = %dKB\n"
", minimum size = %dKB\n", __func__, driver_pg1.host_diag_fw_max_size,
driver_pg1.host_diag_fw_decrement_size,
driver_pg1.host_diag_fw_min_size);
", minimum size = %dKB\n", __func__,
le16_to_cpu(driver_pg1.host_diag_fw_max_size),
le16_to_cpu(driver_pg1.host_diag_fw_decrement_size),
le16_to_cpu(driver_pg1.host_diag_fw_min_size));
if ((trace_size == 0) && (fw_size == 0))
return;
}
@ -179,6 +181,12 @@ void mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc *mrioc)
mpi3mr_alloc_trace_buffer(mrioc, trace_size)) {
retry = true;
if (!trace_dec_size || trace_dec_size > trace_size) {
retry = false;
goto retry_fw;
}
trace_size -= trace_dec_size;
dprint_init(mrioc, "trace diag buffer allocation failed\n"
"retrying smaller size %dKB\n", trace_size / 1024);
@ -211,11 +219,13 @@ void mpi3mr_alloc_diag_bufs(struct mpi3mr_ioc *mrioc)
diag_buffer->size = fw_size;
} else {
retry = true;
fw_size -= fw_dec_size;
dprint_init(mrioc, "%s:trace diag buffer allocation failed,\n"
"retrying smaller size %dKB\n",
__func__, fw_size / 1024);
goto retry_fw;
if (fw_dec_size && fw_dec_size <= fw_size) {
fw_size -= fw_dec_size;
dprint_init(mrioc, "%s:trace diag buffer allocation failed,\n"
"retrying smaller size %dKB\n",
__func__, fw_size / 1024);
goto retry_fw;
}
}
}
}
@ -1244,7 +1254,7 @@ static long mpi3mr_bsg_query_hdb(struct mpi3mr_ioc *mrioc,
length = (sizeof(*hbd_status) + ((MPI3MR_MAX_NUM_HDB - 1) *
sizeof(*hbd_status_entry)));
hbd_status = kmalloc(length, GFP_KERNEL);
hbd_status = kzalloc(length, GFP_KERNEL);
if (!hbd_status)
return -ENOMEM;
hbd_status_entry = &hbd_status->entry[0];
@ -1466,7 +1476,8 @@ static long mpi3mr_bsg_pel_enable(struct mpi3mr_ioc *mrioc,
static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc,
struct bsg_job *job)
{
u16 num_devices = 0, i = 0, size;
u16 num_devices = 0, i = 0;
size_t size;
unsigned long flags;
struct mpi3mr_tgt_dev *tgtdev;
struct mpi3mr_device_map_info *devmap_info = NULL;
@ -1492,8 +1503,8 @@ static long mpi3mr_get_all_tgt_info(struct mpi3mr_ioc *mrioc,
return 0;
}
kern_entrylen = num_devices * sizeof(*devmap_info);
size = sizeof(u64) + kern_entrylen;
kern_entrylen = (uint32_t)num_devices * sizeof(*devmap_info);
size = sizeof(u64) + (size_t)kern_entrylen;
alltgt_info = kzalloc(size, GFP_KERNEL);
if (!alltgt_info)
return -ENOMEM;
@ -2384,7 +2395,7 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
long rval = -EINVAL;
struct mpi3mr_ioc *mrioc = NULL;
u8 *mpi_req = NULL, *sense_buff_k = NULL;
u8 mpi_msg_size = 0;
u32 mpi_msg_size = 0;
struct mpi3mr_bsg_packet *bsg_req = NULL;
struct mpi3mr_bsg_mptcmd *karg;
struct mpi3mr_buf_entry *buf_entries = NULL;
@ -2538,7 +2549,15 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
rval = -EINVAL;
goto out;
}
memcpy(mpi_req, sgl_iter, buf_entries->buf_len);
if (sgl_iter + mpi_msg_size >
dout_buf + job->request_payload.payload_len) {
dprint_bsg_err(mrioc, "%s: MPI request buf exceeds dout_buf\n",
__func__);
mutex_unlock(&mrioc->bsg_cmds.mutex);
rval = -EINVAL;
goto out;
}
memcpy(mpi_req, sgl_iter, mpi_msg_size);
break;
default:
invalid_be = 1;
@ -2737,10 +2756,12 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
}
if (block_io) {
tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle);
if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) {
stgt_priv = (struct mpi3mr_stgt_priv_data *)
tgtdev->starget->hostdata;
atomic_inc(&stgt_priv->block_io);
if (tgtdev) {
if (tgtdev->starget && tgtdev->starget->hostdata) {
stgt_priv = (struct mpi3mr_stgt_priv_data *)
tgtdev->starget->hostdata;
atomic_inc(&stgt_priv->block_io);
}
mpi3mr_tgtdev_put(tgtdev);
}
}
@ -2774,6 +2795,8 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
dprint_bsg_err(mrioc,
"%s: posting bsg request is failed\n", __func__);
rval = -EAGAIN;
if (block_io && stgt_priv)
atomic_dec(&stgt_priv->block_io);
goto out_unlock;
}
wait_for_completion_timeout(&mrioc->bsg_cmds.done,
@ -2935,7 +2958,8 @@ static long mpi3mr_bsg_process_mpt_cmds(struct bsg_job *job)
void mpi3mr_app_save_logdata_th(struct mpi3mr_ioc *mrioc, char *event_data,
u16 event_data_size)
{
u32 index = mrioc->logdata_buf_idx, sz;
u32 index = mrioc->logdata_buf_idx;
size_t entry_payload_len, sz;
struct mpi3mr_logdata_entry *entry;
if (!(mrioc->logdata_buf))
@ -2944,7 +2968,12 @@ void mpi3mr_app_save_logdata_th(struct mpi3mr_ioc *mrioc, char *event_data,
entry = (struct mpi3mr_logdata_entry *)
(mrioc->logdata_buf + (index * mrioc->logdata_entry_sz));
entry->valid_entry = 1;
sz = min(mrioc->logdata_entry_sz, event_data_size);
if (mrioc->logdata_entry_sz > MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ)
entry_payload_len = (size_t)mrioc->logdata_entry_sz -
MPI3MR_BSG_LOGDATA_ENTRY_HEADER_SZ;
else
entry_payload_len = 0;
sz = min_t(size_t, entry_payload_len, event_data_size);
memcpy(entry->data, event_data, sz);
mrioc->logdata_buf_idx =
((++index) % MPI3MR_BSG_LOGDATA_MAX_ENTRIES);

223
drivers/scsi/mpi3mr/mpi3mr_fw.c
View File

@ -124,11 +124,16 @@ void mpi3mr_build_zero_len_sge(void *paddr)
void *mpi3mr_get_reply_virt_addr(struct mpi3mr_ioc *mrioc,
dma_addr_t phys_addr)
{
u64 offset;
if (!phys_addr)
return NULL;
offset = phys_addr - mrioc->reply_buf_dma;
if ((phys_addr < mrioc->reply_buf_dma) ||
(phys_addr > mrioc->reply_buf_dma_max_address))
(phys_addr > mrioc->reply_buf_dma_max_address - mrioc->reply_sz) ||
do_div(offset, mrioc->reply_sz))
return NULL;
return mrioc->reply_buf + (phys_addr - mrioc->reply_buf_dma);
@ -137,9 +142,19 @@ void *mpi3mr_get_reply_virt_addr(struct mpi3mr_ioc *mrioc,
void *mpi3mr_get_sensebuf_virt_addr(struct mpi3mr_ioc *mrioc,
dma_addr_t phys_addr)
{
u64 offset;
if (!phys_addr)
return NULL;
offset = phys_addr - mrioc->sense_buf_dma;
if (phys_addr < mrioc->sense_buf_dma ||
(phys_addr > mrioc->sense_buf_dma +
(mrioc->num_sense_bufs * MPI3MR_SENSE_BUF_SZ) - MPI3MR_SENSE_BUF_SZ) ||
do_div(offset, MPI3MR_SENSE_BUF_SZ))
return NULL;
return mrioc->sense_buf + (phys_addr - mrioc->sense_buf_dma);
}
@ -404,7 +419,8 @@ static void mpi3mr_process_admin_reply_desc(struct mpi3mr_ioc *mrioc,
scsi_normalize_sense(sense_buf, sense_count,
&sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
}
mpi3mr_reply_trigger(mrioc, masked_ioc_status, ioc_loginfo);
@ -474,6 +490,12 @@ int mpi3mr_process_admin_reply_q(struct mpi3mr_ioc *mrioc)
return 0;
}
/*
* Ensure that the descriptor payload is read only after
* the phase bit check is complete.
*/
dma_rmb();
do {
if (mrioc->unrecoverable || mrioc->io_admin_reset_sync)
break;
@ -494,6 +516,13 @@ int mpi3mr_process_admin_reply_q(struct mpi3mr_ioc *mrioc)
if ((le16_to_cpu(reply_desc->reply_flags) &
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase)
break;
/*
* Ensure that the descriptor payload is read only after
* the phase bit check is complete.
*/
dma_rmb();
if (threshold_comps == MPI3MR_THRESHOLD_REPLY_COUNT) {
writel(admin_reply_ci,
&mrioc->sysif_regs->admin_reply_queue_ci);
@ -554,6 +583,9 @@ int mpi3mr_process_op_reply_q(struct mpi3mr_ioc *mrioc,
struct mpi3_default_reply_descriptor *reply_desc;
u16 req_q_idx = 0, reply_qidx, threshold_comps = 0;
if (!op_reply_q)
return 0;
reply_qidx = op_reply_q->qid - 1;
if (!atomic_add_unless(&op_reply_q->in_use, 1, 1))
@ -565,15 +597,33 @@ int mpi3mr_process_op_reply_q(struct mpi3mr_ioc *mrioc,
reply_desc = mpi3mr_get_reply_desc(op_reply_q, reply_ci);
if ((le16_to_cpu(reply_desc->reply_flags) &
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase) {
/* Recheck under in_use before releasing, to avoid a reclaim race */
dma_rmb();
if ((le16_to_cpu(reply_desc->reply_flags) &
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) == exp_phase)
goto process_desc;
atomic_dec(&op_reply_q->in_use);
return 0;
}
process_desc:
/*
* Ensure that the descriptor payload is read only after
* the phase bit check is complete.
*/
dma_rmb();
do {
if (mrioc->unrecoverable || mrioc->io_admin_reset_sync)
break;
req_q_idx = le16_to_cpu(reply_desc->request_queue_id) - 1;
if (unlikely(req_q_idx >= mrioc->num_op_req_q)) {
ioc_err(mrioc, "Invalid request queue id %d, skipping reply\n",
req_q_idx + 1);
goto next_reply;
}
op_req_q = &mrioc->req_qinfo[req_q_idx];
WRITE_ONCE(op_req_q->ci, le16_to_cpu(reply_desc->request_queue_ci));
@ -582,8 +632,9 @@ int mpi3mr_process_op_reply_q(struct mpi3mr_ioc *mrioc,
if (reply_dma)
mpi3mr_repost_reply_buf(mrioc, reply_dma);
num_op_reply++;
threshold_comps++;
next_reply:
num_op_reply++;
if (++reply_ci == op_reply_q->num_replies) {
reply_ci = 0;
@ -593,8 +644,19 @@ int mpi3mr_process_op_reply_q(struct mpi3mr_ioc *mrioc,
reply_desc = mpi3mr_get_reply_desc(op_reply_q, reply_ci);
if ((le16_to_cpu(reply_desc->reply_flags) &
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase)
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) != exp_phase) {
dma_rmb();
if ((le16_to_cpu(reply_desc->reply_flags) &
MPI3_REPLY_DESCRIPT_FLAGS_PHASE_MASK) == exp_phase)
goto reply_ready;
break;
}
reply_ready:
/*
* Ensure that the descriptor payload is read only after
* the phase bit check is complete.
*/
dma_rmb();
#ifndef CONFIG_PREEMPT_RT
/*
* Exit completion loop to avoid CPU lockup
@ -656,6 +718,7 @@ static irqreturn_t mpi3mr_isr_primary(int irq, void *privdata)
{
struct mpi3mr_intr_info *intr_info = privdata;
struct mpi3mr_ioc *mrioc;
struct op_reply_qinfo *op_reply_q;
u16 midx;
u32 num_admin_replies = 0, num_op_reply = 0;
@ -671,9 +734,9 @@ static irqreturn_t mpi3mr_isr_primary(int irq, void *privdata)
if (!midx)
num_admin_replies = mpi3mr_process_admin_reply_q(mrioc);
if (intr_info->op_reply_q)
num_op_reply = mpi3mr_process_op_reply_q(mrioc,
intr_info->op_reply_q);
op_reply_q = READ_ONCE(intr_info->op_reply_q);
if (op_reply_q)
num_op_reply = mpi3mr_process_op_reply_q(mrioc, op_reply_q);
if (num_admin_replies || num_op_reply)
return IRQ_HANDLED;
@ -686,6 +749,7 @@ static irqreturn_t mpi3mr_isr_primary(int irq, void *privdata)
static irqreturn_t mpi3mr_isr(int irq, void *privdata)
{
struct mpi3mr_intr_info *intr_info = privdata;
struct op_reply_qinfo *op_reply_q;
int ret;
if (!intr_info)
@ -698,11 +762,12 @@ static irqreturn_t mpi3mr_isr(int irq, void *privdata)
* If more IOs are expected, schedule IRQ polling thread.
* Otherwise exit from ISR.
*/
if ((threaded_isr_poll == false) || !intr_info->op_reply_q)
op_reply_q = READ_ONCE(intr_info->op_reply_q);
if ((threaded_isr_poll == false) || !op_reply_q)
return ret;
if (!intr_info->op_reply_q->enable_irq_poll ||
!atomic_read(&intr_info->op_reply_q->pend_ios))
if (!op_reply_q->enable_irq_poll ||
!atomic_read(&op_reply_q->pend_ios))
return ret;
disable_irq_nosync(intr_info->os_irq);
@ -724,12 +789,19 @@ static irqreturn_t mpi3mr_isr_poll(int irq, void *privdata)
{
struct mpi3mr_intr_info *intr_info = privdata;
struct mpi3mr_ioc *mrioc;
struct op_reply_qinfo *op_reply_q;
u16 midx;
u32 num_op_reply = 0;
if (!intr_info || !intr_info->op_reply_q)
if (!intr_info)
return IRQ_NONE;
op_reply_q = READ_ONCE(intr_info->op_reply_q);
if (!op_reply_q) {
enable_irq(intr_info->os_irq);
return IRQ_HANDLED;
}
mrioc = intr_info->mrioc;
midx = intr_info->msix_index;
@ -738,19 +810,23 @@ static irqreturn_t mpi3mr_isr_poll(int irq, void *privdata)
if (!mrioc->intr_enabled || mrioc->unrecoverable)
break;
op_reply_q = READ_ONCE(intr_info->op_reply_q);
if (!op_reply_q)
break;
if (!midx)
mpi3mr_process_admin_reply_q(mrioc);
if (intr_info->op_reply_q)
num_op_reply +=
mpi3mr_process_op_reply_q(mrioc,
intr_info->op_reply_q);
num_op_reply +=
mpi3mr_process_op_reply_q(mrioc, op_reply_q);
if (!atomic_read(&op_reply_q->pend_ios))
break;
usleep_range(MPI3MR_IRQ_POLL_SLEEP, MPI3MR_IRQ_POLL_SLEEP + 1);
usleep_range(MPI3MR_IRQ_POLL_SLEEP, 10 * MPI3MR_IRQ_POLL_SLEEP);
} while (atomic_read(&intr_info->op_reply_q->pend_ios) &&
(num_op_reply < mrioc->max_host_ios));
} while (num_op_reply < mrioc->max_host_ios);
intr_info->op_reply_q->enable_irq_poll = false;
if (op_reply_q)
op_reply_q->enable_irq_poll = false;
enable_irq(intr_info->os_irq);
return IRQ_HANDLED;
@ -1934,10 +2010,6 @@ static void mpi3mr_free_op_req_q_segments(struct mpi3mr_ioc *mrioc, u16 q_idx)
int size;
struct segments *segments;
segments = mrioc->req_qinfo[q_idx].q_segments;
if (!segments)
return;
if (mrioc->enable_segqueue) {
size = MPI3MR_OP_REQ_Q_SEG_SIZE;
if (mrioc->req_qinfo[q_idx].q_segment_list) {
@ -1951,6 +2023,10 @@ static void mpi3mr_free_op_req_q_segments(struct mpi3mr_ioc *mrioc, u16 q_idx)
size = mrioc->req_qinfo[q_idx].segment_qd *
mrioc->facts.op_req_sz;
segments = mrioc->req_qinfo[q_idx].q_segments;
if (!segments)
return;
for (j = 0; j < mrioc->req_qinfo[q_idx].num_segments; j++) {
if (!segments[j].segment)
continue;
@ -1977,10 +2053,17 @@ static void mpi3mr_free_op_reply_q_segments(struct mpi3mr_ioc *mrioc, u16 q_idx)
u16 j;
int size;
struct segments *segments;
u16 midx = REPLY_QUEUE_IDX_TO_MSIX_IDX(q_idx, mrioc->op_reply_q_offset);
segments = mrioc->op_reply_qinfo[q_idx].q_segments;
if (!segments)
return;
/*
* Stop the ISR/poll thread from picking up this queue before its
* segments are freed below, and wait for any in-flight handler
* that already has the old pointer to finish using it.
*/
if (midx < mrioc->intr_info_count) {
WRITE_ONCE(mrioc->intr_info[midx].op_reply_q, NULL);
synchronize_irq(pci_irq_vector(mrioc->pdev, midx));
}
if (mrioc->enable_segqueue) {
size = MPI3MR_OP_REP_Q_SEG_SIZE;
@ -1995,6 +2078,10 @@ static void mpi3mr_free_op_reply_q_segments(struct mpi3mr_ioc *mrioc, u16 q_idx)
size = mrioc->op_reply_qinfo[q_idx].segment_qd *
mrioc->op_reply_desc_sz;
segments = mrioc->op_reply_qinfo[q_idx].q_segments;
if (!segments)
return;
for (j = 0; j < mrioc->op_reply_qinfo[q_idx].num_segments; j++) {
if (!segments[j].segment)
continue;
@ -2461,7 +2548,7 @@ static int mpi3mr_create_op_req_q(struct mpi3mr_ioc *mrioc, u16 idx,
static int mpi3mr_create_op_queues(struct mpi3mr_ioc *mrioc)
{
int retval = 0;
u16 num_queues = 0, i = 0, msix_count_op_q = 1;
u16 num_queues = 0, i = 0, j = 0, msix_count_op_q = 1;
u32 ioc_status;
enum mpi3mr_iocstate ioc_state;
@ -2513,6 +2600,13 @@ static int mpi3mr_create_op_queues(struct mpi3mr_ioc *mrioc)
}
}
if (i < num_queues) {
for (j = i; j < num_queues; j++) {
mpi3mr_free_op_req_q_segments(mrioc, j);
mpi3mr_free_op_reply_q_segments(mrioc, j);
}
}
if (i == 0) {
/* Not even one queue is created successfully*/
retval = -1;
@ -2534,11 +2628,19 @@ static int mpi3mr_create_op_queues(struct mpi3mr_ioc *mrioc)
return retval;
out_failed:
kfree(mrioc->req_qinfo);
mrioc->req_qinfo = NULL;
if (mrioc->req_qinfo) {
for (j = 0; j < i; j++) {
mpi3mr_free_op_req_q_segments(mrioc, j);
mpi3mr_free_op_reply_q_segments(mrioc, j);
}
kfree(mrioc->req_qinfo);
mrioc->req_qinfo = NULL;
}
mrioc->num_op_req_q = 0;
kfree(mrioc->op_reply_qinfo);
mrioc->op_reply_qinfo = NULL;
mrioc->num_op_reply_q = 0;
return retval;
}
@ -2582,7 +2684,8 @@ int mpi3mr_op_request_post(struct mpi3mr_ioc *mrioc,
if (mpi3mr_check_req_qfull(op_req_q)) {
midx = REPLY_QUEUE_IDX_TO_MSIX_IDX(
reply_qidx, mrioc->op_reply_q_offset);
mpi3mr_process_op_reply_q(mrioc, mrioc->intr_info[midx].op_reply_q);
mpi3mr_process_op_reply_q(mrioc,
READ_ONCE(mrioc->intr_info[midx].op_reply_q));
if (mpi3mr_check_req_qfull(op_req_q)) {
@ -2875,8 +2978,9 @@ static int mpi3mr_print_pkg_ver(struct mpi3mr_ioc *mrioc)
* @work: work struct
*
* Watch dog work periodically executed (1 second interval) to
* monitor firmware fault and to issue periodic timer sync to
* the firmware.
* monitor firmware fault and perform timestamp synchronization
* to firmware, with an early sync 1 minute after load followed
* by periodic updates at ts_update_interval seconds (default 15 minutes).
*
* Return: Nothing.
*/
@ -2922,11 +3026,23 @@ static void mpi3mr_watchdog_work(struct work_struct *work)
}
if (!(mrioc->facts.ioc_capabilities &
MPI3_IOCFACTS_CAPABILITY_NON_SUPERVISOR_IOC) &&
(mrioc->ts_update_counter++ >= mrioc->ts_update_interval)) {
MPI3_IOCFACTS_CAPABILITY_NON_SUPERVISOR_IOC)) {
if (!mrioc->early_ts_sync_done) {
/*
* Send time sync 1 min after load
*/
if (mrioc->ts_update_counter++ >=
MPI3MR_EARLY_TSUPDATE_SECONDS) {
mrioc->early_ts_sync_done = 1;
mrioc->ts_update_counter = 0;
mpi3mr_sync_timestamp(mrioc);
}
} else if (mrioc->ts_update_counter++ >=
mrioc->ts_update_interval) {
mrioc->ts_update_counter = 0;
mpi3mr_sync_timestamp(mrioc);
}
mrioc->ts_update_counter = 0;
mpi3mr_sync_timestamp(mrioc);
}
if ((mrioc->prepare_for_reset) &&
@ -4112,26 +4228,35 @@ static int mpi3mr_repost_diag_bufs(struct mpi3mr_ioc *mrioc)
}
/**
* mpi3mr_read_tsu_interval - Update time stamp interval
* mpi3mr_read_driver_page1 - Read Driver Page 1 parameters
* @mrioc: Adapter instance reference
*
* Update time stamp interval if its defined in driver page 1,
* otherwise use default value.
* Reads and caches Driver Page 1 parameters such as
* timestamp update interval and driver behavior flags.
*
* Return: Nothing
*/
static void
mpi3mr_read_tsu_interval(struct mpi3mr_ioc *mrioc)
mpi3mr_read_driver_page1(struct mpi3mr_ioc *mrioc)
{
struct mpi3_driver_page1 driver_pg1;
u16 pg_sz = sizeof(driver_pg1);
int retval = 0;
mrioc->ts_update_interval = MPI3MR_TSUPDATE_INTERVAL;
mrioc->skip_dev_shutdown_on_unload = 0;
retval = mpi3mr_cfg_get_driver_pg1(mrioc, &driver_pg1, pg_sz);
if (!retval && driver_pg1.time_stamp_update)
if (retval)
return;
if (driver_pg1.time_stamp_update)
mrioc->ts_update_interval = (driver_pg1.time_stamp_update * 60);
mrioc->skip_dev_shutdown_on_unload =
(le32_to_cpu(driver_pg1.flags) &
MPI3_DRIVER1_FLAGS_DEVICE_SHUTDOWN_ON_UNLOAD_DISABLE) ? 1 : 0;
}
/**
@ -4437,7 +4562,7 @@ int mpi3mr_init_ioc(struct mpi3mr_ioc *mrioc)
goto out_failed_noretry;
}
mpi3mr_read_tsu_interval(mrioc);
mpi3mr_read_driver_page1(mrioc);
mpi3mr_print_ioc_info(mrioc);
dprint_init(mrioc, "allocating host diag buffers\n");
@ -4609,7 +4734,7 @@ int mpi3mr_reinit_ioc(struct mpi3mr_ioc *mrioc, u8 is_resume)
goto out_failed_noretry;
}
mpi3mr_read_tsu_interval(mrioc);
mpi3mr_read_driver_page1(mrioc);
mpi3mr_print_ioc_info(mrioc);
if (is_resume) {
@ -5094,8 +5219,16 @@ static void mpi3mr_issue_ioc_shutdown(struct mpi3mr_ioc *mrioc)
return;
}
shutdown_action = MPI3_SYSIF_IOC_CONFIG_SHUTDOWN_NORMAL |
MPI3_SYSIF_IOC_CONFIG_DEVICE_SHUTDOWN_SEND_REQ;
shutdown_action = MPI3_SYSIF_IOC_CONFIG_SHUTDOWN_NORMAL;
if (!(mrioc->is_unload && mrioc->skip_dev_shutdown_on_unload))
shutdown_action |=
MPI3_SYSIF_IOC_CONFIG_DEVICE_SHUTDOWN_SEND_REQ;
else
ioc_info(mrioc,
"The shutdown request is issued without the device shutdown bit set\n"
"as indicated by the controller configuration\n");
ioc_config = readl(&mrioc->sysif_regs->ioc_configuration);
ioc_config |= shutdown_action;

320
drivers/scsi/mpi3mr/mpi3mr_os.c
View File

@ -233,10 +233,11 @@ static void mpi3mr_fwevt_add_to_list(struct mpi3mr_ioc *mrioc,
{
unsigned long flags;
if (!mrioc->fwevt_worker_thread)
return;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (!mrioc->fwevt_worker_thread) {
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
return;
}
/* get fwevt reference count while adding it to fwevt_list */
mpi3mr_fwevt_get(fwevt);
INIT_LIST_HEAD(&fwevt->list);
@ -282,32 +283,6 @@ void mpi3mr_hdb_trigger_data_event(struct mpi3mr_ioc *mrioc,
mpi3mr_fwevt_add_to_list(mrioc, fwevt);
}
/**
* mpi3mr_fwevt_del_from_list - Delete firmware event from list
* @mrioc: Adapter instance reference
* @fwevt: Firmware event reference
*
* Delete the given firmware event from the firmware event list.
*
* Return: Nothing.
*/
static void mpi3mr_fwevt_del_from_list(struct mpi3mr_ioc *mrioc,
struct mpi3mr_fwevt *fwevt)
{
unsigned long flags;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (!list_empty(&fwevt->list)) {
list_del_init(&fwevt->list);
/*
* Put fwevt reference count after
* removing it from fwevt_list
*/
mpi3mr_fwevt_put(fwevt);
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
}
/**
* mpi3mr_dequeue_fwevt - Dequeue firmware event from the list
* @mrioc: Adapter instance reference
@ -327,11 +302,7 @@ static struct mpi3mr_fwevt *mpi3mr_dequeue_fwevt(
fwevt = list_first_entry(&mrioc->fwevt_list,
struct mpi3mr_fwevt, list);
list_del_init(&fwevt->list);
/*
* Put fwevt reference count after
* removing it from fwevt_list
*/
mpi3mr_fwevt_put(fwevt);
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
@ -365,6 +336,11 @@ static void mpi3mr_cancel_work(struct mpi3mr_fwevt *fwevt)
*/
mpi3mr_fwevt_put(fwevt);
}
/*
* Drop the reference count that was acquired by the caller.
*/
mpi3mr_fwevt_put(fwevt);
}
/**
@ -379,17 +355,44 @@ static void mpi3mr_cancel_work(struct mpi3mr_fwevt *fwevt)
void mpi3mr_cleanup_fwevt_list(struct mpi3mr_ioc *mrioc)
{
struct mpi3mr_fwevt *fwevt = NULL;
unsigned long flags;
/*
* Safely read current_event under lock to prevent TOCTOU race
* with the firmware event worker thread.
*/
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if ((list_empty(&mrioc->fwevt_list) && !mrioc->current_event) ||
!mrioc->fwevt_worker_thread)
!mrioc->fwevt_worker_thread) {
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
return;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
while ((fwevt = mpi3mr_dequeue_fwevt(mrioc)))
mpi3mr_cancel_work(fwevt);
if (mrioc->current_event) {
fwevt = mrioc->current_event;
/*
* Safely read current_event under lock to prevent TOCTOU race
* with the firmware event worker thread.
*/
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
fwevt = mrioc->current_event;
if (fwevt) {
/*
* Take a reference to ensure the event is not freed by the
* worker thread while we are evaluating or cancelling it.
*/
mpi3mr_fwevt_get(fwevt);
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (fwevt) {
bool pending_at_sml;
/*
* Read pending_at_sml under lock to avoid a stale value.
*
* Don't call cancel_work_sync() API for the
* fwevt work if the controller reset is
* get called as part of processing the
@ -397,8 +400,13 @@ void mpi3mr_cleanup_fwevt_list(struct mpi3mr_ioc *mrioc)
* waiting for device add/remove APIs to complete.
* Otherwise we will see deadlock.
*/
if (current_work() == &fwevt->work || fwevt->pending_at_sml) {
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
pending_at_sml = fwevt->pending_at_sml;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (current_work() == &fwevt->work || pending_at_sml) {
fwevt->discard = 1;
mpi3mr_fwevt_put(fwevt);
return;
}
@ -912,6 +920,8 @@ void mpi3mr_remove_tgtdev_from_host(struct mpi3mr_ioc *mrioc,
struct mpi3mr_tgt_dev *tgtdev)
{
struct mpi3mr_stgt_priv_data *tgt_priv;
unsigned long flags;
bool discard = false;
ioc_info(mrioc, "%s :Removing handle(0x%04x), wwid(0x%016llx)\n",
__func__, tgtdev->dev_handle, (unsigned long long)tgtdev->wwid);
@ -924,17 +934,27 @@ void mpi3mr_remove_tgtdev_from_host(struct mpi3mr_ioc *mrioc,
if (!mrioc->sas_transport_enabled || (tgtdev->dev_type !=
MPI3_DEVICE_DEVFORM_SAS_SATA) || tgtdev->non_stl) {
if (tgtdev->starget) {
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->stop_drv_processing ||
mrioc->reset_in_progress) {
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
return;
}
if (mrioc->current_event)
mrioc->current_event->pending_at_sml = 1;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
scsi_remove_target(&tgtdev->starget->dev);
tgtdev->host_exposed = 0;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event) {
mrioc->current_event->pending_at_sml = 0;
if (mrioc->current_event->discard) {
mpi3mr_print_device_event_notice(mrioc,
false);
return;
}
discard = mrioc->current_event->discard;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (discard) {
mpi3mr_print_device_event_notice(mrioc,
false);
return;
}
}
} else
@ -962,6 +982,8 @@ static int mpi3mr_report_tgtdev_to_host(struct mpi3mr_ioc *mrioc,
{
int retval = 0;
struct mpi3mr_tgt_dev *tgtdev;
unsigned long flags;
bool discard = false;
if (mrioc->reset_in_progress || mrioc->pci_err_recovery)
return -1;
@ -978,19 +1000,29 @@ static int mpi3mr_report_tgtdev_to_host(struct mpi3mr_ioc *mrioc,
if (!mrioc->sas_transport_enabled || (tgtdev->dev_type !=
MPI3_DEVICE_DEVFORM_SAS_SATA) || tgtdev->non_stl){
tgtdev->host_exposed = 1;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->stop_drv_processing || mrioc->reset_in_progress) {
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
tgtdev->host_exposed = 0;
goto out;
}
if (mrioc->current_event)
mrioc->current_event->pending_at_sml = 1;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
scsi_scan_target(&mrioc->shost->shost_gendev,
mrioc->scsi_device_channel, tgtdev->perst_id,
SCAN_WILD_CARD, SCSI_SCAN_INITIAL);
if (!tgtdev->starget)
tgtdev->host_exposed = 0;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event) {
mrioc->current_event->pending_at_sml = 0;
if (mrioc->current_event->discard) {
mpi3mr_print_device_event_notice(mrioc, true);
goto out;
}
discard = mrioc->current_event->discard;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (discard) {
mpi3mr_print_device_event_notice(mrioc, true);
goto out;
}
dprint_event_bh(mrioc,
"exposed target device with handle(0x%04x), perst_id(%d)\n",
@ -1363,24 +1395,32 @@ static void mpi3mr_update_tgtdev(struct mpi3mr_ioc *mrioc,
struct mpi3_device0_pcie_format *pcieinf =
&dev_pg0->device_specific.pcie_format;
u16 dev_info = le16_to_cpu(pcieinf->device_info);
u8 pgsz = MPI3MR_DEFAULT_PGSZEXP;
u8 reset_to = MPI3MR_INTADMCMD_TIMEOUT;
u8 abort_to = MPI3MR_INTADMCMD_TIMEOUT;
u8 fw_pgsz = READ_ONCE(pcieinf->page_size);
tgtdev->dev_spec.pcie_inf.dev_info = dev_info;
tgtdev->dev_spec.pcie_inf.capb =
le32_to_cpu(pcieinf->capabilities);
tgtdev->dev_spec.pcie_inf.mdts = MPI3MR_DEFAULT_MDTS;
/* 2^12 = 4096 */
tgtdev->dev_spec.pcie_inf.pgsz = 12;
/* Validate firmware page size to prevent undefined shift behavior */
if (fw_pgsz >= MPI3MR_DEFAULT_PGSZEXP && fw_pgsz <= MPI3MR_MAX_PGSZEXP)
pgsz = fw_pgsz;
if (dev_pg0->access_status == MPI3_DEVICE0_ASTATUS_NO_ERRORS) {
tgtdev->dev_spec.pcie_inf.mdts =
le32_to_cpu(pcieinf->maximum_data_transfer_size);
tgtdev->dev_spec.pcie_inf.pgsz = pcieinf->page_size;
tgtdev->dev_spec.pcie_inf.reset_to =
max_t(u8, pcieinf->controller_reset_to,
MPI3MR_INTADMCMD_TIMEOUT);
tgtdev->dev_spec.pcie_inf.abort_to =
max_t(u8, pcieinf->nvme_abort_to,
reset_to = max_t(u8, pcieinf->controller_reset_to,
MPI3MR_INTADMCMD_TIMEOUT);
abort_to = max_t(u8, pcieinf->nvme_abort_to,
MPI3MR_INTADMCMD_TIMEOUT);
}
tgtdev->dev_spec.pcie_inf.pgsz = pgsz;
tgtdev->dev_spec.pcie_inf.reset_to = reset_to;
tgtdev->dev_spec.pcie_inf.abort_to = abort_to;
if (tgtdev->dev_spec.pcie_inf.mdts > (1024 * 1024))
tgtdev->dev_spec.pcie_inf.mdts = (1024 * 1024);
if (((dev_info & MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) !=
@ -2150,13 +2190,25 @@ static void mpi3mr_fwevt_bh(struct mpi3mr_ioc *mrioc,
u16 perst_id, handle, dev_info;
struct mpi3_device0_sas_sata_format *sasinf = NULL;
unsigned int timeout;
unsigned long flags;
mpi3mr_fwevt_del_from_list(mrioc, fwevt);
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (!list_empty(&fwevt->list)) {
list_del_init(&fwevt->list);
/*
* Put fwevt reference count after
* removing it from fwevt_list
*/
mpi3mr_fwevt_put(fwevt);
}
mrioc->current_event = fwevt;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (mrioc->stop_drv_processing) {
dprint_event_bh(mrioc, "ignoring event(0x%02x) in the bottom half handler\n"
"due to stop_drv_processing\n", fwevt->event_id);
if (mrioc->stop_drv_processing || mrioc->pci_err_recovery) {
dprint_event_bh(mrioc,
"ignoring event(0x%02x) in the bottom half handler\n"
"due to stop_drv_processing or pci_err_recovery\n",
fwevt->event_id);
goto out;
}
@ -2285,9 +2337,12 @@ static void mpi3mr_fwevt_bh(struct mpi3mr_ioc *mrioc,
mpi3mr_process_event_ack(mrioc, fwevt->event_id,
fwevt->evt_ctx);
out:
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
mrioc->current_event = NULL;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
/* Put fwevt reference count to neutralize kref_init increment */
mpi3mr_fwevt_put(fwevt);
mrioc->current_event = NULL;
}
/**
@ -2426,7 +2481,8 @@ static void mpi3mr_dev_rmhs_complete_iou(struct mpi3mr_ioc *mrioc,
ioc_info(mrioc,
"%s :dev removal handshake completed successfully: handle(0x%04x)\n",
__func__, drv_cmd->dev_handle);
clear_bit(drv_cmd->dev_handle, mrioc->removepend_bitmap);
if (drv_cmd->dev_handle < mrioc->facts.max_devhandle)
clear_bit(drv_cmd->dev_handle, mrioc->removepend_bitmap);
}
if (!list_empty(&mrioc->delayed_rmhs_list)) {
@ -2540,12 +2596,29 @@ static void mpi3mr_dev_rmhs_send_tm(struct mpi3mr_ioc *mrioc, u16 handle,
struct mpi3mr_tgt_dev *tgtdev = NULL;
unsigned long flags;
if (handle >= mrioc->facts.max_devhandle) {
ioc_err(mrioc, "dev_remove_hs: handle(0x%04x) >= max_devhandle(0x%04x)\n",
handle, mrioc->facts.max_devhandle);
if (drv_cmd) {
cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_DEVRMCMD_MIN;
drv_cmd->state = MPI3MR_CMD_NOTUSED;
drv_cmd->callback = NULL;
drv_cmd->dev_handle = MPI3MR_INVALID_DEV_HANDLE;
drv_cmd->retry_count = 0;
clear_bit(cmd_idx, mrioc->devrem_bitmap);
}
return;
}
spin_lock_irqsave(&mrioc->tgtdev_lock, flags);
tgtdev = __mpi3mr_get_tgtdev_by_handle(mrioc, handle);
if (tgtdev && (iou_rc == MPI3_CTRL_OP_REMOVE_DEVICE))
tgtdev->state = MPI3MR_DEV_REMOVE_HS_STARTED;
spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags);
if (tgtdev)
mpi3mr_tgtdev_put(tgtdev);
if (drv_cmd)
goto issue_cmd;
do {
@ -2768,12 +2841,28 @@ static void mpi3mr_pcietopochg_evt_th(struct mpi3mr_ioc *mrioc,
struct mpi3_event_data_pcie_topology_change_list *topo_evt =
(struct mpi3_event_data_pcie_topology_change_list *)event_reply->event_data;
int i;
u16 handle;
u8 reason_code;
u16 handle, avail_len;
u8 reason_code, max_entries, num_entries;
struct mpi3mr_tgt_dev *tgtdev = NULL;
struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL;
for (i = 0; i < topo_evt->num_entries; i++) {
avail_len = event_reply->event_data_length * 4;
if (avail_len < offsetof(struct mpi3_event_data_pcie_topology_change_list, port_entry)) {
ioc_err(mrioc, "PCIe topology event: event data too small (%u bytes)\n",
avail_len);
return;
}
max_entries = (avail_len -
offsetof(struct mpi3_event_data_pcie_topology_change_list, port_entry)) /
sizeof(struct mpi3_event_pcie_topo_port_entry);
num_entries = topo_evt->num_entries;
if (num_entries > max_entries) {
ioc_err(mrioc, "PCIe topology event: num_entries(%d) exceeds max(%d)\n",
num_entries, max_entries);
return;
}
for (i = 0; i < num_entries; i++) {
handle = le16_to_cpu(topo_evt->port_entry[i].attached_dev_handle);
if (!handle)
continue;
@ -2834,12 +2923,28 @@ static void mpi3mr_sastopochg_evt_th(struct mpi3mr_ioc *mrioc,
struct mpi3_event_data_sas_topology_change_list *topo_evt =
(struct mpi3_event_data_sas_topology_change_list *)event_reply->event_data;
int i;
u16 handle;
u8 reason_code;
u16 handle, avail_len;
u8 reason_code, max_entries, num_entries;
struct mpi3mr_tgt_dev *tgtdev = NULL;
struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL;
for (i = 0; i < topo_evt->num_entries; i++) {
avail_len = event_reply->event_data_length * 4;
if (avail_len < offsetof(struct mpi3_event_data_sas_topology_change_list, phy_entry)) {
ioc_err(mrioc, "SAS topology event: event data too small (%u bytes)\n",
avail_len);
return;
}
max_entries = (avail_len -
offsetof(struct mpi3_event_data_sas_topology_change_list, phy_entry)) /
sizeof(struct mpi3_event_sas_topo_phy_entry);
num_entries = topo_evt->num_entries;
if (num_entries > max_entries) {
ioc_err(mrioc, "SAS topology event: num_entries(%d) exceeds max(%d)\n",
num_entries, max_entries);
return;
}
for (i = 0; i < num_entries; i++) {
handle = le16_to_cpu(topo_evt->phy_entry[i].attached_dev_handle);
if (!handle)
continue;
@ -3109,7 +3214,7 @@ void mpi3mr_add_event_wait_for_device_refresh(struct mpi3mr_ioc *mrioc)
void mpi3mr_os_handle_events(struct mpi3mr_ioc *mrioc,
struct mpi3_event_notification_reply *event_reply)
{
u16 evt_type, sz;
u16 evt_type, sz, avail_reply_room;
struct mpi3mr_fwevt *fwevt = NULL;
bool ack_req = 0, process_evt_bh = 0;
@ -3170,7 +3275,12 @@ void mpi3mr_os_handle_events(struct mpi3mr_ioc *mrioc,
case MPI3_EVENT_DEVICE_INFO_CHANGED:
case MPI3_EVENT_LOG_DATA:
sz = event_reply->event_data_length * 4;
if (mrioc->reply_sz > offsetof(struct mpi3_event_notification_reply, event_data))
avail_reply_room = mrioc->reply_sz -
offsetof(struct mpi3_event_notification_reply, event_data);
else
avail_reply_room = 0;
sz = min_t(u16, event_reply->event_data_length * 4, avail_reply_room);
mpi3mr_app_save_logdata_th(mrioc,
(char *)event_reply->event_data, sz);
break;
@ -3204,7 +3314,12 @@ void mpi3mr_os_handle_events(struct mpi3mr_ioc *mrioc,
dprint_event_th(mrioc,
"scheduling bottom half handler for event(0x%02x) - (0x%08x), ack_required=%d\n",
evt_type, le32_to_cpu(event_reply->event_context), ack_req);
sz = event_reply->event_data_length * 4;
if (mrioc->reply_sz > offsetof(struct mpi3_event_notification_reply, event_data))
avail_reply_room = mrioc->reply_sz -
offsetof(struct mpi3_event_notification_reply, event_data);
else
avail_reply_room = 0;
sz = min_t(u16, event_reply->event_data_length * 4, avail_reply_room);
fwevt = mpi3mr_alloc_fwevt(sz);
if (!fwevt) {
dprint_event_th(mrioc,
@ -3329,8 +3444,7 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* @desc: Sense type
* @buf: Sense buffer to populate
* @key: Sense key
* @asc: Additional sense code
* @ascq: Additional sense code qualifier
* @code: Additional sense code and its qualifier
*
* Maps the given sense information into either descriptor or
* fixed format sense data.
@ -3338,20 +3452,20 @@ static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc,
* Return: Nothing
*/
static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
u8 asc, u8 ascq)
u16 code)
{
if (desc) {
buf[0] = 0x72; /* descriptor, current */
buf[1] = key;
buf[2] = asc;
buf[3] = ascq;
buf[2] = scsi_sense_code_asc(code);
buf[3] = scsi_sense_code_ascq(code);
buf[7] = 0;
} else {
buf[0] = 0x70; /* fixed, current */
buf[2] = key;
buf[7] = 0xa;
buf[12] = asc;
buf[13] = ascq;
buf[12] = scsi_sense_code_asc(code);
buf[13] = scsi_sense_code_ascq(code);
}
}
@ -3368,25 +3482,25 @@ static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key,
static void mpi3mr_map_eedp_error(struct scsi_cmnd *scmd,
u16 ioc_status)
{
u8 ascq = 0;
u16 sense_code;
switch (ioc_status) {
case MPI3_IOCSTATUS_EEDP_GUARD_ERROR:
ascq = 0x01;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_APP_TAG_ERROR:
ascq = 0x02;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI3_IOCSTATUS_EEDP_REF_TAG_ERROR:
ascq = 0x03;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
ascq = 0x00;
sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
mpi3mr_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x10, ascq);
sense_code);
scmd->result = (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION;
}
@ -3447,8 +3561,12 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
scsi_reply = mpi3mr_get_reply_virt_addr(mrioc,
*reply_dma);
if (!scsi_reply) {
panic("%s: scsi_reply is NULL, this shouldn't happen\n",
mrioc->name);
ioc_err(mrioc, "scsi_reply is NULL, invalid reply_frame_address\n");
/*
* Do not let the caller repost an address that
* failed virt-addr lookup back to the hardware.
*/
*reply_dma = 0;
goto out;
}
host_tag = le16_to_cpu(scsi_reply->host_tag);
@ -3471,7 +3589,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
if (sense_buf) {
scsi_normalize_sense(sense_buf, sense_count, &sshdr);
mpi3mr_scsisense_trigger(mrioc, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
mpi3mr_reply_trigger(mrioc, ioc_status, ioc_loginfo);
break;
@ -3658,7 +3777,8 @@ void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc,
ioc_info(mrioc,
"%s :sense_count 0x%x, sense_key 0x%x ASC 0x%x, ASCQ 0x%x\n",
__func__, sense_count, sshdr.sense_key,
sshdr.asc, sshdr.ascq);
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
}
out_success:
@ -3943,7 +4063,7 @@ inline void mpi3mr_poll_pend_io_completions(struct mpi3mr_ioc *mrioc)
for (i = mrioc->op_reply_q_offset; i < num_of_reply_queues; i++)
mpi3mr_process_op_reply_q(mrioc,
mrioc->intr_info[i].op_reply_q);
READ_ONCE(mrioc->intr_info[i].op_reply_q));
}
/**
@ -5065,8 +5185,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x1A, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@ -5076,8 +5196,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, param_len, scsi_bufflen(scmd));
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x1A, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
PARAMETER_LIST_LENGTH_ERROR);
scsi_done(scmd);
return true;
}
@ -5085,8 +5205,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
if (!buf) {
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x55, 0x03);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
INSUFFICIENT_RESOURCES);
scsi_done(scmd);
return true;
}
@ -5099,8 +5219,8 @@ static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc,
__func__, desc_len);
scsi_print_command(scmd);
scmd->result = SAM_STAT_CHECK_CONDITION;
scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
0x26, 0);
scsi_set_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST,
INVALID_FIELD_IN_PARAMETER_LIST);
scsi_done(scmd);
kfree(buf);
return true;
@ -5200,7 +5320,8 @@ static enum scsi_qc_status mpi3mr_qcmd(struct Scsi_Host *shost,
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY &&
(stgt_priv_data->dev_removed || (dev_handle == MPI3MR_INVALID_DEV_HANDLE))) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
goto out;
}
@ -5690,6 +5811,8 @@ static void mpi3mr_remove(struct pci_dev *pdev)
return;
mrioc = shost_priv(shost);
mrioc->is_unload = true;
while (mrioc->reset_in_progress || mrioc->is_driver_loading)
ssleep(1);
@ -5822,6 +5945,9 @@ mpi3mr_suspend(struct device *dev)
ssleep(1);
mrioc->stop_drv_processing = 1;
mpi3mr_cleanup_fwevt_list(mrioc);
/* Flush any pending discarded event before unmapping PCI resources below. */
if (mrioc->fwevt_worker_thread)
flush_workqueue(mrioc->fwevt_worker_thread);
scsi_block_requests(shost);
mpi3mr_stop_watchdog(mrioc);
mpi3mr_cleanup_ioc(mrioc);

106
drivers/scsi/mpi3mr/mpi3mr_transport.c
View File

@ -1090,6 +1090,13 @@ void mpi3mr_update_links(struct mpi3mr_ioc *mrioc,
return;
}
if (phy_number >= mr_sas_node->num_phys) {
spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
ioc_err(mrioc, "%s: phy_number(%d) >= num_phys(%d)\n",
__func__, phy_number, mr_sas_node->num_phys);
return;
}
mr_sas_phy = &mr_sas_node->phy[phy_number];
mr_sas_phy->attached_handle = handle;
spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
@ -1216,13 +1223,14 @@ void mpi3mr_sas_host_add(struct mpi3mr_ioc *mrioc)
}
num_phys = sas_io_unit_pg0->num_phys;
kfree(sas_io_unit_pg0);
sas_io_unit_pg0 = NULL;
mrioc->sas_hba.host_node = 1;
INIT_LIST_HEAD(&mrioc->sas_hba.sas_port_list);
mrioc->sas_hba.parent_dev = &mrioc->shost->shost_gendev;
mrioc->sas_hba.phy = kzalloc_objs(struct mpi3mr_sas_phy, num_phys);
if (!mrioc->sas_hba.phy)
return;
goto out;
mrioc->sas_hba.num_phys = num_phys;
@ -1230,12 +1238,12 @@ void mpi3mr_sas_host_add(struct mpi3mr_ioc *mrioc)
(num_phys * sizeof(struct mpi3_sas_io_unit0_phy_data));
sas_io_unit_pg0 = kzalloc(sz, GFP_KERNEL);
if (!sas_io_unit_pg0)
return;
goto out_free_phy;
if (mpi3mr_cfg_get_sas_io_unit_pg0(mrioc, sas_io_unit_pg0, sz)) {
ioc_err(mrioc, "failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__);
goto out;
goto out_free_phy;
}
mrioc->sas_hba.handle = 0;
@ -1249,12 +1257,12 @@ void mpi3mr_sas_host_add(struct mpi3mr_ioc *mrioc)
MPI3_SAS_PHY_PGAD_FORM_PHY_NUMBER, i)) {
ioc_err(mrioc, "failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__);
goto out;
goto out_free_phy;
}
if (ioc_status != MPI3_IOCSTATUS_SUCCESS) {
ioc_err(mrioc, "failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__);
goto out;
goto out_free_phy;
}
if (!mrioc->sas_hba.handle)
@ -1264,26 +1272,27 @@ void mpi3mr_sas_host_add(struct mpi3mr_ioc *mrioc)
if (!(mpi3mr_get_hba_port_by_id(mrioc, port_id)))
if (!mpi3mr_alloc_hba_port(mrioc, port_id))
goto out;
goto out_free_phy;
mrioc->sas_hba.phy[i].handle = mrioc->sas_hba.handle;
mrioc->sas_hba.phy[i].phy_id = i;
mrioc->sas_hba.phy[i].hba_port =
mpi3mr_get_hba_port_by_id(mrioc, port_id);
mpi3mr_add_host_phy(mrioc, &mrioc->sas_hba.phy[i],
phy_pg0, mrioc->sas_hba.parent_dev);
if (mpi3mr_add_host_phy(mrioc, &mrioc->sas_hba.phy[i],
phy_pg0, mrioc->sas_hba.parent_dev))
goto out_free_phy;
}
if ((mpi3mr_cfg_get_dev_pg0(mrioc, &ioc_status, &dev_pg0,
sizeof(dev_pg0), MPI3_DEVICE_PGAD_FORM_HANDLE,
mrioc->sas_hba.handle))) {
ioc_err(mrioc, "%s: device page0 read failed\n", __func__);
goto out;
goto out_free_phy;
}
if (ioc_status != MPI3_IOCSTATUS_SUCCESS) {
ioc_err(mrioc, "device page read failed for handle(0x%04x), with ioc_status(0x%04x) failure at %s:%d/%s()!\n",
mrioc->sas_hba.handle, ioc_status, __FILE__, __LINE__,
__func__);
goto out;
goto out_free_phy;
}
mrioc->sas_hba.enclosure_handle =
le16_to_cpu(dev_pg0.enclosure_handle);
@ -1306,6 +1315,17 @@ void mpi3mr_sas_host_add(struct mpi3mr_ioc *mrioc)
le64_to_cpu(encl_pg0.enclosure_logical_id);
}
goto out;
out_free_phy:
for (i = 0; i < mrioc->sas_hba.num_phys; i++) {
if (mrioc->sas_hba.phy[i].phy)
sas_phy_delete(mrioc->sas_hba.phy[i].phy);
}
kfree(mrioc->sas_hba.phy);
mrioc->sas_hba.phy = NULL;
mrioc->sas_hba.num_phys = 0;
out:
kfree(sas_io_unit_pg0);
}
@ -1330,6 +1350,7 @@ static struct mpi3mr_sas_port *mpi3mr_sas_port_add(struct mpi3mr_ioc *mrioc,
struct mpi3mr_sas_phy *mr_sas_phy, *next;
struct mpi3mr_sas_port *mr_sas_port;
unsigned long flags;
bool discard = false;
struct mpi3mr_sas_node *mr_sas_node;
struct sas_rphy *rphy;
struct mpi3mr_tgt_dev *tgtdev = NULL;
@ -1429,7 +1450,7 @@ static struct mpi3mr_sas_port *mpi3mr_sas_port_add(struct mpi3mr_ioc *mrioc,
port = sas_port_alloc_num(mr_sas_node->parent_dev);
if (!port) {
ioc_err(mrioc, "failure at %s:%d/%s()!\n",
ioc_err(mrioc, "failure at %s:%d/%s() (sas_port_alloc)!\n",
__FILE__, __LINE__, __func__);
goto out_fail;
}
@ -1456,19 +1477,51 @@ static struct mpi3mr_sas_port *mpi3mr_sas_port_add(struct mpi3mr_ioc *mrioc,
mr_sas_port->port = port;
if (mr_sas_port->remote_identify.device_type == SAS_END_DEVICE) {
rphy = sas_end_device_alloc(port);
if (!rphy) {
ioc_err(mrioc, "failure at %s:%d/%s() (sas_end_device_alloc)!\n",
__FILE__, __LINE__, __func__);
sas_port_delete(port);
goto out_fail;
}
tgtdev->dev_spec.sas_sata_inf.rphy = rphy;
} else {
rphy = sas_expander_alloc(port,
mr_sas_port->remote_identify.device_type);
if (!rphy) {
ioc_err(mrioc, "failure at %s:%d/%s() (sas_expander_alloc)!\n",
__FILE__, __LINE__, __func__);
sas_port_delete(port);
goto out_fail;
}
}
rphy->identify = mr_sas_port->remote_identify;
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->stop_drv_processing || mrioc->reset_in_progress) {
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
sas_rphy_free(rphy);
sas_port_delete(port);
goto out_fail;
}
if (mrioc->current_event)
mrioc->current_event->pending_at_sml = 1;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if ((sas_rphy_add(rphy))) {
ioc_err(mrioc, "failure at %s:%d/%s()!\n",
__FILE__, __LINE__, __func__);
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event) {
mrioc->current_event->pending_at_sml = 0;
discard = mrioc->current_event->discard;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (discard)
mpi3mr_print_device_event_notice(mrioc, true);
sas_rphy_unlink(rphy);
sas_rphy_free(rphy);
sas_port_delete(port);
goto out_fail;
}
if (mr_sas_port->remote_identify.device_type == SAS_END_DEVICE) {
tgtdev->dev_spec.sas_sata_inf.pend_sas_rphy_add = 0;
@ -1486,11 +1539,14 @@ static struct mpi3mr_sas_port *mpi3mr_sas_port_add(struct mpi3mr_ioc *mrioc,
list_add_tail(&mr_sas_port->port_list, &mr_sas_node->sas_port_list);
spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event) {
mrioc->current_event->pending_at_sml = 0;
if (mrioc->current_event->discard)
mpi3mr_print_device_event_notice(mrioc, true);
discard = mrioc->current_event->discard;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (discard)
mpi3mr_print_device_event_notice(mrioc, true);
/* fill in report manufacture */
if (mr_sas_port->remote_identify.device_type ==
@ -1504,11 +1560,17 @@ static struct mpi3mr_sas_port *mpi3mr_sas_port_add(struct mpi3mr_ioc *mrioc,
return mr_sas_port;
out_fail:
list_for_each_entry_safe(mr_sas_phy, next, &mr_sas_port->phy_list,
port_siblings)
list_del(&mr_sas_phy->port_siblings);
if (tgtdev)
if (tgtdev) {
tgtdev->dev_spec.sas_sata_inf.pend_sas_rphy_add = 0;
tgtdev->dev_spec.sas_sata_inf.rphy = NULL;
mpi3mr_tgtdev_put(tgtdev);
}
list_for_each_entry_safe(mr_sas_phy, next, &mr_sas_port->phy_list,
port_siblings) {
mr_sas_phy->phy_belongs_to_port = 0;
list_del(&mr_sas_phy->port_siblings);
}
kfree(mr_sas_port);
return NULL;
}
@ -1530,6 +1592,7 @@ static void mpi3mr_sas_port_remove(struct mpi3mr_ioc *mrioc, u64 sas_address,
{
int i;
unsigned long flags;
bool discard = false;
struct mpi3mr_sas_port *mr_sas_port, *next;
struct mpi3mr_sas_node *mr_sas_node;
u8 found = 0;
@ -1586,8 +1649,10 @@ static void mpi3mr_sas_port_remove(struct mpi3mr_ioc *mrioc, u64 sas_address,
spin_unlock_irqrestore(&mrioc->sas_node_lock, flags);
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event)
mrioc->current_event->pending_at_sml = 1;
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
list_for_each_entry_safe(mr_sas_phy, next_phy,
&mr_sas_port->phy_list, port_siblings) {
@ -1609,11 +1674,14 @@ static void mpi3mr_sas_port_remove(struct mpi3mr_ioc *mrioc, u64 sas_address,
ioc_info(mrioc, "%s: removed sas_address(0x%016llx)\n",
__func__, (unsigned long long)sas_address);
spin_lock_irqsave(&mrioc->fwevt_lock, flags);
if (mrioc->current_event) {
mrioc->current_event->pending_at_sml = 0;
if (mrioc->current_event->discard)
mpi3mr_print_device_event_notice(mrioc, false);
discard = mrioc->current_event->discard;
}
spin_unlock_irqrestore(&mrioc->fwevt_lock, flags);
if (discard)
mpi3mr_print_device_event_notice(mrioc, false);
kfree(mr_sas_port);
}

69
drivers/scsi/mpt3sas/mpt3sas_scsih.c
View File

@ -5401,23 +5401,23 @@ _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
static void
_scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
{
u8 ascq;
u16 sense_code;
switch (ioc_status) {
case MPI2_IOCSTATUS_EEDP_GUARD_ERROR:
ascq = 0x01;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR:
ascq = 0x02;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
break;
case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR:
ascq = 0x03;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
break;
default:
ascq = 0x00;
sense_code = ID_CRC_OR_ECC_ERROR;
break;
}
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x10, ascq);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, sense_code);
set_host_byte(scmd, DID_ABORT);
}
@ -5474,7 +5474,8 @@ static enum scsi_qc_status scsih_qcmd(struct Scsi_Host *shost,
if (handle == MPT3SAS_INVALID_DEVICE_HANDLE || sas_device_priv_data->block) {
if (scsi_get_host_state(scmd->device->host) == SHOST_RECOVERY &&
scmd->cmnd[0] == TEST_UNIT_READY) {
scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07);
scsi_set_sense(scmd, 0, UNIT_ATTENTION,
I_T_NEXUS_LOSS_OCCURRED);
scsi_done(scmd);
return 0;
}
@ -5986,7 +5987,7 @@ _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle)
event_data = (Mpi2EventDataSasDeviceStatusChange_t *)
event_reply->EventData;
event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA;
event_data->ASC = 0x5D;
event_data->ASC = ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED;
event_data->DevHandle = cpu_to_le16(handle);
event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address);
mpt3sas_ctl_add_to_event_log(ioc, event_reply);
@ -6109,8 +6110,7 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
le32_to_cpu(mpi_reply->SenseCount));
memcpy(scmd->sense_buffer, sense_data, sz);
_scsih_normalize_sense(scmd->sense_buffer, &data);
/* failure prediction threshold exceeded */
if (data.asc == 0x5D)
if (data.asc == ASC_FAILURE_PREDICTION_THRESHOLD_EXCEEDED)
_scsih_smart_predicted_fault(ioc,
le16_to_cpu(mpi_reply->DevHandle));
mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq);
@ -6199,8 +6199,8 @@ _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) {
mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID;
mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION;
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST,
0x20, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
}
break;
@ -7691,38 +7691,41 @@ _scsih_determine_disposition(struct MPT3SAS_ADAPTER *ioc,
if (check_sense) {
_scsih_normalize_sense(transfer_packet->sense, &sense_info);
if (sense_info.skey == UNIT_ATTENTION)
if (sense_info.skey == UNIT_ATTENTION) {
rc = DEVICE_RETRY_UA;
else if (sense_info.skey == NOT_READY) {
/* medium isn't present */
if (sense_info.asc == 0x3a)
} else if (sense_info.skey == NOT_READY) {
if (sense_info.asc == ASC_MEDIUM_NOT_PRESENT) {
rc = DEVICE_READY;
/* LOGICAL UNIT NOT READY */
else if (sense_info.asc == 0x04) {
if (sense_info.ascq == 0x03 ||
sense_info.ascq == 0x0b ||
sense_info.ascq == 0x0c) {
} else if (sense_info.asc == ASC_LU_NOT_READY) {
u16 scode = scsi_sense_code(sense_info.asc,
sense_info.ascq);
if (scode ==
LU_NOT_READY_MANUAL_INTERVENTION_REQUIRED ||
scode ==
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_STANDBY_STATE ||
scode ==
LU_NOT_ACCESSIBLE_TARGET_PORT_IN_UNAVAILABLE_STATE)
rc = DEVICE_ERROR;
} else
else
rc = DEVICE_START_UNIT;
}
/* LOGICAL UNIT HAS NOT SELF-CONFIGURED YET */
else if (sense_info.asc == 0x3e && !sense_info.ascq)
} else if (sense_info.asc ==
ASC_LU_HAS_NOT_SELF_CONFIGURED_YET &&
!sense_info.ascq) {
rc = DEVICE_START_UNIT;
}
} else if (sense_info.skey == ILLEGAL_REQUEST &&
transfer_packet->cdb[0] == REPORT_LUNS) {
transfer_packet->cdb[0] == REPORT_LUNS) {
rc = DEVICE_READY;
} else if (sense_info.skey == MEDIUM_ERROR) {
/* medium is corrupt, lets add the device so
* users can collect some info as needed
/*
* medium is corrupt, lets add the device so users can
* collect some info as needed
*/
if (sense_info.asc == 0x31)
if (sense_info.asc == ASC_MEDIUM_FORMAT_CORRUPTED)
rc = DEVICE_READY;
} else if (sense_info.skey == HARDWARE_ERROR) {
/* Defect List Error, still add the device */
if (sense_info.asc == 0x19)
if (sense_info.asc == ASC_DEFECT_LIST_ERROR)
rc = DEVICE_READY;
}
}

28
drivers/scsi/mvumi.c
View File

@ -722,9 +722,9 @@ static int mvumi_issue_blocked_cmd(struct mvumi_hba *mhba,
return -1;
}
atomic_inc(&cmd->sync_cmd);
spin_lock_irqsave(mhba->shost->host_lock, flags);
spin_lock_irqsave(&mhba->shost->host_lock, flags);
mhba->instancet->fire_cmd(mhba, cmd);
spin_unlock_irqrestore(mhba->shost->host_lock, flags);
spin_unlock_irqrestore(&mhba->shost->host_lock, flags);
wait_event_timeout(mhba->int_cmd_wait_q,
(cmd->cmd_status != REQ_STATUS_PENDING),
@ -732,7 +732,7 @@ static int mvumi_issue_blocked_cmd(struct mvumi_hba *mhba,
/* command timeout */
if (atomic_read(&cmd->sync_cmd)) {
spin_lock_irqsave(mhba->shost->host_lock, flags);
spin_lock_irqsave(&mhba->shost->host_lock, flags);
atomic_dec(&cmd->sync_cmd);
if (mhba->tag_cmd[cmd->frame->tag]) {
mhba->tag_cmd[cmd->frame->tag] = NULL;
@ -747,7 +747,7 @@ static int mvumi_issue_blocked_cmd(struct mvumi_hba *mhba,
} else
atomic_dec(&mhba->fw_outstanding);
spin_unlock_irqrestore(mhba->shost->host_lock, flags);
spin_unlock_irqrestore(&mhba->shost->host_lock, flags);
}
return 0;
}
@ -1791,9 +1791,9 @@ static irqreturn_t mvumi_isr_handler(int irq, void *devp)
struct mvumi_hba *mhba = (struct mvumi_hba *) devp;
unsigned long flags;
spin_lock_irqsave(mhba->shost->host_lock, flags);
spin_lock_irqsave(&mhba->shost->host_lock, flags);
if (unlikely(mhba->instancet->clear_intr(mhba) || !mhba->global_isr)) {
spin_unlock_irqrestore(mhba->shost->host_lock, flags);
spin_unlock_irqrestore(&mhba->shost->host_lock, flags);
return IRQ_NONE;
}
@ -1814,7 +1814,7 @@ static irqreturn_t mvumi_isr_handler(int irq, void *devp)
mhba->isr_status = 0;
if (mhba->fw_state == FW_STATE_STARTED)
mvumi_handle_clob(mhba);
spin_unlock_irqrestore(mhba->shost->host_lock, flags);
spin_unlock_irqrestore(&mhba->shost->host_lock, flags);
return IRQ_HANDLED;
}
@ -2067,7 +2067,7 @@ static unsigned char mvumi_build_frame(struct mvumi_hba *mhba,
return 0;
error:
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST, INVALID_FIELD_IN_CDB);
return -1;
}
@ -2083,13 +2083,13 @@ static enum scsi_qc_status mvumi_queue_command(struct Scsi_Host *shost,
struct mvumi_hba *mhba;
unsigned long irq_flags;
spin_lock_irqsave(shost->host_lock, irq_flags);
spin_lock_irqsave(&shost->host_lock, irq_flags);
mhba = (struct mvumi_hba *) shost->hostdata;
scmd->result = 0;
cmd = mvumi_get_cmd(mhba);
if (unlikely(!cmd)) {
spin_unlock_irqrestore(shost->host_lock, irq_flags);
spin_unlock_irqrestore(&shost->host_lock, irq_flags);
return SCSI_MLQUEUE_HOST_BUSY;
}
@ -2099,13 +2099,13 @@ static enum scsi_qc_status mvumi_queue_command(struct Scsi_Host *shost,
cmd->scmd = scmd;
mvumi_priv(scmd)->cmd_priv = cmd;
mhba->instancet->fire_cmd(mhba, cmd);
spin_unlock_irqrestore(shost->host_lock, irq_flags);
spin_unlock_irqrestore(&shost->host_lock, irq_flags);
return 0;
out_return_cmd:
mvumi_return_cmd(mhba, cmd);
scsi_done(scmd);
spin_unlock_irqrestore(shost->host_lock, irq_flags);
spin_unlock_irqrestore(&shost->host_lock, irq_flags);
return 0;
}
@ -2116,7 +2116,7 @@ static enum scsi_timeout_action mvumi_timed_out(struct scsi_cmnd *scmd)
struct mvumi_hba *mhba = shost_priv(host);
unsigned long flags;
spin_lock_irqsave(mhba->shost->host_lock, flags);
spin_lock_irqsave(&mhba->shost->host_lock, flags);
if (mhba->tag_cmd[cmd->frame->tag]) {
mhba->tag_cmd[cmd->frame->tag] = NULL;
@ -2135,7 +2135,7 @@ static enum scsi_timeout_action mvumi_timed_out(struct scsi_cmnd *scmd)
scmd->sc_data_direction);
}
mvumi_return_cmd(mhba, cmd);
spin_unlock_irqrestore(mhba->shost->host_lock, flags);
spin_unlock_irqrestore(&mhba->shost->host_lock, flags);
return SCSI_EH_NOT_HANDLED;
}

67
drivers/scsi/myrb.c
View File

@ -314,17 +314,19 @@ static void myrb_get_event(struct myrb_hba *cb, unsigned int event)
scsi_normalize_sense(ev_buf->sense, 32, &sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
sshdr.asc == 0x80 &&
sshdr.ascq < ARRAY_SIZE(myrb_event_msg))
scsi_sense_asc(&sshdr) == 0x80 &&
scsi_sense_ascq(&sshdr) < ARRAY_SIZE(myrb_event_msg))
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: %s\n",
ev_buf->channel, ev_buf->target,
myrb_event_msg[sshdr.ascq]);
myrb_event_msg[scsi_sense_ascq(&sshdr)]);
else
shost_printk(KERN_CRIT, cb->host,
"Physical drive %d:%d: Sense: %X/%02X/%02X\n",
ev_buf->channel, ev_buf->target,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key,
scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
}
dma_free_coherent(&cb->pdev->dev, sizeof(struct myrb_log_entry),
@ -1398,7 +1400,7 @@ myrb_mode_sense(struct myrb_hba *cb, struct scsi_cmnd *scmd,
static void myrb_request_sense(struct myrb_hba *cb,
struct scsi_cmnd *scmd)
{
scsi_build_sense(scmd, 0, NO_SENSE, 0, 0);
scsi_set_sense(scmd, 0, NO_SENSE, NO_ADDITIONAL_SENSE_INFORMATION);
scsi_sg_copy_from_buffer(scmd, scmd->sense_buffer,
SCSI_SENSE_BUFFERSIZE);
}
@ -1446,8 +1448,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case INQUIRY:
if (scmd->cmnd[1] & 1) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrb_inquiry(cb, scmd);
scmd->result = (DID_OK << 16);
@ -1461,8 +1463,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case MODE_SENSE:
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrb_mode_sense(cb, scmd, ldev_info);
scmd->result = (DID_OK << 16);
@ -1472,15 +1474,15 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
case READ_CAPACITY:
if ((scmd->cmnd[1] & 1) ||
(scmd->cmnd[8] & 1)) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
lba = get_unaligned_be32(&scmd->cmnd[2]);
if (lba) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
scsi_done(scmd);
return 0;
}
@ -1493,8 +1495,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case SEND_DIAGNOSTIC:
if (scmd->cmnd[1] != 0x04) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
/* Assume good status */
scmd->result = (DID_OK << 16);
@ -1503,8 +1505,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
return 0;
case READ_6:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1517,8 +1519,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_10:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1531,8 +1533,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
break;
case READ_12:
if (ldev_info->state == MYRB_DEVICE_WO) {
/* Data protect, attempt to read invalid data */
scsi_build_sense(scmd, 0, DATA_PROTECT, 0x21, 0x06);
scsi_set_sense(scmd, 0, DATA_PROTECT,
ATTEMPT_TO_READ_INVALID_DATA);
scsi_done(scmd);
return 0;
}
@ -1544,8 +1546,8 @@ static enum scsi_qc_status myrb_ldev_queuecommand(struct Scsi_Host *shost,
block_cnt = get_unaligned_be32(&scmd->cmnd[6]);
break;
default:
/* Illegal request, invalid opcode */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
}
@ -2328,20 +2330,19 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
dev_dbg(&scmd->device->sdev_gendev,
"Bad Data Encountered\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
/* Unrecovered read error */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
UNRECOVERED_READ_ERROR);
else
/* Write error */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0);
scsi_set_sense(scmd, 0, MEDIUM_ERROR, SSC_WRITE_ERROR);
break;
case MYRB_STATUS_IRRECOVERABLE_DATA_ERROR:
scmd_printk(KERN_ERR, scmd, "Irrecoverable Data Error\n");
if (scmd->sc_data_direction == DMA_FROM_DEVICE)
/* Unrecovered read error, auto-reallocation failed */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x11, 0x04);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
UNRECOVERED_READ_ERROR_AUTO_REALLOCATE_FAILED);
else
/* Write error, auto-reallocation failed */
scsi_build_sense(scmd, 0, MEDIUM_ERROR, 0x0C, 0x02);
scsi_set_sense(scmd, 0, MEDIUM_ERROR,
WRITE_ERROR_AUTO_REALLOCATION_FAILED);
break;
case MYRB_STATUS_LDRV_NONEXISTENT_OR_OFFLINE:
dev_dbg(&scmd->device->sdev_gendev,
@ -2351,8 +2352,8 @@ static void myrb_handle_scsi(struct myrb_hba *cb, struct myrb_cmdblk *cmd_blk,
case MYRB_STATUS_ACCESS_BEYOND_END_OF_LDRV:
dev_dbg(&scmd->device->sdev_gendev,
"Attempt to Access Beyond End of Logical Drive");
/* Logical block address out of range */
scsi_build_sense(scmd, 0, NOT_READY, 0x21, 0);
scsi_set_sense(scmd, 0, NOT_READY,
LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE);
break;
case MYRB_STATUS_DEVICE_NONRESPONSIVE:
dev_dbg(&scmd->device->sdev_gendev, "Device nonresponsive\n");

23
drivers/scsi/myrs.c
View File

@ -816,7 +816,7 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
struct Scsi_Host *shost = cs->host;
struct scsi_device *sdev;
struct scsi_sense_hdr sshdr = {0};
unsigned char sense_info[4];
unsigned char asc, sense_info[4];
unsigned char cmd_specific[4];
if (ev->ev_code == 0x1C) {
@ -829,9 +829,11 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
memcpy(cmd_specific, &ev->sense_data[7], 4);
}
}
asc = scsi_sense_asc(&sshdr);
if (sshdr.sense_key == VENDOR_SPECIFIC &&
(sshdr.asc == 0x80 || sshdr.asc == 0x81))
ev->ev_code = ((sshdr.asc - 0x80) << 8 | sshdr.ascq);
(asc == 0x80 || asc == 0x81))
ev->ev_code = scsi_sense_code(asc - 0x80,
scsi_sense_ascq(&sshdr));
while (true) {
ev_code = myrs_ev_list[ev_idx].ev_code;
if (ev_code == ev->ev_code || ev_code == 0)
@ -891,8 +893,9 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
case 'S':
if (sshdr.sense_key == NO_SENSE ||
(sshdr.sense_key == NOT_READY &&
sshdr.asc == 0x04 && (sshdr.ascq == 0x01 ||
sshdr.ascq == 0x02)))
(sshdr.sense_code == LU_IS_IN_PROCESS_OF_BECOMING_READY ||
sshdr.sense_code ==
LU_NOT_READY_INITIALIZING_COMMAND_REQUIRED)))
break;
shost_printk(KERN_INFO, shost,
"event %d: Physical Device %d:%d %s\n",
@ -900,7 +903,8 @@ static void myrs_log_event(struct myrs_hba *cs, struct myrs_event *ev)
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Key = %X, ASC = %02X, ASCQ = %02X\n",
ev->channel, ev->target,
sshdr.sense_key, sshdr.asc, sshdr.ascq);
sshdr.sense_key, scsi_sense_asc(&sshdr),
scsi_sense_ascq(&sshdr));
shost_printk(KERN_INFO, shost,
"Physical Device %d:%d Sense Information = %02X%02X%02X%02X %02X%02X%02X%02X\n",
ev->channel, ev->target,
@ -1603,7 +1607,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
switch (scmd->cmnd[0]) {
case REPORT_LUNS:
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x20, 0x0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_COMMAND_OP_CODE);
scsi_done(scmd);
return 0;
case MODE_SENSE:
@ -1612,8 +1617,8 @@ static enum scsi_qc_status myrs_queuecommand(struct Scsi_Host *shost,
if ((scmd->cmnd[2] & 0x3F) != 0x3F &&
(scmd->cmnd[2] & 0x3F) != 0x08) {
/* Illegal request, invalid field in CDB */
scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x24, 0);
scsi_set_sense(scmd, 0, ILLEGAL_REQUEST,
INVALID_FIELD_IN_CDB);
} else {
myrs_mode_sense(cs, scmd, ldev_info);
scmd->result = (DID_OK << 16);

8
drivers/scsi/nsp32.c
View File

@ -1166,7 +1166,7 @@ static irqreturn_t do_nsp32_isr(int irq, void *dev_id)
int handled = 0;
struct Scsi_Host *host = data->Host;
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
/*
* IRQ check, then enable IRQ mask
@ -1433,7 +1433,7 @@ static irqreturn_t do_nsp32_isr(int irq, void *dev_id)
nsp32_write2(base, IRQ_CONTROL, 0);
out2:
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
nsp32_dbg(NSP32_DEBUG_INTR, "exit");
@ -2886,14 +2886,14 @@ static int nsp32_eh_host_reset(struct scsi_cmnd *SCpnt)
nsp32_msg(KERN_INFO, "Host Reset");
nsp32_dbg(NSP32_DEBUG_BUSRESET, "SCpnt=0x%x", SCpnt);
spin_lock_irq(SCpnt->device->host->host_lock);
spin_lock_irq(&SCpnt->device->host->host_lock);
nsp32hw_init(data);
nsp32_write2(base, IRQ_CONTROL, IRQ_CONTROL_ALL_IRQ_MASK);
nsp32_do_bus_reset(data);
nsp32_write2(base, IRQ_CONTROL, 0);
spin_unlock_irq(SCpnt->device->host->host_lock);
spin_unlock_irq(&SCpnt->device->host->host_lock);
return SUCCESS; /* Host reset is succeeded at any time. */
}

8
drivers/scsi/pcmcia/sym53c500_cs.c
View File

@ -360,7 +360,7 @@ SYM53C500_intr(int irq, void *dev_id)
struct sym53c500_cmd_priv *scp = scsi_cmd_priv(curSC);
int fast_pio = data->fast_pio;
spin_lock_irqsave(dev->host_lock, flags);
spin_lock_irqsave(&dev->host_lock, flags);
VDEB(printk("SYM53C500_intr called\n"));
@ -494,7 +494,7 @@ SYM53C500_intr(int irq, void *dev_id)
break;
}
out:
spin_unlock_irqrestore(dev->host_lock, flags);
spin_unlock_irqrestore(&dev->host_lock, flags);
return IRQ_HANDLED;
idle_out:
@ -588,9 +588,9 @@ SYM53C500_host_reset(struct scsi_cmnd *SCpnt)
int port_base = SCpnt->device->host->io_port;
DEB(printk("SYM53C500_host_reset called\n"));
spin_lock_irq(SCpnt->device->host->host_lock);
spin_lock_irq(&SCpnt->device->host->host_lock);
SYM53C500_int_host_reset(port_base);
spin_unlock_irq(SCpnt->device->host->host_lock);
spin_unlock_irq(&SCpnt->device->host->host_lock);
return SUCCESS;
}

98
drivers/scsi/pm8001/pm8001_defs.h
View File

@ -41,6 +41,104 @@
#ifndef _PM8001_DEFS_H_
#define _PM8001_DEFS_H_
#include <scsi/sas.h>
#ifdef __LITTLE_ENDIAN_BITFIELD
struct sas_identify_frame_local {
/* Byte 0 */
u8 frame_type:4;
u8 dev_type:3;
u8 _un0:1;
/* Byte 1 */
u8 _un1;
/* Byte 2 */
union {
struct {
u8 _un20:1;
u8 smp_iport:1;
u8 stp_iport:1;
u8 ssp_iport:1;
u8 _un247:4;
};
u8 initiator_bits;
};
/* Byte 3 */
union {
struct {
u8 _un30:1;
u8 smp_tport:1;
u8 stp_tport:1;
u8 ssp_tport:1;
u8 _un347:4;
};
u8 target_bits;
};
/* Byte 4 - 11 */
u8 _un4_11[8];
/* Byte 12 - 19 */
u8 sas_addr[SAS_ADDR_SIZE];
/* Byte 20 */
u8 phy_id;
u8 _un21_27[7];
} __packed;
#elif defined(__BIG_ENDIAN_BITFIELD)
struct sas_identify_frame_local {
/* Byte 0 */
u8 _un0:1;
u8 dev_type:3;
u8 frame_type:4;
/* Byte 1 */
u8 _un1;
/* Byte 2 */
union {
struct {
u8 _un247:4;
u8 ssp_iport:1;
u8 stp_iport:1;
u8 smp_iport:1;
u8 _un20:1;
};
u8 initiator_bits;
};
/* Byte 3 */
union {
struct {
u8 _un347:4;
u8 ssp_tport:1;
u8 stp_tport:1;
u8 smp_tport:1;
u8 _un30:1;
};
u8 target_bits;
};
/* Byte 4 - 11 */
u8 _un4_11[8];
/* Byte 12 - 19 */
u8 sas_addr[SAS_ADDR_SIZE];
/* Byte 20 */
u8 phy_id;
u8 _un21_27[7];
} __packed;
#else
#error "Bitfield order not defined!"
#endif
enum chip_flavors {
chip_8001,
chip_8008,

2
drivers/scsi/pm8001/pm8001_hwi.c
View File

@ -3208,7 +3208,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
phy->sas_phy.oob_mode = SATA_OOB_MODE;
sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE, GFP_ATOMIC);
spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
memcpy(phy->frame_rcvd, &pPayload->sata_fis,
sizeof(struct dev_to_host_fis));
phy->frame_rcvd_size = sizeof(struct dev_to_host_fis);
phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;

4
drivers/scsi/pm8001/pm8001_hwi.h
View File

@ -42,6 +42,7 @@
#include <linux/types.h>
#include <scsi/libsas.h>
#include "pm8001_defs.h"
/* for Request Opcode of IOMB */
@ -229,8 +230,9 @@ struct hw_event_resp {
__le32 lr_evt_status_phyid_portid;
__le32 evt_param;
__le32 npip_portstate;
struct sas_identify_frame sas_identify;
struct sas_identify_frame_local sas_identify;
struct dev_to_host_fis sata_fis;
u32 _r_a;
} __attribute__((packed, aligned(4)));

2
drivers/scsi/pm8001/pm80xx_hwi.c
View File

@ -3296,7 +3296,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
phy->sas_phy.oob_mode = SATA_OOB_MODE;
sas_notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE, GFP_ATOMIC);
spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
memcpy(phy->frame_rcvd, &pPayload->sata_fis,
sizeof(struct dev_to_host_fis));
phy->frame_rcvd_size = sizeof(struct dev_to_host_fis);
phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;

100
drivers/scsi/pm8001/pm80xx_hwi.h
View File

@ -43,6 +43,7 @@
#include <linux/types.h>
#include <scsi/libsas.h>
#include "pm8001_defs.h"
/* for Request Opcode of IOMB */
#define OPC_INB_ECHO 1 /* 0x000 */
@ -236,102 +237,6 @@
/* Port recovery timeout, 10000 ms for PM8006 controller */
#define CHIP_8006_PORT_RECOVERY_TIMEOUT 0x640000
#ifdef __LITTLE_ENDIAN_BITFIELD
struct sas_identify_frame_local {
/* Byte 0 */
u8 frame_type:4;
u8 dev_type:3;
u8 _un0:1;
/* Byte 1 */
u8 _un1;
/* Byte 2 */
union {
struct {
u8 _un20:1;
u8 smp_iport:1;
u8 stp_iport:1;
u8 ssp_iport:1;
u8 _un247:4;
};
u8 initiator_bits;
};
/* Byte 3 */
union {
struct {
u8 _un30:1;
u8 smp_tport:1;
u8 stp_tport:1;
u8 ssp_tport:1;
u8 _un347:4;
};
u8 target_bits;
};
/* Byte 4 - 11 */
u8 _un4_11[8];
/* Byte 12 - 19 */
u8 sas_addr[SAS_ADDR_SIZE];
/* Byte 20 */
u8 phy_id;
u8 _un21_27[7];
} __packed;
#elif defined(__BIG_ENDIAN_BITFIELD)
struct sas_identify_frame_local {
/* Byte 0 */
u8 _un0:1;
u8 dev_type:3;
u8 frame_type:4;
/* Byte 1 */
u8 _un1;
/* Byte 2 */
union {
struct {
u8 _un247:4;
u8 ssp_iport:1;
u8 stp_iport:1;
u8 smp_iport:1;
u8 _un20:1;
};
u8 initiator_bits;
};
/* Byte 3 */
union {
struct {
u8 _un347:4;
u8 ssp_tport:1;
u8 stp_tport:1;
u8 smp_tport:1;
u8 _un30:1;
};
u8 target_bits;
};
/* Byte 4 - 11 */
u8 _un4_11[8];
/* Byte 12 - 19 */
u8 sas_addr[SAS_ADDR_SIZE];
/* Byte 20 */
u8 phy_id;
u8 _un21_27[7];
} __packed;
#else
#error "Bitfield order not defined!"
#endif
struct mpi_msg_hdr {
__le32 header; /* Bits [11:0] - Message operation code */
/* Bits [15:12] - Message Category */
@ -427,8 +332,9 @@ struct hw_event_resp {
__le32 lr_status_evt_portid;
__le32 evt_param;
__le32 phyid_npip_portstate;
struct sas_identify_frame sas_identify;
struct sas_identify_frame_local sas_identify;
struct dev_to_host_fis sata_fis;
u32 _r_a;
} __attribute__((packed, aligned(4)));
/*

84
drivers/scsi/pmcraid.c
View File

@ -497,10 +497,10 @@ static void pmcraid_clr_trans_op(
if (pinstance->reset_cmd != NULL) {
timer_delete(&pinstance->reset_cmd->timer);
spin_lock_irqsave(
pinstance->host->host_lock, lock_flags);
&pinstance->host->host_lock, lock_flags);
pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);
spin_unlock_irqrestore(
pinstance->host->host_lock, lock_flags);
&pinstance->host->host_lock, lock_flags);
}
}
@ -562,9 +562,9 @@ static void pmcraid_bist_done(struct timer_list *t)
} else {
cmd->time_left = 0;
pmcraid_info("BIST is complete, proceeding with reset\n");
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pmcraid_ioa_reset(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
}
}
@ -613,9 +613,9 @@ static void pmcraid_reset_alert_done(struct timer_list *t)
if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) ||
cmd->time_left <= 0) {
pmcraid_info("critical op is reset proceeding with reset\n");
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pmcraid_ioa_reset(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
} else {
pmcraid_info("critical op is not yet reset waiting again\n");
/* restart timer if some more time is available to wait */
@ -699,7 +699,7 @@ static void pmcraid_timeout_handler(struct timer_list *t)
* reset is in progress. Otherwise fail this command and get a free
* command block to restart the reset sequence.
*/
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
if (!pinstance->ioa_reset_in_progress) {
pinstance->ioa_reset_attempts = 0;
cmd = pmcraid_get_free_cmd(pinstance);
@ -708,7 +708,7 @@ static void pmcraid_timeout_handler(struct timer_list *t)
* Some other command's timeout handler can do the reset job
*/
if (cmd == NULL) {
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
lock_flags);
pmcraid_err("no free cmnd block for timeout handler\n");
return;
@ -745,7 +745,7 @@ static void pmcraid_timeout_handler(struct timer_list *t)
pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
scsi_block_requests(pinstance->host);
pmcraid_reset_alert(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
}
/**
@ -921,9 +921,9 @@ static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)
struct pmcraid_instance *pinstance = cmd->drv_inst;
unsigned long lock_flags;
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pmcraid_ioa_reset(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
}
/**
@ -982,10 +982,10 @@ static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)
*/
if (ioasc) {
pmcraid_err("IOA Inquiry failed with %x\n", ioasc);
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
pmcraid_reset_alert(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
} else {
pmcraid_querycfg(cmd);
}
@ -1596,11 +1596,11 @@ static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
spin_unlock_irqrestore(&pinstance->resource_lock,
lock_flags);
pmcraid_err("too many resources attached\n");
spin_lock_irqsave(pinstance->host->host_lock,
spin_lock_irqsave(&pinstance->host->host_lock,
host_lock_flags);
pmcraid_send_hcam(pinstance,
PMCRAID_HCAM_CODE_CONFIG_CHANGE);
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
host_lock_flags);
return;
}
@ -1760,9 +1760,9 @@ static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)
} else if (ioasc) {
dev_info(&pinstance->pdev->dev,
"Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc);
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
} else {
pmcraid_handle_config_change(pinstance);
}
@ -1800,10 +1800,10 @@ static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)
} else if (!ioasc) {
pmcraid_handle_error_log(pinstance);
if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) {
spin_lock_irqsave(pinstance->host->host_lock,
spin_lock_irqsave(&pinstance->host->host_lock,
lock_flags);
pmcraid_initiate_reset(pinstance);
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
lock_flags);
return;
}
@ -2322,17 +2322,17 @@ static int pmcraid_reset_reload(
unsigned long lock_flags;
int reset = 1;
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
if (pinstance->ioa_reset_in_progress) {
pmcraid_info("reset_reload: reset is already in progress\n");
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
wait_event(pinstance->reset_wait_q,
!pinstance->ioa_reset_in_progress);
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
if (pinstance->ioa_state == IOA_STATE_DEAD) {
pmcraid_info("reset_reload: IOA is dead\n");
@ -2361,7 +2361,7 @@ static int pmcraid_reset_reload(
pinstance->force_ioa_reset = reset;
pmcraid_info("reset_reload: initiating reset\n");
pmcraid_ioa_reset(reset_cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
pmcraid_info("reset_reload: waiting for reset to complete\n");
wait_event(pinstance->reset_wait_q,
!pinstance->ioa_reset_in_progress);
@ -2371,7 +2371,7 @@ static int pmcraid_reset_reload(
return pinstance->ioa_state != target_state;
out_unlock:
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
return reset;
}
@ -2719,10 +2719,10 @@ static int pmcraid_reset_device(
* This will force the mid-layer to call _eh_bus/host reset, which
* will then go to sleep and wait for the reset to complete
*/
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
if (pinstance->ioa_reset_in_progress ||
pinstance->ioa_state == IOA_STATE_DEAD) {
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
return FAILED;
}
@ -2736,7 +2736,7 @@ static int pmcraid_reset_device(
cmd = pmcraid_get_free_cmd(pinstance);
if (cmd == NULL) {
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
pmcraid_err("%s: no cmd blocks are available\n", __func__);
return FAILED;
}
@ -2765,7 +2765,7 @@ static int pmcraid_reset_device(
timeout,
pmcraid_timeout_handler);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
/* RESET_DEVICE command completes after all pending IOARCBs are
* completed. Once this command is completed, pmcraind_internal_done
@ -2960,11 +2960,11 @@ static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)
* pmcraid_eh_host_reset which will then go to sleep and wait for the
* reset to complete
*/
spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, host_lock_flags);
if (pinstance->ioa_reset_in_progress ||
pinstance->ioa_state == IOA_STATE_DEAD) {
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
host_lock_flags);
return rc;
}
@ -2992,7 +2992,7 @@ static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)
if (cmd_found)
cancel_cmd = pmcraid_abort_cmd(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
host_lock_flags);
if (cancel_cmd) {
@ -3720,11 +3720,11 @@ static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id)
pmcraid_err("ISR: error interrupts: %x \
initiating reset\n", intrs_val);
spin_lock_irqsave(pinstance->host->host_lock,
spin_lock_irqsave(&pinstance->host->host_lock,
lock_flags);
pmcraid_initiate_reset(pinstance);
spin_unlock_irqrestore(
pinstance->host->host_lock,
&pinstance->host->host_lock,
lock_flags);
}
/* If interrupt was as part of the ioa initialization,
@ -3798,9 +3798,9 @@ static irqreturn_t pmcraid_isr(int irq, void *dev_id)
intrs);
intrs = ioread32(
pinstance->int_regs.ioa_host_interrupt_clr_reg);
spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
spin_lock_irqsave(&pinstance->host->host_lock, lock_flags);
pmcraid_initiate_reset(pinstance);
spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, lock_flags);
} else {
/* If interrupt was as part of the ioa initialization,
* clear. Delete the timer and wakeup the
@ -3859,11 +3859,11 @@ static void pmcraid_worker_function(struct work_struct *workp)
/* host_lock must be held before calling
* scsi_device_get
*/
spin_lock_irqsave(pinstance->host->host_lock,
spin_lock_irqsave(&pinstance->host->host_lock,
host_lock_flags);
if (!scsi_device_get(sdev)) {
spin_unlock_irqrestore(
pinstance->host->host_lock,
&pinstance->host->host_lock,
host_lock_flags);
pmcraid_info("deleting %x from midlayer\n",
res->cfg_entry.resource_address);
@ -3879,7 +3879,7 @@ static void pmcraid_worker_function(struct work_struct *workp)
res->change_detected = 0;
} else {
spin_unlock_irqrestore(
pinstance->host->host_lock,
&pinstance->host->host_lock,
host_lock_flags);
}
}
@ -3986,10 +3986,10 @@ static void pmcraid_tasklet_function(unsigned long instance)
atomic_dec(&pinstance->outstanding_cmds);
if (cmd->cmd_done == pmcraid_ioa_reset) {
spin_lock_irqsave(pinstance->host->host_lock,
spin_lock_irqsave(&pinstance->host->host_lock,
host_lock_flags);
cmd->cmd_done(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock,
spin_unlock_irqrestore(&pinstance->host->host_lock,
host_lock_flags);
} else if (cmd->cmd_done != NULL) {
cmd->cmd_done(cmd);
@ -4880,9 +4880,9 @@ static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)
struct pmcraid_instance *pinstance = cmd->drv_inst;
unsigned long flags;
spin_lock_irqsave(pinstance->host->host_lock, flags);
spin_lock_irqsave(&pinstance->host->host_lock, flags);
pmcraid_ioa_reset(cmd);
spin_unlock_irqrestore(pinstance->host->host_lock, flags);
spin_unlock_irqrestore(&pinstance->host->host_lock, flags);
scsi_unblock_requests(pinstance->host);
schedule_work(&pinstance->worker_q);
}

5
drivers/scsi/ps3rom.c
View File

@ -233,7 +233,8 @@ static enum scsi_qc_status ps3rom_queuecommand_lck(struct scsi_cmnd *cmd)
}
if (res) {
scsi_build_sense(cmd, 0, ILLEGAL_REQUEST, 0, 0);
scsi_set_sense(cmd, 0, ILLEGAL_REQUEST,
NO_ADDITIONAL_SENSE_INFORMATION);
cmd->result = res;
priv->curr_cmd = NULL;
scsi_done(cmd);
@ -316,7 +317,7 @@ static irqreturn_t ps3rom_interrupt(int irq, void *data)
goto done;
}
scsi_build_sense(cmd, 0, sense_key, asc, ascq);
scsi_set_sense(cmd, 0, sense_key, scsi_sense_code(asc, ascq));
done:
priv->curr_cmd = NULL;

44
drivers/scsi/qla1280.c
View File

@ -741,9 +741,9 @@ _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
int status = FAILED;
struct scsi_cmnd *cmd = sp->cmd;
spin_unlock_irq(ha->host->host_lock);
spin_unlock_irq(&ha->host->host_lock);
wait_for_completion_timeout(wait, 4*HZ);
spin_lock_irq(ha->host->host_lock);
spin_lock_irq(&ha->host->host_lock);
sp->wait = NULL;
if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
status = SUCCESS;
@ -953,9 +953,9 @@ qla1280_eh_abort(struct scsi_cmnd * cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
spin_lock_irq(&cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, ABORT_COMMAND);
spin_unlock_irq(cmd->device->host->host_lock);
spin_unlock_irq(&cmd->device->host->host_lock);
return rc;
}
@ -969,9 +969,9 @@ qla1280_eh_device_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
spin_lock_irq(&cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, DEVICE_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
spin_unlock_irq(&cmd->device->host->host_lock);
return rc;
}
@ -985,9 +985,9 @@ qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
spin_lock_irq(&cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, BUS_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
spin_unlock_irq(&cmd->device->host->host_lock);
return rc;
}
@ -1003,7 +1003,7 @@ qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
struct Scsi_Host *shost = cmd->device->host;
struct scsi_qla_host *ha = (struct scsi_qla_host *)shost->hostdata;
spin_lock_irq(shost->host_lock);
spin_lock_irq(&shost->host_lock);
if (qla1280_verbose) {
printk(KERN_INFO
"scsi(%ld): Issued ADAPTER RESET\n",
@ -1019,7 +1019,7 @@ qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
ha->flags.reset_active = 0;
spin_unlock_irq(shost->host_lock);
spin_unlock_irq(&shost->host_lock);
return rc;
}
@ -1080,7 +1080,7 @@ qla1280_intr_handler(int irq, void *dev_id)
ENTER_INTR ("qla1280_intr_handler");
ha = (struct scsi_qla_host *)dev_id;
spin_lock(ha->host->host_lock);
spin_lock(&ha->host->host_lock);
ha->isr_count++;
reg = ha->iobase;
@ -1096,7 +1096,7 @@ qla1280_intr_handler(int irq, void *dev_id)
if (!list_empty(&ha->done_q))
qla1280_done(ha);
spin_unlock(ha->host->host_lock);
spin_unlock(&ha->host->host_lock);
qla1280_enable_intrs(ha);
@ -1214,11 +1214,11 @@ qla1280_sdev_configure(struct scsi_device *device, struct queue_limits *lim)
nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
}
spin_lock_irqsave(ha->host->host_lock, flags);
spin_lock_irqsave(&ha->host->host_lock, flags);
if (nv->bus[bus].target[target].parameter.enable_sync)
status = qla1280_set_target_parameters(ha, bus, target);
qla1280_get_target_parameters(ha, device);
spin_unlock_irqrestore(ha->host->host_lock, flags);
spin_unlock_irqrestore(&ha->host->host_lock, flags);
return status;
}
@ -1435,7 +1435,7 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
* needs to be able to drop the lock unconditionally to wait
* for completion.
*/
spin_lock_irqsave(ha->host->host_lock, flags);
spin_lock_irqsave(&ha->host->host_lock, flags);
status = qla1280_load_firmware(ha);
if (status) {
@ -1467,7 +1467,7 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
ha->flags.online = 1;
out:
spin_unlock_irqrestore(ha->host->host_lock, flags);
spin_unlock_irqrestore(&ha->host->host_lock, flags);
if (status)
dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
@ -1496,7 +1496,7 @@ qla1280_request_firmware(struct scsi_qla_host *ha)
int index;
char *fwname;
spin_unlock_irq(ha->host->host_lock);
spin_unlock_irq(&ha->host->host_lock);
mutex_lock(&qla1280_firmware_mutex);
index = ql1280_board_tbl[ha->devnum].fw_index;
@ -1529,7 +1529,7 @@ qla1280_request_firmware(struct scsi_qla_host *ha)
ha->fwver3 = fw->data[2];
unlock:
mutex_unlock(&qla1280_firmware_mutex);
spin_lock_irq(ha->host->host_lock);
spin_lock_irq(&ha->host->host_lock);
return fw;
}
@ -2451,14 +2451,14 @@ qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
spin_unlock_irq(ha->host->host_lock);
spin_unlock_irq(&ha->host->host_lock);
WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
qla1280_debounce_register(&reg->istatus);
wait_for_completion(&wait);
timer_delete_sync(&ha->mailbox_timer);
spin_lock_irq(ha->host->host_lock);
spin_lock_irq(&ha->host->host_lock);
ha->mailbox_wait = NULL;
@ -2560,9 +2560,9 @@ qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
ha->bus_settings[bus].scsi_bus_dead = 1;
ha->bus_settings[bus].failed_reset_count++;
} else {
spin_unlock_irq(ha->host->host_lock);
spin_unlock_irq(&ha->host->host_lock);
ssleep(reset_delay);
spin_lock_irq(ha->host->host_lock);
spin_lock_irq(&ha->host->host_lock);
ha->bus_settings[bus].scsi_bus_dead = 0;
ha->bus_settings[bus].failed_reset_count = 0;

4
drivers/scsi/qla2xxx/qla_attr.c
View File

@ -2814,13 +2814,13 @@ qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
* Transport has effectively 'deleted' the rport, clear
* all local references.
*/
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
/* Confirm port has not reappeared before clearing pointers. */
if (rport->port_state != FC_PORTSTATE_ONLINE) {
fcport->rport = NULL;
*((fc_port_t **)rport->dd_data) = NULL;
}
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
return;

4
drivers/scsi/qla2xxx/qla_init.c
View File

@ -6247,9 +6247,9 @@ qla2x00_reg_remote_port(scsi_qla_host_t *vha, fc_port_t *fcport)
return;
}
spin_lock_irqsave(fcport->vha->host->host_lock, flags);
spin_lock_irqsave(&fcport->vha->host->host_lock, flags);
*((fc_port_t **)rport->dd_data) = fcport;
spin_unlock_irqrestore(fcport->vha->host->host_lock, flags);
spin_unlock_irqrestore(&fcport->vha->host->host_lock, flags);
fcport->dev_loss_tmo = rport->dev_loss_tmo;
rport->supported_classes = fcport->supported_classes;

9
drivers/scsi/qla2xxx/qla_isr.c
View File

@ -3263,21 +3263,24 @@ qla2x00_handle_dif_error(srb_t *sp, void *pkt)
/* check guard */
if (e_guard != a_guard) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x1);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_GUARD_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check ref tag */
if (e_ref_tag != a_ref_tag) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x3);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}
/* check appl tag */
if (e_app_tag != a_app_tag) {
scsi_build_sense(cmd, 1, ILLEGAL_REQUEST, 0x10, 0x2);
scsi_set_sense(cmd, 1, ILLEGAL_REQUEST,
LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED);
set_host_byte(cmd, DID_ABORT);
return 1;
}

99
drivers/scsi/qla2xxx/qla_target.c
View File

@ -2243,18 +2243,20 @@ void qlt_free_ul_mcmd(struct qla_hw_data *ha, struct qla_tgt_mgmt_cmd *mcmd)
* ha->hardware_lock supposed to be held on entry. Might drop it, then
* reacquire
*/
void qlt_send_resp_ctio(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t scsi_status, uint8_t sense_key, uint8_t asc, uint8_t ascq)
static void qlt_send_resp_ctio(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t scsi_status, uint8_t sense_key, uint16_t sense_code)
{
struct atio_from_isp *atio = &cmd->atio;
struct ctio7_to_24xx *ctio;
uint16_t temp;
struct scsi_qla_host *vha = cmd->vha;
uint8_t asc = scsi_sense_code_asc(sense_code);
uint8_t ascq = scsi_sense_code_ascq(sense_code);
ql_dbg(ql_dbg_tgt_dif, vha, 0x3066,
"Sending response CTIO7 (vha=%p, atio=%p, scsi_status=%02x, "
"sense_key=%02x, asc=%02x, ascq=%02x",
vha, atio, scsi_status, sense_key, asc, ascq);
vha, atio, scsi_status, sense_key, asc, ascq);
ctio = (struct ctio7_to_24xx *)qla2x00_alloc_iocbs(vha, NULL);
if (!ctio) {
@ -2677,44 +2679,47 @@ static void qlt_print_dif_err(struct qla_tgt_prm *prm)
{
struct qla_tgt_cmd *cmd;
struct scsi_qla_host *vha;
u16 scode;
/* asc 0x10=dif error */
if (prm->sense_buffer && (prm->sense_buffer[12] == 0x10)) {
cmd = prm->cmd;
vha = cmd->vha;
/* ASCQ */
switch (prm->sense_buffer[13]) {
case 1:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00b,
"BE detected Guard TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case 2:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00c,
"BE detected APP TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case 3:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00f,
"BE detected REF TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
default:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe010,
"BE detected Dif ERR: lba[%llx|%lld] len[%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
}
ql_dump_buffer(ql_dbg_tgt_dif, vha, 0xe011, cmd->cdb, 16);
if (!prm->sense_buffer ||
prm->sense_buffer[12] != ASC_ID_CRC_OR_ECC_ERROR)
return;
cmd = prm->cmd;
vha = cmd->vha;
scode = scsi_sense_code(prm->sense_buffer[12], prm->sense_buffer[13]);
switch (scode) {
case LOGICAL_BLOCK_GUARD_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00b,
"BE detected Guard TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00c,
"BE detected APP TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
case LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe00f,
"BE detected REF TAG ERR: lba[0x%llx|%lld] len[0x%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
default:
ql_dbg(ql_dbg_tgt_dif, vha, 0xe010,
"BE detected Dif ERR: lba[%llx|%lld] len[%x] "
"se_cmd=%p tag[%x]",
cmd->lba, cmd->lba, cmd->num_blks, &cmd->se_cmd,
cmd->atio.u.isp24.exchange_addr);
break;
}
ql_dump_buffer(ql_dbg_tgt_dif, vha, 0xe011, cmd->cdb, 16);
}
/*
@ -3467,7 +3472,8 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
uint8_t *ap = &sts->actual_dif[0];
uint8_t *ep = &sts->expected_dif[0];
uint64_t lba = cmd->se_cmd.t_task_lba;
uint8_t scsi_status, sense_key, asc, ascq;
uint8_t scsi_status, sense_key;
uint16_t sense_code = 0;
struct scsi_qla_host *vha = cmd->vha;
cmd->trc_flags |= TRC_DIF_ERR;
@ -3483,7 +3489,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
ql_dbg(ql_dbg_tgt_dif, vha, 0xf075,
"%s: aborted %d state %d\n", __func__, cmd->aborted, cmd->state);
scsi_status = sense_key = asc = ascq = 0;
scsi_status = sense_key = 0;
/* check appl tag */
if (cmd->e_app_tag != cmd->a_app_tag) {
@ -3497,8 +3503,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_APP;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x2;
sense_code = LOGICAL_BLOCK_APPLICATION_TAG_CHECK_FAILED;
}
/* check ref tag */
@ -3513,8 +3518,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_REF;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x3;
sense_code = LOGICAL_BLOCK_REFERENCE_TAG_CHECK_FAILED;
goto out;
}
@ -3530,8 +3534,7 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
cmd->dif_err_code = DIF_ERR_GRD;
scsi_status = SAM_STAT_CHECK_CONDITION;
sense_key = ABORTED_COMMAND;
asc = 0x10;
ascq = 0x1;
sense_code = LOGICAL_BLOCK_GUARD_CHECK_FAILED;
}
out:
switch (cmd->state) {
@ -3547,8 +3550,8 @@ qlt_handle_dif_error(struct qla_qpair *qpair, struct qla_tgt_cmd *cmd,
break;
}
qlt_send_resp_ctio(qpair, cmd, scsi_status, sense_key, asc,
ascq);
qlt_send_resp_ctio(qpair, cmd, scsi_status, sense_key,
sense_code);
/* assume scsi status gets out on the wire.
* Will not wait for completion.
*/

3
drivers/scsi/qla2xxx/qla_target.h
View File

@ -1178,7 +1178,4 @@ extern irqreturn_t qla83xx_msix_atio_q(int, void *);
extern void qlt_logo_completion_handler(fc_port_t *, int);
extern void qlt_do_generation_tick(struct scsi_qla_host *, int *);
void qlt_send_resp_ctio(struct qla_qpair *, struct qla_tgt_cmd *, uint8_t,
uint8_t, uint8_t, uint8_t);
#endif /* __QLA_TARGET_H */

8
drivers/scsi/qlogicfas408.c
View File

@ -454,9 +454,9 @@ irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
unsigned long flags;
struct Scsi_Host *host = dev_id;
spin_lock_irqsave(host->host_lock, flags);
spin_lock_irqsave(&host->host_lock, flags);
ql_ihandl(dev_id);
spin_unlock_irqrestore(host->host_lock, flags);
spin_unlock_irqrestore(&host->host_lock, flags);
return IRQ_HANDLED;
}
@ -536,9 +536,9 @@ int qlogicfas408_host_reset(struct scsi_cmnd *cmd)
priv->qabort = 2;
spin_lock_irqsave(cmd->device->host->host_lock, flags);
spin_lock_irqsave(&cmd->device->host->host_lock, flags);
ql_zap(priv);
spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
spin_unlock_irqrestore(&cmd->device->host->host_lock, flags);
return SUCCESS;
}

Some files were not shown because too many files have changed in this diff Show More