On 8.2.2017 10:28, Shivasharan S wrote:
> fix in v2 - ex_status and status was wrongly re-used in
> megasas_complete_r1_command.
> discussed below -
> http://marc.info/?l=linux-scsi&m=148638763409385&w=2
>
>
> No functional change. Code refactor.
> Remove function megasas_fpio_to_ldio as we never require to convert fpio to
> ldio because of frame unavailability.
> Grab extra frame of raid 1 write fast path before it creates first frame as
> Fast Path.
> Removed is_raid_1_fp_write flag as raid 1 write fast path command is decided
> using r1_alt_dev_handle only.
> Move resetting megasas_cmd_fusion fields at common function
> megasas_return_cmd_fusion.
>
>
> Signed-off-by: Shivasharan S <[email protected]>
> Signed-off-by: Kashyap Desai <[email protected]>
> Reviewed-by: Hannes Reinecke <[email protected]>
> ---
> drivers/scsi/megaraid/megaraid_sas_fp.c | 14 +-
> drivers/scsi/megaraid/megaraid_sas_fusion.c | 349
> +++++++++-------------------
> drivers/scsi/megaraid/megaraid_sas_fusion.h | 3 +-
> 3 files changed, 118 insertions(+), 248 deletions(-)
>
> diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c
> b/drivers/scsi/megaraid/megaraid_sas_fp.c
> index f1384b0..24258af 100644
> --- a/drivers/scsi/megaraid/megaraid_sas_fp.c
> +++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
> @@ -1338,20 +1338,8 @@ MR_BuildRaidContext(struct megasas_instance *instance,
> ref_in_start_stripe, io_info,
> pRAID_Context, map);
> /* If IO on an invalid Pd, then FP is not possible.*/
> - if (io_info->devHandle == cpu_to_le16(MR_PD_INVALID))
> + if (io_info->devHandle == MR_DEVHANDLE_INVALID)
> io_info->fpOkForIo = FALSE;
> - /* if FP possible, set the SLUD bit in
> - * regLockFlags for ventura
> - */
> - else if ((instance->is_ventura) && (!isRead) &&
> - (raid->writeMode == MR_RL_WRITE_BACK_MODE) &&
> - (raid->capability.fp_cache_bypass_capable))
> - ((struct RAID_CONTEXT_G35 *)
> pRAID_Context)->routing_flags.bits.sld = 1;
> - /* set raid 1/10 fast path write capable bit in io_info */
> - if (io_info->fpOkForIo &&
> - (io_info->r1_alt_dev_handle != MR_PD_INVALID) &&
> - (raid->level == 1) && !isRead)
> - io_info->is_raid_1_fp_write = 1;
> return retval;
> } else if (isRead) {
> uint stripIdx;
> diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c
> b/drivers/scsi/megaraid/megaraid_sas_fusion.c
> index 514c306..7516589 100644
> --- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
> +++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
> @@ -181,7 +181,9 @@ inline void megasas_return_cmd_fusion(struct
> megasas_instance *instance,
> struct megasas_cmd_fusion *cmd)
> {
> cmd->scmd = NULL;
> - memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
> + memset(cmd->io_request, 0, MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE);
> + cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
> + cmd->cmd_completed = false;
> }
>
> /**
> @@ -701,7 +703,7 @@ megasas_alloc_cmds_fusion(struct megasas_instance
> *instance)
> memset(cmd->io_request, 0,
> sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
> cmd->io_request_phys_addr = io_req_base_phys + offset;
> - cmd->is_raid_1_fp_write = 0;
> + cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
> }
>
> if (megasas_create_sg_sense_fusion(instance))
> @@ -1984,7 +1986,7 @@ megasas_build_ldio_fusion(struct megasas_instance
> *instance,
> io_info.ldStartBlock = ((u64)start_lba_hi << 32) | start_lba_lo;
> io_info.numBlocks = datalength;
> io_info.ldTgtId = device_id;
> - io_info.r1_alt_dev_handle = MR_PD_INVALID;
> + io_info.r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
> scsi_buff_len = scsi_bufflen(scp);
> io_request->DataLength = cpu_to_le32(scsi_buff_len);
>
> @@ -2025,7 +2027,7 @@ megasas_build_ldio_fusion(struct megasas_instance
> *instance,
> io_info.isRead && io_info.ra_capable)
> fp_possible = false;
>
> - if (io_info.r1_alt_dev_handle != MR_PD_INVALID) {
> + if (io_info.r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
> mrdev_priv = scp->device->hostdata;
>
> if (atomic_inc_return(&instance->fw_outstanding) >
> @@ -2090,9 +2092,10 @@ megasas_build_ldio_fusion(struct megasas_instance
> *instance,
> } else
> scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
>
> - cmd->is_raid_1_fp_write = io_info.is_raid_1_fp_write;
> - if (io_info.is_raid_1_fp_write)
> + if (instance->is_ventura)
> cmd->r1_alt_dev_handle = io_info.r1_alt_dev_handle;
> + else
> + cmd->r1_alt_dev_handle = MR_DEVHANDLE_INVALID;
>
> if ((raidLUN[0] == 1) &&
>
> (local_map_ptr->raidMap.devHndlInfo[io_info.pd_after_lb].validHandles > 1)) {
> @@ -2451,72 +2454,6 @@ megasas_get_request_descriptor(struct megasas_instance
> *instance, u16 index)
> return (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)p;
> }
>
> -/*
> - * megasas_fpio_to_ldio-
> - * This function converts an fp io to ldio
> - */
> -
> -void megasas_fpio_to_ldio(struct megasas_instance *instance,
> - struct megasas_cmd_fusion *cmd, struct scsi_cmnd *scmd)
> -{
> - struct fusion_context *fusion;
> - union RAID_CONTEXT_UNION *praid_context;
> - struct MR_LD_RAID *raid;
> - struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
> - u32 device_id, ld;
> -
> - fusion = instance->ctrl_context;
> - cmd->request_desc->SCSIIO.RequestFlags =
> - (MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
> - << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
> - cmd->io_request->Function = MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
> - cmd->io_request->DevHandle = cpu_to_le16(MEGASAS_DEV_INDEX(scmd));
> -
> - /*remove FAST PATH ENABLE bit in IoFlags */
> - cmd->io_request->IoFlags &=
> - cpu_to_le16(~MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
> -
> - /* if the numSGE > max_sge_in_main_sge set the chain offset*/
> - if (cmd->io_request->RaidContext.raid_context_g35.num_sge >
> - fusion->max_sge_in_main_msg)
> - cmd->io_request->ChainOffset = fusion->chain_offset_io_request;
> - memcpy(cmd->io_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
> - cmd->io_request->CDB.EEDP32.PrimaryReferenceTag = 0;
> - cmd->io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0;
> - cmd->io_request->EEDPFlags = 0;
> - cmd->io_request->Control = 0;
> - cmd->io_request->EEDPBlockSize = 0;
> - cmd->is_raid_1_fp_write = 0;
> -
> - device_id = MEGASAS_DEV_INDEX(cmd->scmd);
> - local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
> - ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
> - raid = MR_LdRaidGet(ld, local_map_ptr);
> - praid_context = &cmd->io_request->RaidContext;
> - if (cmd->scmd->sc_data_direction == PCI_DMA_FROMDEVICE) {
> - if ((raid->cpuAffinity.ldRead.cpu0)
> - && (raid->cpuAffinity.ldRead.cpu1))
> -
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_FCFS;
> - else if (raid->cpuAffinity.ldRead.cpu1)
> -
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_1;
> - else
> -
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_0;
> - } else {
> - if ((raid->cpuAffinity.ldWrite.cpu0)
> - && (raid->cpuAffinity.ldWrite.cpu1))
> - praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_FCFS;
> - else if (raid->cpuAffinity.ldWrite.cpu1)
> - praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_1;
> - else
> - praid_context->raid_context_g35.routing_flags.bits.cpu_sel
> - = MR_RAID_CTX_CPUSEL_0;
> - }
> -}
>
> /* megasas_prepate_secondRaid1_IO
> * It prepares the raid 1 second IO
> @@ -2527,60 +2464,36 @@ void megasas_prepare_secondRaid1_IO(struct
> megasas_instance *instance,
> {
> union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc, *req_desc2 = NULL;
> struct fusion_context *fusion;
> -
> fusion = instance->ctrl_context;
> req_desc = cmd->request_desc;
> - if (r1_cmd) {
> - /* copy the io request frame as well
> - * as 8 SGEs data for r1 command
> - */
> - memcpy(r1_cmd->io_request, cmd->io_request,
> - sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
> - memcpy(&r1_cmd->io_request->SGL, &cmd->io_request->SGL,
> - (fusion->max_sge_in_main_msg *
> - sizeof(union MPI2_SGE_IO_UNION)));
> - /*sense buffer is different for r1 command*/
> - r1_cmd->io_request->SenseBufferLowAddress =
> - cpu_to_le32(r1_cmd->sense_phys_addr);
> - r1_cmd->scmd = cmd->scmd;
> - req_desc2 =
> - megasas_get_request_descriptor(instance, r1_cmd->index-1);
> - if (req_desc2) {
> - req_desc2->Words = 0;
> - r1_cmd->request_desc = req_desc2;
> - req_desc2->SCSIIO.SMID =
> - cpu_to_le16(r1_cmd->index);
> - req_desc2->SCSIIO.RequestFlags =
> - req_desc->SCSIIO.RequestFlags;
> - r1_cmd->is_raid_1_fp_write = 1;
> - r1_cmd->request_desc->SCSIIO.DevHandle =
> - cmd->r1_alt_dev_handle;
> - r1_cmd->io_request->DevHandle = cmd->r1_alt_dev_handle;
> -
> cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
> - cpu_to_le16(r1_cmd->index);
> -
> r1_cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
> - cpu_to_le16(cmd->index);
> - /* MSIxIndex of both commands request
> - * descriptors should be same
> - */
> - r1_cmd->request_desc->SCSIIO.MSIxIndex =
> - cmd->request_desc->SCSIIO.MSIxIndex;
> - /*span arm is different for r1 cmd*/
> -
> r1_cmd->io_request->RaidContext.raid_context_g35.span_arm =
> + /* copy the io request frame as well as 8 SGEs data for r1 command*/
> + memcpy(r1_cmd->io_request, cmd->io_request,
> + (sizeof(struct MPI2_RAID_SCSI_IO_REQUEST)));
> + memcpy(&r1_cmd->io_request->SGL, &cmd->io_request->SGL,
> + (fusion->max_sge_in_main_msg * sizeof(union MPI2_SGE_IO_UNION)));
> + /*sense buffer is different for r1 command*/
> + r1_cmd->io_request->SenseBufferLowAddress =
> + cpu_to_le32(r1_cmd->sense_phys_addr);
> + r1_cmd->scmd = cmd->scmd;
> + req_desc2 = megasas_get_request_descriptor(instance,
> + (r1_cmd->index - 1));
> + req_desc2->Words = 0;
> + r1_cmd->request_desc = req_desc2;
> + req_desc2->SCSIIO.SMID = cpu_to_le16(r1_cmd->index);
> + req_desc2->SCSIIO.RequestFlags = req_desc->SCSIIO.RequestFlags;
> + r1_cmd->request_desc->SCSIIO.DevHandle = cmd->r1_alt_dev_handle;
> + r1_cmd->io_request->DevHandle = cmd->r1_alt_dev_handle;
> + r1_cmd->r1_alt_dev_handle = cmd->io_request->DevHandle;
> + cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
> + cpu_to_le16(r1_cmd->index);
> + r1_cmd->io_request->RaidContext.raid_context_g35.smid.peer_smid =
> + cpu_to_le16(cmd->index);
> + /*MSIxIndex of both commands request descriptors should be same*/
> + r1_cmd->request_desc->SCSIIO.MSIxIndex =
> + cmd->request_desc->SCSIIO.MSIxIndex;
> + /*span arm is different for r1 cmd*/
> + r1_cmd->io_request->RaidContext.raid_context_g35.span_arm =
> cmd->io_request->RaidContext.raid_context_g35.span_arm
> + 1;
> - } else {
> - megasas_return_cmd_fusion(instance, r1_cmd);
> - dev_info(&instance->pdev->dev,
> - "unable to get request descriptor, firing as
> normal IO\n");
> - atomic_dec(&instance->fw_outstanding);
> - megasas_fpio_to_ldio(instance, cmd, cmd->scmd);
> - }
> - } else {
> - dev_info(&instance->pdev->dev,
> - "unable to get command, firing as normal IO\n");
> - atomic_dec(&instance->fw_outstanding);
> - megasas_fpio_to_ldio(instance, cmd, cmd->scmd);
> - }
> }
>
> /**
> @@ -2624,10 +2537,6 @@ megasas_build_and_issue_cmd_fusion(struct
> megasas_instance *instance,
> index = cmd->index;
>
> req_desc = megasas_get_request_descriptor(instance, index-1);
> - if (!req_desc) {
> - atomic_dec(&instance->fw_outstanding);
> - return SCSI_MLQUEUE_HOST_BUSY;
> - }
>
> req_desc->Words = 0;
> cmd->request_desc = req_desc;
> @@ -2657,12 +2566,7 @@ megasas_build_and_issue_cmd_fusion(struct
> megasas_instance *instance,
> /* driver side count always should be less than max_fw_cmds
> * to get new command
> */
> - if (cmd->is_raid_1_fp_write &&
> - atomic_inc_return(&instance->fw_outstanding) >
> - (instance->host->can_queue)) {
> - megasas_fpio_to_ldio(instance, cmd, cmd->scmd);
> - atomic_dec(&instance->fw_outstanding);
> - } else if (cmd->is_raid_1_fp_write) {
> + if (cmd->r1_alt_dev_handle != MR_DEVHANDLE_INVALID) {
> r1_cmd = megasas_get_cmd_fusion(instance,
> (scmd->request->tag + instance->max_fw_cmds));
> megasas_prepare_secondRaid1_IO(instance, cmd, r1_cmd);
> @@ -2684,6 +2588,61 @@ megasas_build_and_issue_cmd_fusion(struct
> megasas_instance *instance,
> }
>
> /**
> + * megasas_complete_r1_command -
> + * completes R1 FP write commands which has valid peer smid
> + * @instance: Adapter soft state
> + * @cmd_fusion: MPT command frame
> + *
> + */
> +static inline void
> +megasas_complete_r1_command(struct megasas_instance *instance,
> + struct megasas_cmd_fusion *cmd)
> +{
> + u8 *sense, status, ex_status;
> + u32 data_length;
> + u16 peer_smid;
> + struct fusion_context *fusion;
> + struct megasas_cmd_fusion *r1_cmd = NULL;
> + struct scsi_cmnd *scmd_local = NULL;
> + struct RAID_CONTEXT_G35 *rctx_g35;
> +
> + rctx_g35 = &cmd->io_request->RaidContext.raid_context_g35;
> + fusion = instance->ctrl_context;
> + peer_smid = le16_to_cpu(rctx_g35->smid.peer_smid);
> +
> + r1_cmd = fusion->cmd_list[peer_smid - 1];
> + scmd_local = cmd->scmd;
> + status = rctx_g35->status;
> + ex_status = rctx_g35->ex_status;
> + data_length = cmd->io_request->DataLength;
> + sense = cmd->sense;
> +
> + cmd->cmd_completed = true;
Please help me understand how this works
- there are two peer commands sent to the controller
- both are completed and the later calls scsi_done and returns both r1_cmd + cmd
- if both commands can be completed at the same time, is it possible that the
above line is executed at the same moment for both completions ?
How is the code protected against a double completion when both completed
commands
see the peer cmd_completed as set ?
> +
> + /* Check if peer command is completed or not*/
> + if (r1_cmd->cmd_completed) {
> + rctx_g35 = &r1_cmd->io_request->RaidContext.raid_context_g35;
> + if (rctx_g35->status != MFI_STAT_OK) {
> + status = rctx_g35->status;
> + ex_status = rctx_g35->ex_status;
> + data_length = r1_cmd->io_request->DataLength;
> + sense = r1_cmd->sense;
> + }
> +
> + megasas_return_cmd_fusion(instance, r1_cmd);
> + map_cmd_status(fusion, scmd_local, status, ex_status,
> + le32_to_cpu(data_length), sense);
> + if (instance->ldio_threshold &&
> + megasas_cmd_type(scmd_local) == READ_WRITE_LDIO)
> + atomic_dec(&instance->ldio_outstanding);
> + scmd_local->SCp.ptr = NULL;
> + megasas_return_cmd_fusion(instance, cmd);
> + scsi_dma_unmap(scmd_local);
> + scmd_local->scsi_done(scmd_local);
> + }
> +}
> +
> +/**
> * complete_cmd_fusion - Completes command
> * @instance: Adapter soft state
> * Completes all commands that is in reply descriptor queue
> @@ -2696,10 +2655,10 @@ complete_cmd_fusion(struct megasas_instance
> *instance, u32 MSIxIndex)
> struct MPI2_RAID_SCSI_IO_REQUEST *scsi_io_req;
> struct fusion_context *fusion;
> struct megasas_cmd *cmd_mfi;
> - struct megasas_cmd_fusion *cmd_fusion, *r1_cmd = NULL;
> + struct megasas_cmd_fusion *cmd_fusion;
> u16 smid, num_completed;
> - u8 reply_descript_type, *sense;
> - u32 status, extStatus, device_id, data_length;
> + u8 reply_descript_type, *sense, status, extStatus;
> + u32 device_id, data_length;
> union desc_value d_val;
> struct LD_LOAD_BALANCE_INFO *lbinfo;
> int threshold_reply_count = 0;
> @@ -2729,25 +2688,11 @@ complete_cmd_fusion(struct megasas_instance
> *instance, u32 MSIxIndex)
>
> while (d_val.u.low != cpu_to_le32(UINT_MAX) &&
> d_val.u.high != cpu_to_le32(UINT_MAX)) {
> - /*
> - * Ensure that the peer command is NULL here in case a
> - * command has completed but the R1 FP Write peer has
> - * not completed yet.If not null, it's possible that
> - * another thread will complete the peer
> - * command and should not.
> - */
> - r1_cmd = NULL;
>
> smid = le16_to_cpu(reply_desc->SMID);
> -
> cmd_fusion = fusion->cmd_list[smid - 1];
> -
> - scsi_io_req =
> - (struct MPI2_RAID_SCSI_IO_REQUEST *)
> - cmd_fusion->io_request;
> -
> - if (cmd_fusion->scmd)
> - cmd_fusion->scmd->SCp.ptr = NULL;
> + scsi_io_req = (struct MPI2_RAID_SCSI_IO_REQUEST *)
> + cmd_fusion->io_request;
>
> scmd_local = cmd_fusion->scmd;
> status = scsi_io_req->RaidContext.raid_context.status;
> @@ -2768,88 +2713,33 @@ complete_cmd_fusion(struct megasas_instance
> *instance, u32 MSIxIndex)
> break;
> case MPI2_FUNCTION_SCSI_IO_REQUEST: /*Fast Path IO.*/
> /* Update load balancing info */
> - device_id = MEGASAS_DEV_INDEX(scmd_local);
> - lbinfo = &fusion->load_balance_info[device_id];
> - /*
> - * check for the raid 1/10 fast path writes
> - */
> - if (!cmd_fusion->is_raid_1_fp_write &&
> - (cmd_fusion->scmd->SCp.Status &
> - MEGASAS_LOAD_BALANCE_FLAG)) {
> + if (fusion->load_balance_info &&
> + (cmd_fusion->scmd->SCp.Status &
> + MEGASAS_LOAD_BALANCE_FLAG)) {
> + device_id = MEGASAS_DEV_INDEX(scmd_local);
> + lbinfo = &fusion->load_balance_info[device_id];
>
> atomic_dec(&lbinfo->scsi_pending_cmds[cmd_fusion->pd_r1_lb]);
> - cmd_fusion->scmd->SCp.Status &=
> - ~MEGASAS_LOAD_BALANCE_FLAG;
> - } else if (cmd_fusion->is_raid_1_fp_write) {
> - /* get peer command */
> - if (cmd_fusion->index < instance->max_fw_cmds)
> - r1_cmd =
> fusion->cmd_list[(cmd_fusion->index +
> - instance->max_fw_cmds)-1];
> - else {
> - r1_cmd =
> - fusion->cmd_list[(cmd_fusion->index -
> - instance->max_fw_cmds)-1];
> - }
> - cmd_fusion->cmd_completed = true;
> + cmd_fusion->scmd->SCp.Status &=
> ~MEGASAS_LOAD_BALANCE_FLAG;
> }
> -
> - if (reply_descript_type ==
> - MPI2_RPY_DESCRIPT_FLAGS_SCSI_IO_SUCCESS) {
> - if (megasas_dbg_lvl == 5)
> - dev_err(&instance->pdev->dev, "\nFAST
> Path "
> - "IO Success\n");
> - }
> - /* Fall thru and complete IO */
> + //Fall thru and complete IO
> case MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST: /* LD-IO Path */
> - /* Map the FW Cmd Status */
> - /*
> - * check for the raid 1/10 fast path writes
> - */
> - if (r1_cmd && r1_cmd->is_raid_1_fp_write
> - && r1_cmd->cmd_completed) {
> - /*
> - * if the peer Raid 1/10 fast path failed,
> - * mark IO as failed to the scsi layer.
> - * over write the current status by the failed
> - * status makes sure that if any one of
> - * command fails,return fail status to
> - * scsi layer
> - */
> - if
> (r1_cmd->io_request->RaidContext.raid_context.status !=
> - MFI_STAT_OK) {
> - status =
> -
> r1_cmd->io_request->RaidContext.raid_context.status;
> - extStatus =
> -
> r1_cmd->io_request->RaidContext.raid_context.ex_status;
> - data_length =
> - r1_cmd->io_request->DataLength;
> - sense = r1_cmd->sense;
> - }
> -
> r1_cmd->io_request->RaidContext.raid_context.status = 0;
> -
> r1_cmd->io_request->RaidContext.raid_context.ex_status = 0;
> - cmd_fusion->is_raid_1_fp_write = 0;
> - r1_cmd->is_raid_1_fp_write = 0;
> - r1_cmd->cmd_completed = false;
> - cmd_fusion->cmd_completed = false;
> - megasas_return_cmd_fusion(instance, r1_cmd);
> - }
> - if (!cmd_fusion->is_raid_1_fp_write) {
> + atomic_dec(&instance->fw_outstanding);
> + if (cmd_fusion->r1_alt_dev_handle ==
> MR_DEVHANDLE_INVALID) {
> map_cmd_status(fusion, scmd_local, status,
> - extStatus, data_length, sense);
> - scsi_io_req->RaidContext.raid_context.status =
> 0;
> - scsi_io_req->RaidContext.raid_context.ex_status
> = 0;
> - if (instance->ldio_threshold
> - && megasas_cmd_type(scmd_local) ==
> READ_WRITE_LDIO)
> + extStatus,
> le32_to_cpu(data_length),
> + sense);
> + if (instance->ldio_threshold &&
> + (megasas_cmd_type(scmd_local) ==
> READ_WRITE_LDIO))
> atomic_dec(&instance->ldio_outstanding);
> + scmd_local->SCp.ptr = NULL;
> megasas_return_cmd_fusion(instance, cmd_fusion);
> scsi_dma_unmap(scmd_local);
> scmd_local->scsi_done(scmd_local);
> - }
> - atomic_dec(&instance->fw_outstanding);
> -
> + } else /* Optimal VD - R1 FP command completion. */
> + megasas_complete_r1_command(instance,
> cmd_fusion);
> break;
> case MEGASAS_MPI2_FUNCTION_PASSTHRU_IO_REQUEST: /*MFI command */
> cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
> -
> /* Poll mode. Dummy free.
> * In case of Interrupt mode, caller has reverse check.
> */
> @@ -3896,7 +3786,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int
> reason)
> {
> int retval = SUCCESS, i, j, convert = 0;
> struct megasas_instance *instance;
> - struct megasas_cmd_fusion *cmd_fusion, *mpt_cmd_fusion;
> + struct megasas_cmd_fusion *cmd_fusion, *r1_cmd;
> struct fusion_context *fusion;
> u32 abs_state, status_reg, reset_adapter;
> u32 io_timeout_in_crash_mode = 0;
> @@ -3973,15 +3863,8 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int
> reason)
> cmd_fusion = fusion->cmd_list[i];
> /*check for extra commands issued by driver*/
> if (instance->is_ventura) {
> - cmd_fusion->is_raid_1_fp_write = 0;
> - cmd_fusion->cmd_completed = false;
> - mpt_cmd_fusion =
> - fusion->cmd_list[i + instance->max_fw_cmds];
> - mpt_cmd_fusion->is_raid_1_fp_write = 0;
> - mpt_cmd_fusion->cmd_completed = false;
> - if (mpt_cmd_fusion->scmd)
> - megasas_return_cmd_fusion(instance,
> - mpt_cmd_fusion);
> + r1_cmd = fusion->cmd_list[i +
> instance->max_fw_cmds];
> + megasas_return_cmd_fusion(instance, r1_cmd);
> }
> scmd_local = cmd_fusion->scmd;
> if (cmd_fusion->scmd) {
> diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h
> b/drivers/scsi/megaraid/megaraid_sas_fusion.h
> index 82a4ff7..9d9658e 100644
> --- a/drivers/scsi/megaraid/megaraid_sas_fusion.h
> +++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
> @@ -673,6 +673,7 @@ struct MPI2_IOC_INIT_REQUEST {
>
> /* mrpriv defines */
> #define MR_PD_INVALID 0xFFFF
> +#define MR_DEVHANDLE_INVALID 0xFFFF
> #define MAX_SPAN_DEPTH 8
> #define MAX_QUAD_DEPTH MAX_SPAN_DEPTH
> #define MAX_RAIDMAP_SPAN_DEPTH (MAX_SPAN_DEPTH)
> @@ -921,7 +922,6 @@ struct IO_REQUEST_INFO {
> u8 span_arm; /* span[7:5], arm[4:0] */
> u8 pd_after_lb;
> u16 r1_alt_dev_handle; /* raid 1/10 only */
> - bool is_raid_1_fp_write;
> bool ra_capable;
> };
>
> @@ -1060,7 +1060,6 @@ struct megasas_cmd_fusion {
> u32 index;
> u8 pd_r1_lb;
> struct completion done;
> - bool is_raid_1_fp_write;
> u16 r1_alt_dev_handle; /* raid 1/10 only*/
> bool cmd_completed; /* raid 1/10 fp writes status holder */
>
