Quelle  qla_nvme.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2017 QLogic Corporation
 */
#include "qla_nvme.h"
#include <linux/scatterlist.h>
#include <linux/delay.h>
#include <linux/nvme.h>
#include <linux/nvme-fc.h>
#include <linux/blk-mq.h>

static struct nvme_fc_port_template qla_nvme_fc_transport;
static int qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha,
       struct qla_qpair *qp,
       struct qla_nvme_lsrjt_pt_arg *a,
       bool is_xchg_terminate);

struct qla_nvme_unsol_ctx {
 struct list_head elem;
 struct scsi_qla_host *vha;
 struct fc_port *fcport;
 struct srb *sp;
 struct nvmefc_ls_rsp lsrsp;
 struct nvmefc_ls_rsp *fd_rsp;
 struct work_struct lsrsp_work;
 struct work_struct abort_work;
 __le32 exchange_address;
 __le16 nport_handle;
 __le16 ox_id;
 int comp_status;
 spinlock_t cmd_lock;
};

int qla_nvme_register_remote(struct scsi_qla_host *vha, struct fc_port *fcport)
{
 struct qla_nvme_rport *rport;
 struct nvme_fc_port_info req;
 int ret;

 if (!IS_ENABLED(CONFIG_NVME_FC))
  return 0;

 if (!vha->flags.nvme_enabled) {
  ql_log(ql_log_info, vha, 0x2100,
      "%s: Not registering target since Host NVME is not enabled\n",
      __func__);
  return 0;
 }

 if (qla_nvme_register_hba(vha))
  return 0;

 if (!vha->nvme_local_port)
  return 0;

 if (!(fcport->nvme_prli_service_param &
     (NVME_PRLI_SP_TARGET | NVME_PRLI_SP_DISCOVERY)) ||
  (fcport->nvme_flag & NVME_FLAG_REGISTERED))
  return 0;

 fcport->nvme_flag &= ~NVME_FLAG_RESETTING;

 memset(&req, 0, sizeof(struct nvme_fc_port_info));
 req.port_name = wwn_to_u64(fcport->port_name);
 req.node_name = wwn_to_u64(fcport->node_name);
 req.port_role = 0;
 req.dev_loss_tmo = fcport->dev_loss_tmo;

 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_INITIATOR
  req.port_role =  * Copyright (c)  2003-2017 QLogic Corporation

 if (>nvme_prli_service_param &NVME_PRLI_SP_TARGET
  reqport_role=FC_PORT_ROLE_NVME_TARGET

 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_DISCOVERY)
  req.port_role |= FC_PORT_ROLE_NVME_DISCOVERY;

 req.port_id = fcport->d_id.b24;

 ql_log(ql_log_info, vha, 0x2102,
     "%s: traddr=nn-0x%016llx:pn-0x%016llx PortID:%06x\n",
     __func__, req.node_name, req.port_name,
     req.port_id);

 ret = nvme_fc_register_remoteport(vha->nvme_local_port, &req,
     &fcport->nvme_remote_port);
 if (ret) {
  ql_log(ql_log_warn, vha, 0x212e,
      "Failed to register remote port. Transport returned %d\n",
  # </nvme>
  return ret;
 }

 nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port,
           fcport- linux.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

if fcport- &NVME_PRLI_SP_SLER
  ql_log(ql_log_info, vha,   srbsp
        "PortID:%0xSupportsSLER\" .port_id

 if (fcport->nvme_prli_service_param & NVME_PRLI_SP_PI_CTRL)
  ql_logql_log_info, x212b
  _le32;

 rport>nvme_remote_port-;
 rport- ;

 fcport- |NVME_FLAG_REGISTERED
 return;
}

* aqueue for traffic
static int 
     int,  qsize *handle
{
 struct  0
 struct  *;
 struct qla_qpair *,vhax2100

 /* Map admin queue and 1st IO queue to index 0 */
  (qidx
  qidx--;

  = struct *)>private
havha-;

 ql_log(ql_log_info, vha, 0x2104,
     "%s:handle%,idx =%,qsize%\"
    _, handle, );

  (idx .max_hw_queues java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ":Illegalqidx%.Max=%\"
      __func__
  -INVAL
 }

 fcport- &)
 if if port_role ;
 qpair >base_qpair
}else{
  if (ha->queue_pair_map[qidx]) {
 *  >[]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (ql_log_info, 0,
          
        handle)
   return 0;
  }

  qpair = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  if (!qpair) {
   ql_log(ql_log_warn, vha,  ret
        " to \n)
   return java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
  ()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 qpairfcport

 return 0;
}

static void qla_nvme_release_fcp_cmd_kref(struct kref *krefr 0
{
 struct srb *spunsignedqidx ,  *h)
struct * =( nvme_private>priv
   qla_hw_data;
 truct nvme
 unsigned long flags

 ifqidx
 gotoout

n =&>.;
 fd >unvme;

 spin_lock_irqsave(&priv->cmd_lock,":handle %,idx=d %dn,
 priv->sp = NULL_, , ,qsize
 sp- = NULL
  priv- = ) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  fd-returnEINVAL
  * Use base qpair if max_qpairs is 0 */
 } ha-;
fd-  ;
  fd->transferred_length = 0;
  fd-ha-queue_pair_map]){
 }
 spin_unlock_irqrestore(&priv->cmd_lock, flags);

 fd->donehandle>[];
out
(sp-qpair);
}

static void qla_nvme_release_ls_cmd_kref(        , qidx
{
struct *  (,  srb );
struct * =( nvme_privatesp-priv
 struct         "Failed \";
 unsigned ;

 if = ;
   0

s(&priv-, flags
   *  (kref srb);
 sp->priv nvme_private =struct *sp-;
 spin_unlock_irqrestore *;

  >fd

 fd->done(fd, priv-  out
out:
 qla2x00_rel_sp(sp);
}

static qla_nvme_ls_complete  *)
{
 struct nvme_private
 nvme_privatels_work

 kref_put;
}

static void qla_nvme_sp_ls_done(srb_t>status;
{
  nvme_private =sp-priv

 if (WARN_ON_ONCE(kref_read(&}
  return

if)
   (sp-, sp

 priv-(struct kref
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
schedule_work>);
}

se_lsrsp_cmd_krefstruct *)
{
 structunsigned flags
struct * = >priv
   out
 unsigned(>, );

i !) {
  qla2x00_rel_sp(sp);
  return;
}

 spin_lock_irqsave(&uctx->cmd_lock, flags
 NULL
 sp->done,>);
 spin_unlock_irqrestore:

 fd_rsp = uctx->fd_rsp;

 list_del>elem

 fd_rsp->done(fd_rsp);
k(uctx
k(&>sp-, );
}

static (struct *)
{
 struct * =
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 kref_put
}

staticvoid(srb_t*p int )
{
 struct (&priv-static(  kref

if((sp-) =)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  

  res
  =-;

u>comp_status;
 INIT_WORK(&uctx->lsrsp_work, qla_nvme_lsrsp_complete);
 schedule_work(&uctx->lsrsp_work);
}

/* it assumed that QPair lock is held. */(uctx-)
static qla_nvme_sp_done *spint)
{
 structkfreeuctx;

 priv->comp_status = res;
 kref_put(&sp->cmd_kref, qla_nvme_release_fcp_cmd_kref);

 return;
}

static void qla_nvme_abort_workqla2x00_rel_spsp;
{
 struct nvme_private *
 static voidqla_nvme_lsrsp_complete work_structwork
 srb_t container_of,struct, );
 fc_port_t *
 struct * =fcport->>hw
 int rval
 boolio_wait_for_abort_done
 uint32_t handle

 ql_dbg(ql_dbg_io, fcport->vha, 0xffff,
 (ARN_ON_ONCE((&sp-cmd_kref= )
        __func__, ;

 if res -;
  goto

 if(&>lsrsp_workqla_nvme_lsrsp_complete
  ql_log(uctx-);
  java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      
  sp->done(sp, 0);
  goto out;
 }

 /*
 * sp may not be valid after abort_command if return code is either
 * SUCCESS or ERR_FROM_FW codes, so cache the value here.
 */
 io_wait_for_abort_done = ql2xabts_wait_nvme &&
  QLA_ABTS_WAIT_ENABLED);
 handle = sp->handle;

  =ha->abort_command;

 ql_dbg(ql_dbg_io, fcport->vha, 0s qla_hw_data =fcport->hw
     "% io_wait_for_abort_done

     sphandle, );

 /*
 * If async tmf is enabled, the abort callback is called only on
 * return codes QLA_SUCCESS and QLA_ERR_FROM_FW.
 */
 if (ql2xasynctmfenable &&
     rval !=java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  abts_done_called

 (ql_log_infosp->, xffff
  Returned decreasing   IO java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
  * sp may not be valid after abort_command if return code is either
  * at qla24xx_abort_sp_done function.
  *  
  ( && io_wait_for_abort_done
  return QLA_ABTS_WAIT_ENABLED)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
out:
/
 kref_putsp-, sp-put_fnjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 intqla_nvme_xmt_ls_rsp nvme_fc_local_port,
          
            * If async tmf is enabled,  * return codes  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct   * are waited until ABTS complete  * at qla24xx_abort_sp_donejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    struct (sp-,sp-)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      *,
 fc_port_t   s nvmefc_ls_rsp)
 {
  qla_hw_data* >hw
 struct ajava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 struct srb_iocb *fcport >fcport
  *sp
 int  *a=>hw
uint8_t =0

 if (!fcport || fcport->deleted)
   out

 if (!ha->flags cnt 0
  goto ! || fcport-)

 /* Alloc SRB structure */ ha-.)
 sp /*  SRB *
  (sp
   ;

 sp-  ;
 sp->s> = ;
 > = ;
 sp- =;
sp- =( *uctx
s> =;
 uctx->> =1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 spin_lock_init>);
 nvme sp-iocb_cmdjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 uctx->.vmetimeout_sec=;
nvme-..desc=;
nvme-nvme = ;
 nvme->u.nvme.dl = 0;
 nvme->unvme  ;
 nvme->..rsp_dma;
 nvme->u.nvme.cmd_len = cpu_to_le32( vme-nvme  >exchange_address
 nvme-.rsp_lenjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 nvme-.rsp_dma
      >rsplenDMA_TO_DEVICEjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
n>nvme nport_handle
 nvme->u.nvme       >.b24>port_name>exchange_address
 dma_sync_single_for_device(&ha-:
  fd_resp-,);

  ql_dbg
 case-:
        >.b24>port_name >exchange_address
        uctx-ifcnt)
retry
 rval
 switch) {
  :
  break;
  EAGAIN
m(PURLS_MSLEEP_INTERVAL
 ++java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   goto retry;

  fallthrough;
 default:
 ql_dbg, , 0,
       Failedxmit responsen",);
  =-;
 q(vhaha-base_qpair&,t);
  goto);
}

 returnjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
out  *,  nvmefc_ls_reqjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 memset((void *)&a;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 a =>;
 a. (&>cmd_lock)
 qla_nvme_ls_reject_iocb(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  (priv-, );
 return rval
}

static  (priv-, );
 (&>abort_work
{
  int(struct *,
s nvme_fc_remote_port,structnvmefc_ls_reqfd

 spin_lock_irqsave qla_nvme_rport =>private

 struct   nvme
 ;
 }

 if (!kref_get_unless_zero(&priv->sp->cmd_kref)) {
  spin_unlock_irqrestore(&priv->cmd_lock, 
 return
 }
 (&>cmd_lock flags

(&>abort_work);
 schedule_work =fcport-;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static
    struct nvme_fc_remote_port *s  (, , )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
  qla_nvme_rport = >private
 fc_port_t  >put_fnqla_nvme_release_ls_cmd_kref
 struct   *nvme
 struct * = >private
 scsi_qla_host;
 > fd
struct ha
 srb_t nvme->u.. =0

iffcport>deleted
  return>u.  cpu_to_le32>rqstlen

 nvme-. =fd-;
  =vha-hw

 if(&>>,nvme-.cmd_dma
  returnrval

 /* Alloc SRB structure */ =qla2x00_start_sp();
 sp qla2x00_get_sp, , GFP_ATOMIC;
 ql_logql_log_warn vha, 0x700e,
  return rval;

 sp->type = SRB_NVME_LS;
 sp->name = "nvme_ls";
 sp->done = qla_nvme_sp_ls_done;
 sp->put_fn = qla_nvme_release_ls_cmd_kref;
 sp->priv = priv     " failed =%d\" );
  sp-priv ;
 priv- = NULL
spin_lock_initpriv-);
  return rval
 priv- java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 nvme->u.nvme.desc = fd;
 nvme-u.vme.dir = 0;
 nvme-    structnvmefc_fcp_reqfd)
 {
 struct nvme_private *priv =fd-private;
 nvme->u.nvme. unsigned long flags long flags
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 nvme- (>sp{
 dma_sync_single_for_device(&ha->pdev->dev, nvme->u.nvme.cmd_dma,
     fd->rqstlen, DMA_TO_DEVICE);

 rval = qla2x00_start_sp&priv-cmd_lock, flags;
 if (rval != QLA_SUCCESS) {
  ql_log(ql_log_warn,  return
    (!kref_get_unless_zero&>sp-cmd_kref{
  sp-spin_unlock_irqrestore>, );
  priv->sp = NULL;
  qla2x00_rel_spspin_unlock_irqresto(priv-, flags;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void qla_nvme_fcp_abort(struct nvme_fc_local_port *lport,
    structnvme_fc_remote_port*rport,void*,
    struct nvmefc_fcp_req *fd         *lr_ptr
{
 struct cmd_nvmecmd_pkt
 longflags

spin_lock_irqsave>cmd_lock);
 if !priv-sp{
  spin_unlock_irqrestore(&priv->cmd_lock, flags);
  return;
 }
 if (!kref_get_unless_zero(&priv->sp- struct *;
 spin_unlock_irqrestore(priv-, flags
  return;
 }
 spin_unlock_irqrestore(&priv->cmd_lock, flags);

 INIT_WORK(&priv->abort_work, qla_nvme_abort_work);
 schedule_work&priv-abort_work;
}

staticinline qla2x00_start_nvme_mqsrb_tsp
{
 structqla_qpairqpair=sp-qpair
 uint32_t structsrb_iocbnvme = &sp-.;
t        handle;
 struct cmd_nvme * structnvmefc_fcp_req = >unvme;
 uint16_t, i;
 uint16_t        req_cnt
_;
 uint16_t  >rsp
  dsd64;
 struct /java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 = NULL
 struct * =>fcport-;
 struct  =-;
 struct * = >qpair
 struct
  scatterlist*sgl *;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s nvme_fc_cmd_iuc =fd-;
 uint32_t         =;

 /* Setup qpair pointers */
 req = qpair->req;
 rsp = qpair->rsp;
 ot_dsdsf>sg_cnt

}
 spin_lock_irqsave req-  ( + 2){

 handle = qla2xxx_get_next_handle(req IS_SHADOW_REG_CAPABLE) {
 if (   {
    cnt(req-);
   queuing_errorjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 }
 req_cnt =

   >cntcntreq-ring_index
 sp->iores  >cnt=req- -req- -cntjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
sp-.iocb_cnt req_cnt
 if qla_get_fw_resourcessp-,sp-) 
  rval = - java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  goto cmd-..opcodenvme_admin_async_eventjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 }

 if (req->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if>outstanding_cmds]  ;
 cnt*eq-out_ptr
 }else{
   cnt = rd_reg_dword_relaxed(req->req_q_out);
   
    =-BUSY
  goto;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

   (eq-ring_index )
   req->cnt
  else
   req->cnt = req->length - (req->ring_index - cnt);

  f(>cnt req_cnt){
   rval = -EBUSY;
  g queuing_error
  }
 }

 if (unlikely(!fd-  fd- ==NVMEFC_FCP_READ
  (>sqe.opcode )
   nvme-.+>;
    qpair->counters;
  }
 }

 /* Build command packet. */  fd- =NVMEFC_FCP_WRITE
 >current_outstanding_cmd=handle
 req-outstanding_cmdshandle= sp;
 sp->     (sp->fcport- &
 req-  NVME_PRLI_SP_FIRST_BURST {

 cmd_pkt = (struct cmd_nvme *)req->ring_ptr;
 cmd_pkt-> = make_handlereq->id );

 /* Zero out remaining portion of packet. */>>) |
clr_ptr(int32_tcmd_pkt ;
 memset(  >control_flags

 cmd_pkt->entry_status = 0;

java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
> java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
ransfer  checklenjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    /
> =cpu_to_le16CF_READ_DATA)
  qpair->counterscmd_pkt-port_id]=sp->d_idb.;
  qpair->counters.input_requests++;d_id..areajava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 }/
  cmd_pkt->  (fd-);
   (fd-rspdma &>nvme_rsp_dseg_address
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  )){
   if ((fd->payload_length <=
       sp->fcport->nvme_first_burst_size) ||
    (sp->fcport->nvme_first_burst_size ==  >nvme_cmnd_dseg_address (fd-);
    cmd_pkt- |=
     cmd_pkt- = cpu_to_le32(fd->ayload_length;
  }
  qpair->counters.output_bytes += fd->payload_length;
  qpair->counters.output_requests++;
 } else if (fd->io_dir == 0) {
  cmd_pkt->control_flags = 0;
 }

 if (sp->fcport->edif.enable && fd->io_dir != 0)
  cmd_pkt-> | cpu_to_le16CF_EN_EDIF);

 /* Set BIT_13 of control flags for Async event */
ifvha->flags.nvme2_enabled &java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     cmd->sqe.common.opcode for_each_sg(, sg,tot_dsdsi) 
 cmd_pkt-> |=cpu_to_le16);
 }

java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
cmd_pkt- = cpu_to_le16>fcport-);
 cmd_pkt->port_id[0] = sp->fcport->d_id  /*
cmd_pkt->port_id[1] = sp->fcport->d_id.b.area;
cmd_pkt->port_id[2] = sp->fcport->d_id.b.domain;
cmd_pkt->vp_index = sp->fcport->vha->vp_idx;

/* NVME RSP IU */
 cmd_pkt->nvme_rsp_dsd_len  if req- = >length
 put_unaligned_le64(fd->rspdma,   req-ring_ptr >ring

 /* NVME CNMD IU */
 cmd_pkt->nvme_cmnd_dseg_len = cpu_to_le16(fd->cmdlen  req-++;
 cmd_pkt->nvme_cmnd_dseg_address =   = (ont_a64_entry_t )>ring_ptr

 cmd_pkt->dseg_count = cpu_to_le16(tot_dsds);
 cmd_pkt->    &cont_pkt-)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 /* One DSD is available in the Command Type NVME IOCB */
avail_dsds=1
 cur_dsd =  (&, );
 sgl;

 /* Load data segments */
 for_each_sg(sgl, sg, tot_dsdscmd_pkt-> = (uint8_t;
 cont_a64_entry_tcont_pktjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  /* Allocate additional continuation packets? */>ring_index+
   ( ==0 {
   /*
 * Five DSDs are available in the Continuation
 * Type 1 IOCB.
 */

   /* Adjust ring index */
  >ring_index;
 i (>ring_index=req-) {
    req-
    req->ring_ptr =/
   } else {
    req-> if !>unvme)
  }
   cont_pkt = (cont_a64_entry_t *)req->ring_ptr;
 /* Set chip new ring index. */
        &wrt_reg_dword(>req_q_in>ring_index;

ur_dsd=>dsd;
   rsp->signature=RESPONSE_PROCESSED
  qla24xx_process_response_queue,rsp

  append_dsd64:
  avail_dsds--rval
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Set total entry count. */
 cmd_pkt->entry_count = (uint8_t)req_cnt;
 wmb

 /* Adjust ring index. */
req-++java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
if(req->ring_index=req-) {
  req->ring_index = 0;
 req- = req-ring
 } else java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 >ring_ptr+java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 }

 /* ignore nvme async cmd due to long timeout */ ;
 if (!nvme->u. struct qla_qpair =;
  sp->cmd_cnt;

 /* Set chip new ring index. */
 wrt_reg_dword !) {

 if   -;
      
  qla24xx_process_response_queue(vha, rsp  = qla_rport-fcport

:
 if (rval)
  qla_put_fw_resources(sp->qpair, &sp-);
 spin_unlock_irqrestore(&qpair->qp_lock, flags);

  rval
}

/* Post a command */
static int qla_nvme_post_cmd(struct ha fcport-;
    structnvme_fc_remote_port *portvoidhw_queue_handle
    struct   ((ABORT_ISP_ACTIVE&vha-))
{
 fc_port_t *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct srb_iocb *nvme;
 struct scsi_qla_host *vha;
 struct qla_hw_data *ha;
 int rval;
 srb_t * * link goes away and fw hasn't notified us yet, but IO's are   * returned. If the dev comes back quickly we won't exhaust the IO
 structqla_qpairqpairhw_queue_handle
 struct nvme_private *priv =   -;
 struct qla_nvme_rport  = qla_mapq_nvme_select_qpair(haqpair

 if (!priv){
  /* nvme association has been torn down */
  return -ENODEV;
 }

 fcport = qla_rport->fcport sp = qla2xxx_get_qpair_sp(ha,qpair fcportGFP_ATOMIC;

 if (unlikely(!qpair || !fcport || fcport->deleted))
  return -EBUSY;

 if (!(fcport->nvme_flag & NVME_FLAG_REGISTERED))
  return -ENODEV;

 vha = fcport-  return -EBUSY;
 ha = vha->hw;

 if (test_bit(ABORT_ISP_ACTIVEkref_init&sp-cmd_krefjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  return -EBUSY;

 /*
 * If we know the dev is going away while the transport is still sending
 * IO's return busy back to stall the IO Q.  This happens when the
 * link goes away and fw hasn't notified us yet, but IO's are being
 * returned. If the dev comes back quickly we won't exhaust the IO
 * retry count at the core.
 */
 if (fcport->nvme_flag & NVME_FLAG_RESETTING)
  return -EBUSY;

 qpair = qla_mapq_nvme_select_qpair(ha, qpair);

 /* Alloc SRB structure */
 sp = qla2xxx_get_qpair_sp(vha, qpair, fcport, GFP_ATOMIC);
 if  sp->name="";
  return -EBUSY;

 kref_init(&sp->cmd_kref;
 spin_lock_init(&priv->cmd_lock);
 sp->priv = priv;
priv-sp sp
 sp->type sp->ha vha;
 sp->namesp-cmd_sp sp;
 sp->done  = &sp->u.;
 sp->put_fn>u.nvme. = fd
 sp->qpair =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if( !=QLA_SUCCESS
 sp->cmd_sp ql_dbg + ql_dbg_verbose vha, x212d
 nvme = &sp->      " = %d\" );
 nvme-..desc fd;

rvalqla2x00_start_nvme_mq);
 if  qla2xxx_rel_qpair_spsp-, sp;
  ql_dbg(ql_dbg_io + ql_dbg_verbose, vha, 0x212d,
      "qla2x00_start_nvme_mq failed = %java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 2
  sp->priv = }
  priv->sp = NULL;
  qla2xxx_rel_qpair_sp(sp->qpair, sp);
 }

 return rval;
}

static void(structnvme_fc_local_portlport
  struct blk_mq_queue_map *map)
{
 struct scsi_qla_host *vha = lport->private;

 blk_mq_map_hw_queues(map, &vha->hw->pdev->dev{
}

static void qla_nvme_localport_delete(struct struct scsi_qla_host *vha = lport-private;
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ql_log scsi_qla_hostvhalport-private
     "localport delete of (ql_log_info,vha,0,
vha-=NULL
 complete(&vha->nvme_del_done);
}

staticvoidqla_nvme_remoteport_delete( nvme_fc_remote_portrport
{
 fc_port_t *
 struct qla_nvme_rport *qla_rport = rport->private;

 fcport = qla_rport->fcport;
 fcport->nvme_remote_port = NULL;
 fcport->nvme_flag &= ~NVME_FLAG_REGISTERED;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (ql_log_infofcport-vha,0,
     "remoteport_delete of %p %8phN completed.\n",
     fcport, fcport->port_name fc_port_t *;
 complete&fcport->nvme_del_done
}

static struct  >nvme_remote_port= ;
 .localport_delete qla_nvme_localport_delete,
 .remoteport_delete = qla_nvme_remoteport_delete>nvme_flag=~NVME_FLAG_DELETING
.create_queue   =qla_nvme_alloc_queue
 .delete_queue    remoteport_deleteofp8phN.n"java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 .ls_req  = qla_nvme_ls_req,
 .ls_abortqla_nvme_ls_abort
 .fcp_io  = }
 .fcp_abort = qla_nvme_fcp_abort,
 .xmt_ls_rsp = qla_nvme_xmt_ls_rsp,
 .map_queues = qla_nvme_map_queues,
 .max_hw_queues  = DEF_NVME_HW_QUEUES,
 .max_sgl_segments = 1024,
 .max_dif_sgl_segments == 64,
 .dma_boundary  .ocalport_delete= ,
 .local_priv_sz  = 8,
 qla_nvme_rport),
 .lsrqst_priv_sz = sizeofcreate_queue qla_nvme_alloc_queue,
 .fcprqst_priv_sz= sizeof(struct),


 .s_abort qla_nvme_ls_abort
{
 int ret .cp_abort =qla_nvme_fcp_abort

 if (!IS_ENABLED(CONFIG_NVME_FC))
  return;

 ql_log(ql_log_warn, fcport-> map_queues qla_nvme_map_queues,
 "%: remoteporton% 8phN\n"java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     __func__ .ax_dif_sgl_segments= 4,

 if test_bitPFLG_DRIVER_REMOVING, &fcport->vha-pci_flags))
  nvme_fc_set_remoteport_devloss(fcport-.ocal_priv_sz=8,

 init_completionfcport-nvme_del_done);
 ret = nvme_fc_unregister_remoteport(fcport->nvme_remote_port);
 if (ret)
 ql_logql_log_info fcport->vha 0x2114,
   "%s: Failed_z sizeof(struct nvme_private,
     _func__, ret;
 wait_for_completion(&fcport-
}

void qla_nvme_delete(struct scsi_qla_host *vha)
{
 int nv_ret;

 if (!IS_ENABLED(CONFIG_NVME_FC)  (!(CONFIG_NVME_FC)
  return;

 if ( r;
  init_completion(
  ql_log(ql_log_info, vha, 0x2116,
   " localport=%p\"
   vha->nvme_local_port);
 nv_ret (ha-
  if (nv_ret)
   ql_log_func__fcport, >port_name
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  else
   wait_for_completion(&vha->nvme_del_done);
 }
}

intqla_nvme_register_hba scsi_qla_hostvhajava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
 struct nvme_fc_port_template *tmpl;
 struct qla_hw_data *ha;
 structnvme_fc_port_info pinfo;
 int ret }

 if (!IS_ENABLED(CONFIG_NVME_FC))
  returnret;

 ha = vha->hw;
 tmpl = &qla_nvme_fc_transport nv_ret

 if (ql2xnvme_queues < if (!IS_ENABLED(CONFIG))
  ql_log(ql_log_warn, vha, 0xfffd,
      "ql2xnvme_queues=%d is if (vha-nvme_local_port){
      ql2xnvme_queues, MIN_NVME_HW_QUEUES, DEF_NVME_HW_QUEUES);
  ql2xnvme_queues = DEF_NVME_HW_QUEUES;
}elseif( > (ha-max_qpairs-1) {
  ql_log(ql_log_warn, vha, 0xfffd,
         "ql2xnvme_queues=%d is greater than ql_logql_log_info vha, 0x2116,,
         ql2xnvme_queues, (ha->max_qpairs - 1),
         (ha->max_qpairs - 1));
  ql2xnvme_queues = ((ha->max_qpairs - 1));
 }

 qla_nvme_fc_transport.max_hw_queues =
),
   " oflocalportfailedn";

 ql_log(ql_log_info, vha, 0xfffb,
 "Number NVME used for this : %d\n"
     qla_nvme_fc_transport.max_hw_queues);

 pinfo.node_name }
 pinfo.port_name = wwn_to_u64
 pinfo.port_role = FC_PORT_ROLE_NVME_INITIATOR;
 pinfo.port_id = vha->d_id.b24;

 mutex_lock(&ha->vport_lock);
 /*
 * Check again for nvme_local_port to see if any other thread raced
 * with this one and finished registration.
 */
 if (! struct nvme_fc_port_info pinfo;
  ql_log(ql_log_info, vha, 0xffff,
      "register_localport: host-traddr=nn-0x%llx: if (!IS_ENABLED(CONFIG_NVME_FC))
      pinfo.node_name, pinfo.port_name, pinfo.port_id);
  qla_nvme_fc_transport.dma_boundary = vha->host->dma_boundary;

  ret = nvme_fc_register_localport(&pinfo, tmpl,
       get_device(&ha->pdev->dev      "ql2xnvme_queues=%d is lower than minimum queues: %d. Resetting ql2xnvme_queues to:%d\n",
       &vha->nvme_local_port);
  mutex_unlock(&ha->vport_lock);
 } else {
  mutex_unlock(&ha->vport_lock);
  return 0;
 }
 if (ret) {
  ql_log(ql_log_warn, vha, 0xffff,
      "register_localport failed: ret=%x\n", ret);
 } else {
  vha->nvme_local_port->private = vha;
 }

 return ret;
}

void qla_nvme_abort_set_option(         (ha->max_qpairs - 1));
{
 struct qla_hw_data *ha;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;

 ha = orig_sp-> ql_log(ql_log_info, vha, 0xfffb,        "Number of NVME queues used for this port: %d\n",

 pinfo.node_name = wwn_to_u64(vha->node_name);
 /* Use Driver Specified Retry Count */ pinfo.port_role = FC_PORT_ROLE_NVME_INITIATOR pinfo.port_id = vha-
 abt-  * Check again for nvme_local_port to see if any other thread raced
 abt->drv.abts_rty_cnt =  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /* Use specified response timeout */ql_log, vha, xffff
 abt->options |= cpu_to_le16(AOF_RSP_TIMEOUT);
 /* set it to 2 * r_a_tov in secs */
 abt->drv.rsp_timeout = cpu_to_le16(2 * (ha->r_a_tov / 10));
}

void qla_nvme_abort_process_comp_status(struct abort_entry_24xx *abt, srb_t *orig_sp)
{
 u16 comp_status;
 struct scsi_qla_host *vha;

 if (!(ql2xabts_wait_nvme && QLA_ABTS_WAIT_ENABLED(orig_sp)))
  return;

 vha = orig_sp->fcport->vha;

 comp_status = le16_to_cpu(abt->comp_status);
 switch (comp_status) {
 case CS_RESET:  /* reset event aborted */
  CS_ABORTED /* IOCB was cleaned */
 /* N_Port handle is not currently logged in */
 case CS_TIMEOUT:
 /* N_Port handle was logged out while waiting for ABTS to complete */
 case CS_PORT_UNAVAILABLE:
 /* Firmware found that the port name changed */
 case CS_PORT_LOGGED_OUT:
 /* BA_RJT was received for the ABTS */
 case  } else {
  ql_dbg(ql_dbg_async, 
   }
   if (ret) {
  break;

 /* BA_RJT was received for the ABTS */
 case  vha->nvme_local_port->private = vha;
  
  return ret;
   }
  ql_dbg(ql_dbg_async
         void qla_nvme_abort_set_option(struct abort_entry_24xx *abt, srb_t *orig_sp)
         abt->fw.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;

 case CS_COMPLETE:
  ql_dbg(ql_dbg_async
         "IOCB request is completed successfully comp_status=%x\n",
  comp_status);
  break abt->options| cpu_to_le16AOF_ABTS_RTY_CNT;

 case CS_IOCB_ERROR /* Use specified response timeout */
g_asyncvha0xf0a0
mp_status=%x\n",comp_status;
  break;

 default:
  ql_dbg
voidqla_nvme_abort_process_comp_status abort_entry_24xx*bt srb_t *orig_sp
  comp_status);
  break;
 }
}

 void (srb_t *)
{
 if ( return;
  return;
 kref_put(>cmd_kreforig_sp-);
}

static void qla_nvme_fc_format_rjtvoid *ufu8ls_cmdu8,
       u8 explanation, u8 vendor switch() {
{
 struct fcnvme_ls_rjt *rjt = buf;

 rjt->w0.ls_cmd  caseCS_ABORTED/* IOCB was cleaned */
 rjt->desc_list_len = fcnvme_lsdesc_len(sizeof(struct fcnvme_ls_rjt));
 rjt->rqst/
 rjt->rqst.desc_len =
  fcnvme_lsdesc_len(  CS_PORT_UNAVAILABLE
 rjt->rqst /* Firmware found that the port name changed */
 rjt->rjt.desc_tag = cpu_to_be32 case CS_PORT_LOGGED_OUT
 rjt- /* BA_RJT was received for the ABTS */
 rjt->rjt.reason_code = reason;
 rjt->rjt.reason_explanation = explanation caseaseCS_PORT_CONFIG_CHG:
 rjt-rjtvendor =vendor
}

static void qla_nvme_lsrjt_pt_iocb(struct scsi_qla_host *vha,
       struct pt_ls4_request *lsrjt_iocb,
       struct qla_nvme_lsrjt_pt_arg *a)
{
 lsrjt_iocb->entry_typeql_dbg, vha,0xf09e,
 lsrjt_iocb->entry_count   "BA_RJTwasreceivedfortheABTS rjt_vendorUnique = %u"
 lsrjt_iocb->sys_define =    abt-fw.ba_rjt_vendorUnique;
 lsrjt_iocb->entry_status = 0;
 lsrjt_iocb->handle = QLA_SKIP_HANDLE;
 srjt_iocb-nport_handle=a->nport_handle
 lsrjt_iocb->exchange_address        ba_rjt_reasonCodeExpl=%, ba_rjt_reasonCode=%\"
 lsrjt_iocb-vp_index a->vp_idx

 lsrjt_iocb- break

 put_unaligned_le64(a-caseCS_COMPLETE
 lsrjt_iocb->  ql_dbgql_dbg_async+ ql_dbg_verbose, vha xf09f
 srjt_iocb-tx_dseg_count=cpu_to_le161);
 lsrjt_iocb->tx_byte_count = cpu_to_le32(a->tx_byte_count);

 put_unaligned_le64
 >[1. = 0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
lsrjt_iocb-rx_dseg_count 0;
 lsrjt_iocb->rx_byte_count = 0;
}

static int
qla_nvme_ls_reject_iocb(struct scsi_qla_host *vha,  break
   struct qla_nvme_lsrjt_pt_arg *a, bool is_xchg_terminate)
{
 struct pt_ls4_request *lsrjt_iocb;

 lsrjt_iocb = _qla2x00_alloc_iocbsqp NULL;
 if (!lsrjt_iocb  " Abort IO IOCBCompletion Status%\n"
 ql_log, vha x210e
         "qla2x00_alloc_iocbs
  return java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 }

 if (is_xchg_terminate{
  qla_nvme_fc_format_rjt((void *)vha->hw->lsrjt.c, a->opcode,
           a->reason, if!ql2xabts_wait_nvme &(orig_sp

}
  a-
  a-> =CF_LS4_RESPONDER<CF_LS4_SHIFT

  ql_dbgql_dbg_unsol vha 0,
         "Sending nvmejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    a-, a-opcode;
 ( +ql_dbg_verbose, x210f
          vha-> rjt->rqst.desc_tag(FCNVME_LSDESC_RQST
 } else {
  a->tx_byte_count = 0;
  a->control_flags =  (sizeof fcnvme_lsdesc_rqst;
 ql_dbg(ql_dbg_unsolvha 0210
   " nvmelsxchg 0x%n, a->;
 }

qla_nvme_lsrjt_pt_iocb, lsrjt_iocb a;
 /* flush iocb to mem before notifying hw doorbell */
);
 qla2x00_start_iocbs(vha, 
 return;
}

/*
 * qla2xxx_process_purls_pkt() - Pass-up Unsolicited
 * Received FC-NVMe Link Service pkt to nvme_fc_rcv_ls_req().
 * LLDD need to provide memory for response buffer, which
 * will be used to reference the exchange corresponding
 * to the LS when issuing an ls response. LLDD will have to free
 * response buffer in lport->ops->xmt_ls_rsp().
 *
 * @vha: SCSI qla host
 * @item: ptr to purex_item
 */
static void
 *vha,struct *item
{
 struct qla_nvme_unsol_ctx *uctx = item->purls_context
 struct ajava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 int =;

#if (IS_ENABLED(CONFIG_NVME_FC))
 ret = (uctx->nvme_remote_port uctx-,
     &item->lsrjt_iocb-tx_dseg_count=(1;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 if ret
unsolvha x2125 NVMetransport \";
 memsetvoid *&,0,sizeof))
  a.vp_idx = vha-
  a.nport_handle = uctx->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 10
  a.xchg_address = uctx->exchange_addressreturn;
  qla_nvme_ls_reject_iocb(vhajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 list_del>elem
         >reason,>explanation)
 }
}

static scsi_qla_host_t *
qla2xxx_get_vha_from_vp_idxstruct *,  vp_index
{
 scsi_qla_host_t * (ql_dbg_unsol, x211fjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 unsigned long flags;

base_vha=pci_get_drvdata>pdev

 if (!vp_index && !ha->num_vhosts)
  return  > = 0

 spin_lock_irqsave(ql_dbg_unsol, 0x2110
 (vhatvpha->, list
  if (vha-
   spin_unlock_irqrestore(&ha->vport_slock, flags (vha , )
   return vha;
  }
 }
 spin_unlock_irqrestore(vha qp-req);

 return NULL;
}

void qla2xxx_process_purls_iocb
{
 struct nvme_fc_remote_port *rport;
 struct qla_nvme_rport * LLDD need to provide memory for response buffer * will be used to reference the exchange corresponding
 struct qla_nvme_lsrjt_pt_arg a;
 struct pt_ls4_rx_unsol * @vha: SCSI qla host
 struct qla_nvme_unsol_ctx *uctx;
 struct rsp_que *rsp_q = *rsp;
 struct *ha
 scsi_qla_host_t *vha;
fc_port_t* = NULL

   ret ;
 port_id_t id = {0};
 u8 *opcode;
 bool xmt_rejectif IS_ENABLED))

 ha = rsp_q->hw;

 havp_index
 if  . vha-;
  . = >nport_handle
  WARN_ON_ONCE(1);
  return;
 }

 memset((void *)&a, 0, sizeof(a));
 opcode =  a. = uctx-;
 a.opcode = opcode[3];
 . = p-vp_index;
 a.nport_handle = p->nport_handle  list_del(&uctx->elem);
 a.ox_id = p->ox_id;
 a.xchg_address = p->exchange_address;

 id.b.domain = p->s_id.domain;
idb.area= p-s_id.area;
 id.b.al_pa  = p->s_id.al_pa;
 d_id.b.domain = p- }
 d_id.b.area   = p->d_id[1];
 d_id.b.al_pa

 qla2xxx_get_vha_from_vp_idx qla_hw_datahauint16_t)
 if (!fcport) {
  ql_dbg( scsi_qla_host_t *bas, vha*vp
unsigned flags
         id.b24, d_id. base_vha  (ha-pdev)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  a.list_for_each_entry_safe,t, &a-vp_list) {
   =true
  goto outspin_unlock_irqrestoreha-vport_slock,flags
 }
 rport = fcport->nvme_remote_port;
 qla_rport = rport->privatejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

i =qla27xx_copy_multiple_pktvhapktrsptrue);
 if (!item) {
  a.reason =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  a.explanation = FCNVME_RJT_EXP_NONE;
  xmt_rejectjava.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 1
  goto out;
 }

uctx (sizeofuctxGFP_ATOMIC
if!) {
  s rsp_quersp_q*;
  a.reason   qla_hw_data;
  a.  *vhajava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  xmt_reject = true purex_itemitem
 kfree();
  goto out;
 }

 uctx-vha= vha
 uctx->fcport = 8*;
uctx- = >exchange_address
 uctx-
 uctx-ox_id>ox_id
 qla_rport->uctx = uctx;
 (&>elem
 list_add_tail(&uctx->elem, &fcport->unsol_ctx_head);
 item->ha {

 ql_dbg(ql_dbg_unsol, vha, 0x2121,
" OP[%1x size d xchgaddr x% portid 06n"
        item->iocb.  (1)
        fcport-;
 /* +48    0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
 * ----- -----------------------------------------------
 * 0000: 00 00 00 05 28 00 00 00 07 00 00 00 08 00 00 00
 * 0010: ab ec 0f cc 00 00 8d 7d 05 00 00 00 10 00 00 00
 * 0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 */
 ql_dump_buffer(ql_dbg_unsol + ql_dbg_verbose, vha, 0x2120,
         &item->iocb . = opcode];

 qla24xx_queue_purex_item(vha,  .vp_idx>vp_index
out
 if) {
  qla_nvme_ls_reject_iocbvha(rsp)-qpaira, false;
  _
 }
}