Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI fixes from James Bottomley:
"Driver fixes and and one core patch.
Nine of the driver patches are minor fixes and reworks to lpfc and the
rest are trivial and minor fixes elsewhere"
* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
scsi: pmcraid: Fix missing resource cleanup in error case
scsi: ipr: Fix missing/incorrect resource cleanup in error case
scsi: mpt3sas: Fix out-of-bounds compiler warning
scsi: lpfc: Update lpfc version to 14.2.0.4
scsi: lpfc: Allow reduced polling rate for nvme_admin_async_event cmd completion
scsi: lpfc: Add more logging of cmd and cqe information for aborted NVMe cmds
scsi: lpfc: Fix port stuck in bypassed state after LIP in PT2PT topology
scsi: lpfc: Resolve NULL ptr dereference after an ELS LOGO is aborted
scsi: lpfc: Address NULL pointer dereference after starget_to_rport()
scsi: lpfc: Resolve some cleanup issues following SLI path refactoring
scsi: lpfc: Resolve some cleanup issues following abort path refactoring
scsi: lpfc: Correct BDE type for XMIT_SEQ64_WQE in lpfc_ct_reject_event()
scsi: vmw_pvscsi: Expand vcpuHint to 16 bits
scsi: sd: Fix interpretation of VPD B9h length
+94
-61
+2
-2
drivers/scsi/ipr.c
+2
-2
drivers/scsi/ipr.c
···
9795
9795
GFP_KERNEL);
9796
9796
9797
9797
if (!ioa_cfg->hrrq[i].host_rrq) {
9798
-
while (--i > 0)
9798
+
while (--i >= 0)
9799
9799
dma_free_coherent(&pdev->dev,
9800
9800
sizeof(u32) * ioa_cfg->hrrq[i].size,
9801
9801
ioa_cfg->hrrq[i].host_rrq,
···
10068
10068
ioa_cfg->vectors_info[i].desc,
10069
10069
&ioa_cfg->hrrq[i]);
10070
10070
if (rc) {
10071
-
while (--i >= 0)
10071
+
while (--i > 0)
10072
10072
free_irq(pci_irq_vector(pdev, i),
10073
10073
&ioa_cfg->hrrq[i]);
10074
10074
return rc;
+1
-3
drivers/scsi/lpfc/lpfc_crtn.h
+1
-3
drivers/scsi/lpfc/lpfc_crtn.h
···
420
420
uint32_t);
421
421
void lpfc_sli_abort_fcp_cmpl(struct lpfc_hba *, struct lpfc_iocbq *,
422
422
struct lpfc_iocbq *);
423
-
void lpfc_sli4_abort_fcp_cmpl(struct lpfc_hba *h, struct lpfc_iocbq *i,
424
-
struct lpfc_wcqe_complete *w);
425
423
426
424
void lpfc_sli_free_hbq(struct lpfc_hba *, struct hbq_dmabuf *);
427
425
···
628
630
struct lpfc_nodelist *ndlp);
629
631
void lpfc_nvme_abort_fcreq_cmpl(struct lpfc_hba *phba,
630
632
struct lpfc_iocbq *cmdiocb,
631
-
struct lpfc_wcqe_complete *abts_cmpl);
633
+
struct lpfc_iocbq *rspiocb);
632
634
void lpfc_create_multixri_pools(struct lpfc_hba *phba);
633
635
void lpfc_create_destroy_pools(struct lpfc_hba *phba);
634
636
void lpfc_move_xri_pvt_to_pbl(struct lpfc_hba *phba, u32 hwqid);
+1
-1
drivers/scsi/lpfc/lpfc_ct.c
+1
-1
drivers/scsi/lpfc/lpfc_ct.c
···
197
197
memset(bpl, 0, sizeof(struct ulp_bde64));
198
198
bpl->addrHigh = le32_to_cpu(putPaddrHigh(mp->phys));
199
199
bpl->addrLow = le32_to_cpu(putPaddrLow(mp->phys));
200
-
bpl->tus.f.bdeFlags = BUFF_TYPE_BLP_64;
200
+
bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
201
201
bpl->tus.f.bdeSize = (LPFC_CT_PREAMBLE - 4);
202
202
bpl->tus.w = le32_to_cpu(bpl->tus.w);
203
203
+9
-12
drivers/scsi/lpfc/lpfc_els.c
+9
-12
drivers/scsi/lpfc/lpfc_els.c
···
2998
2998
ndlp->nlp_DID, ulp_status,
2999
2999
ulp_word4);
3000
3000
3001
-
/* Call NLP_EVT_DEVICE_RM if link is down or LOGO is aborted */
3002
3001
if (lpfc_error_lost_link(ulp_status, ulp_word4)) {
3003
-
lpfc_disc_state_machine(vport, ndlp, cmdiocb,
3004
-
NLP_EVT_DEVICE_RM);
3005
3002
skip_recovery = 1;
3006
3003
goto out;
3007
3004
}
···
3018
3021
spin_unlock_irq(&ndlp->lock);
3019
3022
lpfc_disc_state_machine(vport, ndlp, cmdiocb,
3020
3023
NLP_EVT_DEVICE_RM);
3021
-
lpfc_els_free_iocb(phba, cmdiocb);
3022
-
lpfc_nlp_put(ndlp);
3023
-
3024
-
/* Presume the node was released. */
3025
-
return;
3024
+
goto out_rsrc_free;
3026
3025
}
3027
3026
3028
3027
out:
3029
-
/* Driver is done with the IO. */
3030
-
lpfc_els_free_iocb(phba, cmdiocb);
3031
-
lpfc_nlp_put(ndlp);
3032
-
3033
3028
/* At this point, the LOGO processing is complete. NOTE: For a
3034
3029
* pt2pt topology, we are assuming the NPortID will only change
3035
3030
* on link up processing. For a LOGO / PLOGI initiated by the
···
3048
3059
ndlp->nlp_DID, ulp_status,
3049
3060
ulp_word4, tmo,
3050
3061
vport->num_disc_nodes);
3062
+
3063
+
lpfc_els_free_iocb(phba, cmdiocb);
3064
+
lpfc_nlp_put(ndlp);
3065
+
3051
3066
lpfc_disc_start(vport);
3052
3067
return;
3053
3068
}
···
3068
3075
lpfc_disc_state_machine(vport, ndlp, cmdiocb,
3069
3076
NLP_EVT_DEVICE_RM);
3070
3077
}
3078
+
out_rsrc_free:
3079
+
/* Driver is done with the I/O. */
3080
+
lpfc_els_free_iocb(phba, cmdiocb);
3081
+
lpfc_nlp_put(ndlp);
3071
3082
}
3072
3083
3073
3084
/**
+3
drivers/scsi/lpfc/lpfc_hw4.h
+3
drivers/scsi/lpfc/lpfc_hw4.h
···
4487
4487
#define wqe_sup_SHIFT 6
4488
4488
#define wqe_sup_MASK 0x00000001
4489
4489
#define wqe_sup_WORD word11
4490
+
#define wqe_ffrq_SHIFT 6
4491
+
#define wqe_ffrq_MASK 0x00000001
4492
+
#define wqe_ffrq_WORD word11
4490
4493
#define wqe_wqec_SHIFT 7
4491
4494
#define wqe_wqec_MASK 0x00000001
4492
4495
#define wqe_wqec_WORD word11
+1
-1
drivers/scsi/lpfc/lpfc_init.c
+1
-1
drivers/scsi/lpfc/lpfc_init.c
···
12188
12188
rc = pci_enable_msi(phba->pcidev);
12189
12189
if (!rc)
12190
12190
lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
12191
-
"0462 PCI enable MSI mode success.\n");
12191
+
"0012 PCI enable MSI mode success.\n");
12192
12192
else {
12193
12193
lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
12194
12194
"0471 PCI enable MSI mode failed (%d)\n", rc);
+2
-1
drivers/scsi/lpfc/lpfc_nportdisc.c
+2
-1
drivers/scsi/lpfc/lpfc_nportdisc.c
···
834
834
lpfc_nvmet_invalidate_host(phba, ndlp);
835
835
836
836
if (ndlp->nlp_DID == Fabric_DID) {
837
-
if (vport->port_state <= LPFC_FDISC)
837
+
if (vport->port_state <= LPFC_FDISC ||
838
+
vport->fc_flag & FC_PT2PT)
838
839
goto out;
839
840
lpfc_linkdown_port(vport);
840
841
spin_lock_irq(shost->host_lock);
+40
-12
drivers/scsi/lpfc/lpfc_nvme.c
+40
-12
drivers/scsi/lpfc/lpfc_nvme.c
···
1065
1065
nCmd->rcv_rsplen = wcqe->parameter;
1066
1066
nCmd->status = 0;
1067
1067
1068
+
/* Get the NVME cmd details for this unique error. */
1069
+
cp = (struct nvme_fc_cmd_iu *)nCmd->cmdaddr;
1070
+
ep = (struct nvme_fc_ersp_iu *)nCmd->rspaddr;
1071
+
1068
1072
/* Check if this is really an ERSP */
1069
1073
if (nCmd->rcv_rsplen == LPFC_NVME_ERSP_LEN) {
1070
1074
lpfc_ncmd->status = IOSTAT_SUCCESS;
1071
1075
lpfc_ncmd->result = 0;
1072
1076
1073
1077
lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME,
1074
-
"6084 NVME Completion ERSP: "
1075
-
"xri %x placed x%x\n",
1076
-
lpfc_ncmd->cur_iocbq.sli4_xritag,
1077
-
wcqe->total_data_placed);
1078
+
"6084 NVME FCP_ERR ERSP: "
1079
+
"xri %x placed x%x opcode x%x cmd_id "
1080
+
"x%x cqe_status x%x\n",
1081
+
lpfc_ncmd->cur_iocbq.sli4_xritag,
1082
+
wcqe->total_data_placed,
1083
+
cp->sqe.common.opcode,
1084
+
cp->sqe.common.command_id,
1085
+
ep->cqe.status);
1078
1086
break;
1079
1087
}
1080
1088
lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
1081
1089
"6081 NVME Completion Protocol Error: "
1082
1090
"xri %x status x%x result x%x "
1083
-
"placed x%x\n",
1091
+
"placed x%x opcode x%x cmd_id x%x, "
1092
+
"cqe_status x%x\n",
1084
1093
lpfc_ncmd->cur_iocbq.sli4_xritag,
1085
1094
lpfc_ncmd->status, lpfc_ncmd->result,
1086
-
wcqe->total_data_placed);
1095
+
wcqe->total_data_placed,
1096
+
cp->sqe.common.opcode,
1097
+
cp->sqe.common.command_id,
1098
+
ep->cqe.status);
1087
1099
break;
1088
1100
case IOSTAT_LOCAL_REJECT:
1089
1101
/* Let fall through to set command final state. */
···
1207
1195
{
1208
1196
struct lpfc_hba *phba = vport->phba;
1209
1197
struct nvmefc_fcp_req *nCmd = lpfc_ncmd->nvmeCmd;
1210
-
struct lpfc_iocbq *pwqeq = &(lpfc_ncmd->cur_iocbq);
1198
+
struct nvme_common_command *sqe;
1199
+
struct lpfc_iocbq *pwqeq = &lpfc_ncmd->cur_iocbq;
1211
1200
union lpfc_wqe128 *wqe = &pwqeq->wqe;
1212
1201
uint32_t req_len;
1213
1202
···
1265
1252
cstat->control_requests++;
1266
1253
}
1267
1254
1268
-
if (pnode->nlp_nvme_info & NLP_NVME_NSLER)
1255
+
if (pnode->nlp_nvme_info & NLP_NVME_NSLER) {
1269
1256
bf_set(wqe_erp, &wqe->generic.wqe_com, 1);
1257
+
sqe = &((struct nvme_fc_cmd_iu *)
1258
+
nCmd->cmdaddr)->sqe.common;
1259
+
if (sqe->opcode == nvme_admin_async_event)
1260
+
bf_set(wqe_ffrq, &wqe->generic.wqe_com, 1);
1261
+
}
1262
+
1270
1263
/*
1271
1264
* Finish initializing those WQE fields that are independent
1272
1265
* of the nvme_cmnd request_buffer
···
1806
1787
* lpfc_nvme_abort_fcreq_cmpl - Complete an NVME FCP abort request.
1807
1788
* @phba: Pointer to HBA context object
1808
1789
* @cmdiocb: Pointer to command iocb object.
1809
-
* @abts_cmpl: Pointer to wcqe complete object.
1790
+
* @rspiocb: Pointer to response iocb object.
1810
1791
*
1811
1792
* This is the callback function for any NVME FCP IO that was aborted.
1812
1793
*
···
1815
1796
**/
1816
1797
void
1817
1798
lpfc_nvme_abort_fcreq_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
1818
-
struct lpfc_wcqe_complete *abts_cmpl)
1799
+
struct lpfc_iocbq *rspiocb)
1819
1800
{
1801
+
struct lpfc_wcqe_complete *abts_cmpl = &rspiocb->wcqe_cmpl;
1802
+
1820
1803
lpfc_printf_log(phba, KERN_INFO, LOG_NVME,
1821
1804
"6145 ABORT_XRI_CN completing on rpi x%x "
1822
1805
"original iotag x%x, abort cmd iotag x%x "
···
1861
1840
struct lpfc_nvme_fcpreq_priv *freqpriv;
1862
1841
unsigned long flags;
1863
1842
int ret_val;
1843
+
struct nvme_fc_cmd_iu *cp;
1864
1844
1865
1845
/* Validate pointers. LLDD fault handling with transport does
1866
1846
* have timing races.
···
1985
1963
return;
1986
1964
}
1987
1965
1966
+
/*
1967
+
* Get Command Id from cmd to plug into response. This
1968
+
* code is not needed in the next NVME Transport drop.
1969
+
*/
1970
+
cp = (struct nvme_fc_cmd_iu *)lpfc_nbuf->nvmeCmd->cmdaddr;
1988
1971
lpfc_printf_vlog(vport, KERN_INFO, LOG_NVME_ABTS,
1989
1972
"6138 Transport Abort NVME Request Issued for "
1990
-
"ox_id x%x\n",
1991
-
nvmereq_wqe->sli4_xritag);
1973
+
"ox_id x%x nvme opcode x%x nvme cmd_id x%x\n",
1974
+
nvmereq_wqe->sli4_xritag, cp->sqe.common.opcode,
1975
+
cp->sqe.common.command_id);
1992
1976
return;
1993
1977
1994
1978
out_unlock:
+6
drivers/scsi/lpfc/lpfc_scsi.c
+6
drivers/scsi/lpfc/lpfc_scsi.c
···
6062
6062
int status;
6063
6063
u32 logit = LOG_FCP;
6064
6064
6065
+
if (!rport)
6066
+
return FAILED;
6067
+
6065
6068
rdata = rport->dd_data;
6066
6069
if (!rdata || !rdata->pnode) {
6067
6070
lpfc_printf_vlog(vport, KERN_ERR, LOG_TRACE_EVENT,
···
6142
6139
u32 dev_loss_tmo = vport->cfg_devloss_tmo;
6143
6140
unsigned long flags;
6144
6141
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
6142
+
6143
+
if (!rport)
6144
+
return FAILED;
6145
6145
6146
6146
rdata = rport->dd_data;
6147
6147
if (!rdata || !rdata->pnode) {
+12
-13
drivers/scsi/lpfc/lpfc_sli.c
+12
-13
drivers/scsi/lpfc/lpfc_sli.c
···
1930
1930
sync_buf = __lpfc_sli_get_iocbq(phba);
1931
1931
if (!sync_buf) {
1932
1932
lpfc_printf_log(phba, KERN_ERR, LOG_CGN_MGMT,
1933
-
"6213 No available WQEs for CMF_SYNC_WQE\n");
1933
+
"6244 No available WQEs for CMF_SYNC_WQE\n");
1934
1934
ret_val = ENOMEM;
1935
1935
goto out_unlock;
1936
1936
}
···
3805
3805
set_job_ulpword4(cmdiocbp,
3806
3806
IOERR_ABORT_REQUESTED);
3807
3807
/*
3808
-
* For SLI4, irsiocb contains
3808
+
* For SLI4, irspiocb contains
3809
3809
* NO_XRI in sli_xritag, it
3810
3810
* shall not affect releasing
3811
3811
* sgl (xri) process.
···
3823
3823
}
3824
3824
}
3825
3825
}
3826
-
(cmdiocbp->cmd_cmpl) (phba, cmdiocbp, saveq);
3826
+
cmdiocbp->cmd_cmpl(phba, cmdiocbp, saveq);
3827
3827
} else
3828
3828
lpfc_sli_release_iocbq(phba, cmdiocbp);
3829
3829
} else {
···
4063
4063
cmdiocbq->cmd_flag &= ~LPFC_DRIVER_ABORTED;
4064
4064
if (cmdiocbq->cmd_cmpl) {
4065
4065
spin_unlock_irqrestore(&phba->hbalock, iflag);
4066
-
(cmdiocbq->cmd_cmpl)(phba, cmdiocbq,
4067
-
&rspiocbq);
4066
+
cmdiocbq->cmd_cmpl(phba, cmdiocbq, &rspiocbq);
4068
4067
spin_lock_irqsave(&phba->hbalock, iflag);
4069
4068
}
4070
4069
break;
···
10287
10288
* @flag: Flag indicating if this command can be put into txq.
10288
10289
*
10289
10290
* __lpfc_sli_issue_fcp_io_s3 is wrapper function to invoke lockless func to
10290
-
* send an iocb command to an HBA with SLI-4 interface spec.
10291
+
* send an iocb command to an HBA with SLI-3 interface spec.
10291
10292
*
10292
10293
* This function takes the hbalock before invoking the lockless version.
10293
10294
* The function will return success after it successfully submit the wqe to
···
12739
12740
cmdiocbq->cmd_cmpl = cmdiocbq->wait_cmd_cmpl;
12740
12741
cmdiocbq->wait_cmd_cmpl = NULL;
12741
12742
if (cmdiocbq->cmd_cmpl)
12742
-
(cmdiocbq->cmd_cmpl)(phba, cmdiocbq, NULL);
12743
+
cmdiocbq->cmd_cmpl(phba, cmdiocbq, NULL);
12743
12744
else
12744
12745
lpfc_sli_release_iocbq(phba, cmdiocbq);
12745
12746
return;
···
12753
12754
12754
12755
/* Set the exchange busy flag for task management commands */
12755
12756
if ((cmdiocbq->cmd_flag & LPFC_IO_FCP) &&
12756
-
!(cmdiocbq->cmd_flag & LPFC_IO_LIBDFC)) {
12757
+
!(cmdiocbq->cmd_flag & LPFC_IO_LIBDFC)) {
12757
12758
lpfc_cmd = container_of(cmdiocbq, struct lpfc_io_buf,
12758
-
cur_iocbq);
12759
+
cur_iocbq);
12759
12760
if (rspiocbq && (rspiocbq->cmd_flag & LPFC_EXCHANGE_BUSY))
12760
12761
lpfc_cmd->flags |= LPFC_SBUF_XBUSY;
12761
12762
else
···
13895
13896
* @irspiocbq: Pointer to work-queue completion queue entry.
13896
13897
*
13897
13898
* This routine handles an ELS work-queue completion event and construct
13898
-
* a pseudo response ELS IODBQ from the SLI4 ELS WCQE for the common
13899
+
* a pseudo response ELS IOCBQ from the SLI4 ELS WCQE for the common
13899
13900
* discovery engine to handle.
13900
13901
*
13901
13902
* Return: Pointer to the receive IOCBQ, NULL otherwise.
···
13939
13940
13940
13941
if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
13941
13942
spin_lock_irqsave(&phba->hbalock, iflags);
13942
-
cmdiocbq->cmd_flag |= LPFC_EXCHANGE_BUSY;
13943
+
irspiocbq->cmd_flag |= LPFC_EXCHANGE_BUSY;
13943
13944
spin_unlock_irqrestore(&phba->hbalock, iflags);
13944
13945
}
13945
13946
···
14798
14799
/* Pass the cmd_iocb and the wcqe to the upper layer */
14799
14800
memcpy(&cmdiocbq->wcqe_cmpl, wcqe,
14800
14801
sizeof(struct lpfc_wcqe_complete));
14801
-
(cmdiocbq->cmd_cmpl)(phba, cmdiocbq, cmdiocbq);
14802
+
cmdiocbq->cmd_cmpl(phba, cmdiocbq, cmdiocbq);
14802
14803
} else {
14803
14804
lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
14804
14805
"0375 FCP cmdiocb not callback function "
···
18955
18956
18956
18957
/* Free iocb created in lpfc_prep_seq */
18957
18958
list_for_each_entry_safe(curr_iocb, next_iocb,
18958
-
&iocbq->list, list) {
18959
+
&iocbq->list, list) {
18959
18960
list_del_init(&curr_iocb->list);
18960
18961
lpfc_sli_release_iocbq(phba, curr_iocb);
18961
18962
}
+1
-1
drivers/scsi/lpfc/lpfc_version.h
+1
-1
drivers/scsi/lpfc/lpfc_version.h
+12
-11
drivers/scsi/mpt3sas/mpt3sas_base.c
+12
-11
drivers/scsi/mpt3sas/mpt3sas_base.c
···
5369
5369
Mpi2ConfigReply_t mpi_reply;
5370
5370
Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
5371
5371
Mpi26PCIeIOUnitPage1_t pcie_iounit_pg1;
5372
+
u16 depth;
5372
5373
int sz;
5373
5374
int rc = 0;
5374
5375
···
5381
5380
goto out;
5382
5381
/* sas iounit page 1 */
5383
5382
sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData);
5384
-
sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
5383
+
sas_iounit_pg1 = kzalloc(sizeof(Mpi2SasIOUnitPage1_t), GFP_KERNEL);
5385
5384
if (!sas_iounit_pg1) {
5386
5385
pr_err("%s: failure at %s:%d/%s()!\n",
5387
5386
ioc->name, __FILE__, __LINE__, __func__);
···
5394
5393
ioc->name, __FILE__, __LINE__, __func__);
5395
5394
goto out;
5396
5395
}
5397
-
ioc->max_wideport_qd =
5398
-
(le16_to_cpu(sas_iounit_pg1->SASWideMaxQueueDepth)) ?
5399
-
le16_to_cpu(sas_iounit_pg1->SASWideMaxQueueDepth) :
5400
-
MPT3SAS_SAS_QUEUE_DEPTH;
5401
-
ioc->max_narrowport_qd =
5402
-
(le16_to_cpu(sas_iounit_pg1->SASNarrowMaxQueueDepth)) ?
5403
-
le16_to_cpu(sas_iounit_pg1->SASNarrowMaxQueueDepth) :
5404
-
MPT3SAS_SAS_QUEUE_DEPTH;
5405
-
ioc->max_sata_qd = (sas_iounit_pg1->SATAMaxQDepth) ?
5406
-
sas_iounit_pg1->SATAMaxQDepth : MPT3SAS_SATA_QUEUE_DEPTH;
5396
+
5397
+
depth = le16_to_cpu(sas_iounit_pg1->SASWideMaxQueueDepth);
5398
+
ioc->max_wideport_qd = (depth ? depth : MPT3SAS_SAS_QUEUE_DEPTH);
5399
+
5400
+
depth = le16_to_cpu(sas_iounit_pg1->SASNarrowMaxQueueDepth);
5401
+
ioc->max_narrowport_qd = (depth ? depth : MPT3SAS_SAS_QUEUE_DEPTH);
5402
+
5403
+
depth = sas_iounit_pg1->SATAMaxQDepth;
5404
+
ioc->max_sata_qd = (depth ? depth : MPT3SAS_SATA_QUEUE_DEPTH);
5405
+
5407
5406
/* pcie iounit page 1 */
5408
5407
rc = mpt3sas_config_get_pcie_iounit_pg1(ioc, &mpi_reply,
5409
5408
&pcie_iounit_pg1, sizeof(Mpi26PCIeIOUnitPage1_t));
+1
-1
drivers/scsi/pmcraid.c
+1
-1
drivers/scsi/pmcraid.c
+1
-1
drivers/scsi/sd.c
+1
-1
drivers/scsi/sd.c
···
3072
3072
goto out;
3073
3073
3074
3074
/* We must have at least a 64B header and one 32B range descriptor */
3075
-
vpd_len = get_unaligned_be16(&buffer[2]) + 3;
3075
+
vpd_len = get_unaligned_be16(&buffer[2]) + 4;
3076
3076
if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
3077
3077
sd_printk(KERN_ERR, sdkp,
3078
3078
"Invalid Concurrent Positioning Ranges VPD page\n");