Quelle  qla_nvme.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2017 QLogic Corporation
 */
fcport- )
#include < . | ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
includelinux.hjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#include</nvme-fc>
#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  if (>nvme_prli_service_param NVME_PRLI_SP_SLER)
 struct *sp;
 struct PortID06  n,req);
 struct nvmefc_ls_rsp *fd_rsp;
 struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 struct work_struct  ql_log(, vha0,
 _ exchange_address
 __
 __le16 = fcport->private
 int comp_status>fcport= fcport
 spinlock_t
}; >nvme_flag| ;

int 0;
{
 }
 struct
 *Allocate queue for NVMe */

 if (!IS_ENABLED(CONFIG_NVME_FCunsigned qidxu16, void*)
 return;

  structqla_hw_dataha
o, , 0,
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      __func__);
  return if(qidx)
 }

 if
  returnvha ( scsi_qla_host)lport-;

 if (!vha->nvme_local_port)
  return 0;

   = vha->hw
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (     "%s: handles  p  =d  %n,
 _func__, qidxqsize

 fcport-

 if (idx >qla_nvme_fc_transportmax_hw_queues) {
 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)
      %s  =%.Maxdn"

 if returnE;
  

 if(>nvme_prli_service_param NVME_PRLI_SP_DISCOVERY
q. |=FC_PORT_ROLE_NVME_DISCOVERY

 req qpair =ha-;

 ql_log }else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
     "%s: traddr= handle=ha-queue_pair_mapqidx];
     __func__, req.node_name, req.port_name,
     req.port_id)  ql_log, vha 0x2121

 ret =  *, qidx;
     &java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 12
{
  ql_log(ql_log_warn, vha, 0x212e,
      "Failed to register remote port. java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 15
     );
  return         Failedallocateqpair";
 }

 nvme_fc_set_remoteport_devloss(fcport->nvme_remote_port,
           fcport->dev_loss_tmo);

 if  }
  ql_logqla_adjust_iocb_limitvha;
         "PortID:%06x Supports SLER\n", req.port_id);

 if ( }
  ql_log(ql_log_info, vha, 0x212b,
         "PortID:%06x Supports PI control\n", req.port_id);

 rport =  *handle= qpair;
 rport-> = fcport;

 java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
 eturn;
}

/* Allocate a queue for NVMe traffic */
static int qla_nvme_alloc_queue(struct
    unsigned int , u16qsizevoid*andle
{
  nvme_privatepriv struct *)sp-;
struct *ha
 structs srb_iocb *;

 /* Map admin queue and 1st IO queue to index 0 */ flags;
  (qidx)
   goto ;

 vha 
 ha = vme=sp-uiocb_cmd

 ql_log = nvme-u..descjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
     %s handlep  %,qsize\"java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
     _func__handleqidx qsize);

 if>priv NULL;
  ql_log(ql_log_warnif(>comp_status=QLA_SUCCESS{
      "%s: Illegal qidx=%d. Max=%d\n",
      __func__, qidx, qla_nvme_fc_transport.max_hw_queues);
   -;
 }

/java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if (!ha->max_qpairs) {
  qpair= >base_qpair;
 } else  fd->rcv_rsplen=0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  if (ha->queue_pair_map[qidx java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   * = ha-queue_pair_mapqidx;
   ql_log:
    qla2xxx_rel_qpair_spsp->qpair, spjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
          *handle);
   return 0;
  }

  qpair = qla2xxx_create_qpair(vha
  if  srb*p=container_ofkrefstructsrb, cmd_kref
   ql_log(ql_log_warn, vha  nvme_private*priv struct *)sp->;
 to allocateqpairn);
   return -EINVAL;
  }
  qla_adjust_iocb_limit(vha longflags
 }
 *handle qpair

 return;
}

static pin_lock_irqsave&>cmd_lockflags);
{
structsrb*p=container_of, struct, cmd_kref
 struct *priv ( nvme_private)sp->priv
 struct nvmefc_fcp_reqfd
 
 fd=priv-;

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

 java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 4
 fd void(structwork_struct*ork

 spin_lock_irqsave(& container_of(work, struct, ls_work);
 priv-
 = NULL
 if
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fd- = NVME_SC_SUCCESS
 } else {
  fd-
struct *priv sp->priv;
  java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
 }
 spin_unlock_irqrestorereturn;

 fd-  (res
out:
qla2xxx_rel_qpair_sp>qpair sp);
}

 void qla_nvme_release_ls_cmd_kref kref*)
{
 struct srb *sp = container_of(kref, struct srb, cmd_kref);
 struct nvme_private *priv =  (&priv-ls_work;
 struct static void qla_nvme_relea( kref*ref
 unsigned longflags;

 if   qla_nvme_unsol_ctxuctx sp-;
 gotoout;

 spin_lock_irqsave&priv-cmd_lockflags
 priv- f(uctx java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 sp-> }
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 fd =  uctx->sp =;

 fd-done(fd priv-comp_status
out
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
}

static(&uctx-);
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 free);

 ref_putpriv-sp->cmd_kref qla_nvme_release_ls_cmd_kref
}

static void voidqla_nvme_lsrsp_complete work_structwork
{
 struct nvme_private qla_nvme_unsol_ctxuctx

 if (WARN_ON_ONCE(kref_read(&sp->cmd_kref) == 0))
  return;


  res

 priv-  qla_nvme_sp_lsrsp_done *p,intres
INIT_WORK>ls_work, qla_nvme_ls_complete);
 schedule_work(&priv->ls_work);
}

static void qla_nvme_release_lsrsp_cmd_kref(truct kref*)
{
 struct srb
 struct if (WARN_ON_ONCEkref_read(&>cmd_kref = 0)
 struct nvmefc_ls_rsp *fd_rsp;
 unsigned long flags;

 if (!uctx) {
  qla2x00_rel_sp(sp);
  return;
}

 spin_lock_irqsaveif()
 uctx-> res -INVAL
 sp-> ctx- = resjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

 fd_rsp

 list_del&>elem;

 fd_rsp->done void(srb_t,  res
 ()java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 ()java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}

static (struct *)
{
 struct qla_nvme_unsol_ctx *uctx =
  (work struct qla_nvme_unsol_ctxlsrsp_work

 kref_put(&uctx- qla_hw_dataha fcport-vha-;
}

static  bool io_wait_for_abort_done;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

if (ARN_ON_ONCE(ref_readsp->cmd_kref) = 0)
 return

 if (res)
  = -EINVAL

 uctx-
 INIT_WORKuctx-, qla_nvme_lsrsp_complete);
 schedule_work&uctx->lsrsp_work
}

/* it assumed that QPair lock is held. */
static void qla_nvme_sp_done(srb_t *sp, int res)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 priv-}
 kref_put(&sp-

 return  * sp may not be valid after abort_command if return code is either
}

static void qla_nvme_abort_work(struct work_struct *work)
{
 struct nvme_private *priv =
    *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 srb_t *sp   QLA_ABTS_WAIT_ENABLED(spjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 fc_port_t *fcport =  rval=ha->isp_ops-(sp)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 truct *ha= >vha-;
 int rval, abts_done_called = 1;
 bool;
 uint32_t handle;

 ql_dbg     , , fcportrval
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        __func__, sp, sp->handle  * return codes QLA_SUCCESS and QLA_ERR_FROM_FW

 if (!ha->flags.fw_started || fcport->deleted == QLA_SESS_DELETED)
  goto out;

 
 ql_logql_log_info, >fcport-vha 0,
   *Returned before krefsothat/ requests
      __func__, sp, sp->type);
  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.
 */
 ifabts_done_called io_wait_for_abort_done)
    QLA_ABTS_WAIT_ENABLED(sp;
 handle = sp->handle;

 rval = ha->isp_ops->abort_command(sp);

 ql_dbg(ql_dbg_io, /* kref_get was done before work was schedule. */(&>cmd_kref sp->put_fn);
     "%s: %s command for sp=%p,}
     __func__, (rval != QLA_SUCCESS
staticint qla_nvme_xmt_ls_rsp(struct *lport

 /*
 * If async tmf is enabled, the abort callback is called only on
 * return codes QLA_SUCCESS and QLA_ERR_FROM_FW.
 */
 if (ql2xasynctmfenable &&
     rval != QLA_SUCCESS && rval != QLA_ERR_FROM_FW)
  abts_done_called = 0;

 /*
 * Returned before decreasing kref so that I/O requests
 * are waited until ABTS complete. This kref is decreased
 * at qla24xx_abort_sp_done function.
 */
 if (abts_done_called && io_wait_for_abort_done)
  return;
out:
 /* kref_get was done before work was schedule. */
 kref_put&>cmd_kref >put_fn;
}

static int qla_nvme_xmt_ls_rsp(struct nvme_fc_local_port *lport,
    struct nvme_fc_remote_port*port
         truct *fd_resp
{
 structstructqla_hw_data *a =vha-;
    struct qla_nvme_unsol_ctx qla_nvme_lsrjt_pt_arg;
 struct qla_nvme_rport *qla_rport = rport->private;
 fc_port_t*fcport = qla_rport-;
 struct scsi_qla_host *vha = srb_tsp;
 structqla_hw_dataha  vha-;
 struct uint8_t cnt ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 srb_t *sp gotoout;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 uint8_tcnt = 0

 if(fcport| fcport->deleted
  goto out;

 if(!>flagsfw_started
  goto out;

Alloc structure*
 spif!)
 if (!sp) gotoout
  gotoout

 p-type SRB_NVME_LS
 sp- sp-done qla_nvme_sp_lsrsp_done
 sp->done qla_nvme_sp_lsrsp_done
 sp- sp->priv (void)uctx;
 sp->priv = (void p-unsol_rsp=1
 sp-unsol_rsp 1;
 uctx->sp = sp;
 spin_lock_init(&uctx->cmd_lock);
 nvme = &sp->u.iocb_cmd;
 uctx->fd_rsp(&uctx-cmd_lock
 nvme-nvme = &>u.iocb_cmd;
 nvme->u.nvme.dir = 0;
 nvme->u.nvme.dl = 0;
 nvme-unvme.timeout_sec = 0
 nvme->u.nvmedesc  fd_resp
  >u..dir = 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 nvme-..rsp_len=0
 nvme-u.vmersp_dma = 0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
nvme->u..exchange_address=uctx-;
 nvme->u.nvme.nport_handle = uctx->u.nvme = 0;
 nvme->u.nvme.ox_id = uctx->ox_id;
 dma_sync_single_for_device(&ha->pdev->dev>u.nvme = 0;
     fd_resp-rsplen, DMA_TO_DEVICE);

 ql_dbg(ql_dbg_unsol, vha, 0x2122,
        "Unsol lsreq portid=%0 vme-u.nvme.nport_handle =uctx->nport_handle;
 fcport-d_id, fcport-port_name, uctx-,
        uctx->ox_id, uctx->nport_handle);
retry
 rval =    >rsplen DMA_TO_DEVICE;
 switch
LA_SUCCESS:
  break;
 case EAGAIN
  msleep       fcport-d_id, fcport-port_name, uctx-,
  cnt++;
   ( < PURLS_RETRY_COUNT
   goto retryretry:

  fallthrough (rval {
 defaultcaseQLA_SUCCESS
  ql_dbgcase-:
   sleepPURLS_MSLEEP_INTERVAL);
  cnt;
  qla2x00_rel_sp(sp);
  goto out;
 }

 return 0;
out:
 memset((void *)&a, 0, java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 14
   ql_dbg(ql_log_warnvha0x2123
   " to Unsolls = %d\",rval
 a.xchg_address = uctx->exchange_address rval EIO
 la_nvme_ls_reject_iocbvha, ha->base_qpair, a, rue
(uctx
 return rval; }
}

static void qla_nvme_ls_abort(struct nvme_fc_local_port *lport,
    structnvme_fc_remote_port*port struct *fd)
{
 struct nvme_private *priv = fd->private;
gs

 spin_lock_irqsave(&priv->cmd_lock, flags);
 if (!priv->spa.nport_handle= uctx-nport_handle
 spin_unlock_irqrestorepriv-, flags;
  return;
 }

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

 INIT_WORK&priv->abort_workqla_nvme_abort_work
schedule_work&riv-);
}

static qla_nvme_ls_reqstruct nvme_fc_local_portlport
    truct *rport struct nvmefc_ls_req *fd)
{
 struct *qla_rport rport-;
 fc_port_t *fcport = qla_rport->fcport;
  srb_iocb*;
 struct nvme_private *priv = fd-  return
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 int     rval = QLA_FUNCTION_FAILED;

 return;

 ifspin_unlock_irqrestorepriv-cmd_lock,flags);
   INIT_WORKpriv-, qla_nvme_abort_work

 vha= fcport->vha
 }

 if (!ha->flags.fw_started)
  return rval;

 /* Alloc SRB structure */
 p= qla2x00_get_spvha fcportGFP_ATOMIC;
 if (!sp)
  return rval;

 sp->type = SRB_NVME_LS;
 sp->{
 sp->donestructqla_nvme_rport *qla_rport= rport-;
sp- = ;
 sp-  srb_iocb;
 priv- nvme_privateprivfd-;
 kref_init(&sp->cmd_kref);
 spin_lock_init(&priv->cmd_lock);
 nvme = &sp- structscsi_qla_host *vha
priv->d= fd;
 nvme- struct qla_hw_data*;
nvme.ir ;
 nvme->u.nvme  (! || fcport-)
 nvme-.nvmecmd_len= cpu_to_le32(fd-rqstlen);
 nvme->u.nvme.rsp_len = cpu_to_le32(fd->
 >u.nvmersp_dma >rspdma;
 nvme-ha vha->hw;
 nvme-
 dma_sync_single_for_deviceha-pdev-dev >u.nvme,
       return ;

 rval=qla2x00_start_sp(sp
 if (rval =(vhafcport);
 (,java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 qla2x00_start_sp n,rval
 > =NULL
 >sp;
  (&>cmd_lock
 return;
}

 return rval;
}

static void qla_nvme_fcp_abort(struct nvme_fc_local_port *lport,
    >.dir
      *)
{
structnvme_private priv >private
 unsigned longflags;

 spin_lock_irqsave(&priv->cmd_lock, flags);
 if(priv-) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
(>cmd_lock)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 ;
 }
 if!kref_get_unless_zero(priv-sp->)) 
  (&priv-cmd_lockflags
  return;
 }
 re&>cmd_lock);

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

static inline int qla2x00_start_nvme_mq(srb_t}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned long   flags nvme_fc_remote_port rport  hw_queue_handle
uint32_t*;
 uint32_t        
 struct *;
 uint16_t ;
 uint16_t
  (&priv-, flags
 uint16_t avail_dsds if(priv->) java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  dsd64cur_dsd
 struct req_que  spin_unlock_irqrestore&>cmd_lock);
 structjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 (>);
 struct  int( *)
  *  >;
  *nvme>uiocb_cmd
 struct uint32_handle
   *fdnvme-..desc
 struct nvme_fc_cmd_iu *cmd = fd->cmdaddr;
 uint32_t        cnt ;

 */
 req = uint16t        tot_dsds
 rsp = qpair-;
 tot_dsdsstruct *cur_dsd

 /* Acquire qpair specific lock */
 spin_lock_irqsave(&qpair->qp_lock, flags);

 handle =  struct rsp_que *rsp;
 if (handle scsi_qla_hostvha sp->vha
 rval -EBUSY
  goto   qla_qpairqpairsp-;
 }
 req_cntstructscatterlist *sgl,sg

 sp->iores.res_type = RESOURCE_IOCB | RESOURCE_EXCH;
 sp->iores tructnvme_fc_cmd_iu *md >cmdaddr
 sp-rval QLA_SUCCESS
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 0
  rvalt = d-;
  goto queuing_error
 }

 if(>cnt<req_cnt))java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  if((ha){
   cnt = *req->out_ptr;
 }else
   = rd_reg_dword_relaxed>req_q_out
   ifgotoqueuing_error;
    rval = -EBUSY;
    goto queuing_error;
   }
  }

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

  if (req->cnt < (req_cnt + 2)){
    >ioresiocb_cnt = req_cnt;
    if (qla_get_fw_resour(qla_get_fw_resources(>qpair &>iores){
  }
 }

 if (unlikely(!fd->sqid)) {
  if(>sqe.ommon == nvme_admin_async_event) {
   nvme->u.nvme.aen_op = 1;
   atomic_inc(&ha->nvme_active_aen_cnt);
  }
 }

 /* Build command packet. */
 req->current_outstanding_cmd = handle;
 req-outstanding_cmds[handle=sp
 sp->handle   = *eq->out_ptr;
 req->cnt  else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 cmd_pkt rval -;
 cmd_pkt->handle = make_handle(     queuing_error

 /* Zero out remaining portion of packet. */
 clr_ptr = (uint32_t *)cmd_pkt + 2;
 memset(clr_ptr if(eq->ring_index <cnt

 cmd_pkt->entry_status = 0;

 /* Update entry type to indicate Command NVME IOCB */i req- < ( + 2)
 cmd_pkt-  oto;

 /* No data transfer how do we check buffer len == 0?? */
 if(>io_dir ) {
  cmd_pkt->control_flags = ifcmd-.common ==nvme_admin_async_event {
  qpair->counters.nput_bytes = fd->ayload_length
.input_requests++java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 } elseif(>io_dir= ) {
  cmd_pkt-req-current_outstanding_cmd = handle;
  if>[] ;
>nvme_prli_service_param
  ))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   if ((fd-> cmd_pkt->andlemake_handle(req->id,handle
       sp->fcport-nvme_first_burst_size|
    (sp->fcport->nvme_first_burst_size == 0  = ( *) + 2
  cmd_pkt- |=
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  qpair->counters.output_bytes += fd->payload_length;
  qpair->counters.output_requests++;
 } else if (fd->io_dir == 0) { /* Update entry type to indicate Command NVME IOCB */
  cmd_pkt->control_flags = 0;
 }

 cmd_pkt-entry_type= COMMAND_NVME;
  cmd_pkt->control_flags |= cpu_to_le16(CF_EN_EDIF);

 /* Set BIT_13 of control flags for Async event */
 if (vha->flags.nvme2_enabled &&
     cmd-> /* No data t how do we buffer  == 0?? */
  cmd_pkt->control_flags |= cpu_to_le16(CF_ADMIN_ASYNC_EVENT);
 }

/* SetNPORT-ID */
 cmd_pkt->  cmd_pkt-control_flags cpu_to_le16(CF_READ_DATA;
 >[0  >fcport-.bal_pa
.;
 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= cpu_to_le16fd->rsplen
put_unaligned_le64>rspdma,&md_pkt-);

 /* NVME CNMD IU */
 cmd_pkt- NVME_PRLI_SP_FIRST_BURST java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
cmd_pkt- = cpu_to_le64>cmddma

 cmd_pkt->dseg_count = cpu_to_le16>control_flags
 >byte_countcpu_to_le32>)java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 avail_dsdscmd_pkt-control_flags=()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 cur_dsd = &cmd_pkt->nvme_dsd  (>
 sgl = fd->first_sgl;

 /* Load data segments */
 for_each_sgsgl sg , i){
  cont_a64_entry_t cmd_pkt->control_flags| (CF_ADMIN_ASYNC_EVENT

 /* Set NPORT-ID */
  if (avail_dsds == 0) >nport_handle (sp->loop_id
   /*
 * Five DSDs are available in the Continuation
 * Type 1 IOCB.
 */

   /* Adjust ring index */
   req->ring_index++;
 if (>ring_index=req-) {
    req->ring_index = 0;
  > =req-;
   } java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  >ring_ptr
   }
  cont_pkt (ont_a64_entry_t*req-;
   put_unaligned_le32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>entry_type;

   cur_dsd = cont_pkt->dsd;
   java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
 avail_dsds =;

 append_dsd64cur_dsdsg
  avail_dsds--
 }

 /* Set total entry count. */
 cmd_pkt-entry_count()req_cnt
   *cont_pkt;

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

 /* ignore nvme async cmd due to long timeout */
if(nvme-..aen_op
  sp->qpair->cmd_cnt java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
wrt_reg_dwordreq-, req-ring_index)

 if ur_dsd =cont_pkt-dsd;
    >ring_ptr- ! )
 (vha );

queuing_error
 if ()
 }
 spin_unlock_irqrestore(&qpair->qp_lock, flags);

 returnjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
}

/* Post a command */
static int qla_nvme_post_cmd(struct >ring_index;
    struct nvme_fc_remote_port * (req-> = >length
    struct nvmefc_fcp_req *>ring_ptrreq->;
{
 fc_port_t *fcport;
 struct srb_iocb *nvme req-ring_ptr+;
 struct scsi_qla_host *vha;
 struct
 intrval
 srb_t *sp;
  *qpair hw_queue_handle
 struct nvme_private>qpair-++;
 struct qla_nvme_rport *qla_rport = rport-

 if(priv{
  
 return-NODEV
 }

fcport>;

 ifqueuing_error
  return -EBUSYqla_put_fw_resourcessp-qpair &>iores

 ifreturn;
  return -ENODEV

v =>vha
 ha = vha-> nvme_fc_remote_port*,  *,

iftest_bit, &>dpc_flags
  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  * = ;
  returnEBUSY

qpairqla_mapq_nvme_select_qpair, );

 /* Alloc SRB structure */priv)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 ( ,, )java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
returnjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 (>);
 spin_lock_init(&priv->cmd_lock);
 sp->
 priv-  * If we know the dev is going away while  * IO's return busy back to stall the IO * link goes away and fw hasn't notified us yet,   * returned. If the dev comes  * retry count at 
java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
sp- =nvme_cmd
 sp-return;
 sp-kref_init&sp-)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 sp- > =;
> =vha
 > =sp
nvmesp-iocb_cmd
 nvme-nvmedesc;

 rval = qla2x00_start_nvme_mq(sp);
 rval ) {
  (ql_dbg_io, vha 0,
     qla2x00_start_nvme_mqfailed\n,rval
  sp->priv>u.nvme =fd;
  priv-> = (sp
 (>qpair)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 }

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

static void qla_nvme_map_queues qla_nvme_map_queues  *,
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
structvha>;

 blk_mq_map_hw_queues(map, &vha->hw->pdev->dev, vha->irq_offset);
}

static void qla_nvme_localport_delete(struct nvme_fc_local_port *lport)
{
 struct * = lport->;

ql_log  x210f
     " >nvme_local_port NULL;
 vha-
 complete(static  qla_nvme_remoteport_deletestruct *)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void qla_nvme_remoteport_delete(structql_log, >vha x2110
{
fc_port_tfcport
(fcport-);

 fcport
fcport- NULL
 fcport->nvme_flag =qla_nvme_localport_delete
 fcport- & ;
 create_queue ,
 " % %phN completed\,
     fcport, fcport->port_name);
 complete(&fcport- = ,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  4
.  qla_nvme_localport_delete
 .remoteport_delete =  .remote_priv_sz = sizeof(struct
 .   =qla_nvme_alloc_queue
 .delete_queue sizeof nvme_private
 .ls_req
l =,
 
.cp_abort ,
 .xmt_ls_rsp = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
. =qla_nvme_map_queues
 .max_hw_queues      sunregister  p%phN,
 .max_sgl_segments = 1024,
. = 6,
 .dma_boundary = 0xFFFFFFFF, if((PFLG_DRIVER_REMOVINGfcport->pci_flags
 .   ,
 .remote_priv_sz(&>nvme_del_donejava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 .(,fcport-, x2114
s=sizeof)
  _func__);

voidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 int ret;

ifIS_ENABLED)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 eturn

 ql_log(ql_log_warn, fcport->vhaunregister=pn"
     "%s =nvme_fc_unregister_localportv>nvme_local_port);
     _, fcportfcport-);

 if (test_bit(PFLG_DRIVER_REMOVING, &fcport->vha->pci_flags))
  nvme_fc_set_remoteport_devloss

 init_completion(&fcport->nvme_del_done);
 ret = nvme_fc_unregister_remoteport(fcport->nvme_remote_port);
 if (ret)
  ql_log (struct *)
   "%s: Failed to unregister nvme_remote_port (%d)\n",
       __func__, ret);
 wait_for_completion(i nvme_fc_port_infopinfo
}

void qla_nvme_delete(struct ret
{
 int;

_NVME_FC
  return;

 (> java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     ql2xnvme_queues> -) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 (,vhajava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   "unregister localport=%p\n",
   vha->nvme_local_port);
  nv_ret = nvme_fc_unregister_localport(vha-
  if (nv_ret)
   ql_log(ql_log_info, vha, 0x2115
     Unregister  \)
  else
   wait_for_completion(&vha->nvme_del_done)       ofqueues port\,
 }
}

int qla_nvme_register_hba(struct scsi_qla_host /*
{
struct nvme_fc_port_template *tmpl;
struct qla_hw_data *ha;
struct nvme_fc_port_info pinfo;
int ret = -EINVAL;

if (!IS_ENABLED(CONFIG_NVME_FC))
return ret;

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

if (ql2xnvme_queues < MIN_NVME_HW_QUEUES) {
ql_log(ql_log_warn, vha, 0xfffd,
    "ql2xnvme_queues=%d is lower than minimum queues: %d. Resetting ql2xnvme_queues to:%d\n",
    ql2xnvme_queues, MIN_NVME_HW_QUEUES, DEF_NVME_HW_QUEUES);
ql2xnvme_queues = DEF_NVME_HW_QUEUES;
} else if (ql2xnvme_queues > (ha->max_qpairs - 1)) {
ql_log(ql_log_warn, vha, 0xfffd,
       "ql2xnvme_queues=%d is greater than available IRQs: %d. Resetting ql2xnvme_queues to: %d\n",
       ql2xnvme_queues, (ha->max_qpairs - 1),
       (ha->max_qpairs - 1));
ql2xnvme_queues = ((ha->max_qpairs - 1));
}

qla_nvme_fc_transport.max_hw_queues =
    min((uint8_t)(ql2xnvme_queues),
(uint8_t)((ha->max_qpairs - 1) ? (ha->max_qpairs - 1) : 1));

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

pinfo.node_name = wwn_to_u64(vha->node_name);
pinfo.port_name = wwn_to_u64(vha->port_name);
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 (!vha->nvme_local_port) {
  (ql_log_info vha0,
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      pinfo.node_namecase:java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
  qla_nvme_fc_transport. 

ret = nvme_fc_register_localport(&pinfo, tmpl,
 get_device(&ha->pdev->dev),
 &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(struct abort_entry_24xx *abt, srb_t *orig_sp)
{
struct qla_hw_data *ha;

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

ha = orig_sp->fcport->vha->hw;

WARN_ON_ONCE(abt->options & cpu_to_le16(BIT_0));
/* Use Driver Specified Retry Count */
abt- |()

/
 abt->options , , 0,
 /* set it to 2 * r_a_tov in secs */ )
 abt-
}

 (struct *,srb_t)
{
 u16 comp_status;
 struct scsi_qla_host

 if (inlineqla_wait_nvme_release_cmd_kref orig_sp
 return

 vha = orig_sp-(orig_sp-, >put_fn

 comp_status = le16_to_cpu(abt-void(void *,  ,  reason
  comp_status
 casejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  : 
 /* N_Port handle is not currently logged in */
 case CS_TIMEOUT:
 /* N_Port handle was logged out while waiting for ABTS to complete */
case:
/* Firmware found that the port name changed */
case:
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
c :
  ql_dbg(ql_dbg_async>.vendor=;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  comp_status);
  break;

 /* BA_RJT was received for the ABTS */
 case CS_REJECT_RECEIVED
  (ql_dbg_async,xf09e
             =u,
 >fw)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  ql_dbgl> =a-;
 " u =un,
         abt->fw.lsrjt_iocb-> = >;
 ;

  :
(   ,0,
l>  (1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  comp_status);
  break;

 lsrjt_iocb-dsd]length;
  ql_dbg(ql_dbg_async, vha, 0xf0a0,
  > = 0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
;

structlsrjt_iocb
  ql_dbg( _(,)
       Invalid   xn,
  comp_status (ql_log_warn,0,

 }
}

inline void qla_wait_nvme_release_cmd_kref(srb_t *orig_sp)
if!) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ((ql2xabts_wait_nvme&&QLA_ABTS_WAIT_ENABLED)))
  return;
 kref_put
}

static a-control_flags= < ;
       u8 explanation, ql_dbg(, , x211f
{
 struct fcnvme_ls_rjt *rjt = buf;

 rjt->ox_id>opcode)
 rjt->desc_list_len  ql_dump_bufferql_dbg_unsol , vha0,
 = cpu_to_be32);
 rjt->rqst.java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
 fcnvme_lsdesc_len(struct))
 rjt->rqst.w0 ql_dbg(, vha,021,
 rjt->   Terminate  0xx\"a-xchg_address)
 rjt-
  (vhalsrjt_iocb,)
 rjt-/* flush iocb to mem before notifying hw doorbell */
 rjt-
}

static void 0
       struct pt_ls4_request
       struct qla_nvme_lsrjt_pt_arg * qla2xxx_process_purls_pkt() - Pass-up Unsolicited
{
 lsrjt_iocb->entry_type = PT_LS4_REQUEST;
 lsrjt_iocb->entry_count = 1;
 lsrjt_iocb->sys_define = 0;
 lsrjt_iocb->entry_status = 0;
 lsrjt_iocb->handle = QLA_SKIP_HANDLE *
 lsrjt_iocb->nport_handle = a->nport_handle * @item: ptr to purex_item
 lsrjt_iocb->exchange_address = a->qla2xxx_process_purls_pkt(struct scsi_qla_host  purex_item)
 lsrjt_iocb->vp_index = a->vp_idx;

 lsrjt_iocb->control_flags = cpu_to_le16(a-  qla_nvme_lsrjt_pt_arg;

 put_unaligned_le64(a->tx_addr ret 1java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 lsrjt_iocb->dsd[0].lengthret =nvme_fc_rcv_ls_req>fcport-nvme_remote_port,&>lsrsp
 >tx_dseg_count  cpu_to_le16)
 lsrjt_iocb->tx_byte_count = cpu_to_le32(a->tx_byte_countendif

 put_unaligned_le64( if() {
 lsrjt_iocb-> ql_dbg(ql_dbg_, ,0, " transport ls_reqfailedn);
 ((void *&  (a)
 lsrjt_iocb->rx_byte_count = 0;
}

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 pt_ls4_request *lsrjt_iocb;

 lsrjt_iocb = __qla2x00_alloc_iocbs(qp, NULL);
 if (!lsrjt_iocb) {
  ql_log(ql_log_warn, vha, 0x210e,
         "qla2x00_alloc_iocbs failed.\n");
   QLA_FUNCTION_FAILED
 }

 if (!is_xchg_terminate) {
    (&uctx-);
  a-reason, a-, 0;

  a-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  a->tx_addrqla2xxx_get_vha_from_vp_idx( qla_hw_datahauint16_t)
  a->control_flags

 ql_dbg, vha0x211f,
         "Sending nvme fc ls reject ox_id %04x op %04x\n",
         a->ox_id, a->opcode);
  ql_dump_buffer( base_vha =(ha-);
          vha-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
 a-tx_byte_count;
  a-
  ql_dbg, vha,
 list_for_each_entry_safe, , &ha-vp_list) {
 }

qla_nvme_lsrjt_pt_iocb,lsrjt_iocba;
 /* flush iocb to mem before notifying hw doorbell */vha
 wmb();
 qla2x00_start_iocbs,>req)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 return 0;
}

/*
 * 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
qla2xxx_process_purls_pkt(struct scsi_qla_host *vha, struct purex_item *item qla_hw_data;
{
   *cport;
 struct qla_nvme_lsrjt_pt_arg 
 int = 1java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

#((CONFIG_NVME_FC
 ret = nvme_fc_rcv_ls_req(uctx->fcport-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     &item->iocb, item->size);
#endif
 if (ret) {
  ql_dbg(ql_dbg_unsol
  memset((void vha= qla2xxx_get_vha_from_vp_idx(ha, p->);
  avp_idx= vha->vp_idx
 anport_handle uctx-;
 axchg_address>exchange_address
  qla_nvme_ls_reject_iocb(vha,avp_idx>vp_index
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   .    >s_idjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static
(struct *,  vp_index
{
e_vha*, *;
  long;

base_vha=pci_get_drvdata>pdev;

 if (!vp_index && !ha->num_vhosts)
  return base_vha;

 spin_lock_irqsave(&ha->vport_slock, flags);
 (vha vp&>, list
  ifxmt_reject ;
   (&ha->vport_slock );
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }
 }
 spin_unlock_irqrestore(&ha->vport_slock, flags);

 return  tem qla27xx_copy_multiple_pkt(, , , , false
}

void qla2xxx_process_purls_iocb(void **pkt, struct rsp_que **rsp)
{
 struct nvme_fc_remote_port *rport;
 struct qla_nvme_rport *qla_rport;
 struct qla_nvme_lsrjt_pt_arg a;
  =kzalloc(*), );
 struct  (uctx
 truct * = *sp
struct *ha
scsi_qla_host_tvha;
 fc_port_t *fcport = NULL;
 struct *;
 port_id_t d_id = kfree(itemjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 port_id_t id>  ;
u8opcode
 bool  >exchange_addressp-exchange_address;

 ha = rsp_q- uctx-> = p-;

 vha = qla2xxx_get_vha_from_vp_idx(ha, p->vp_indexINIT_LIST_HEADuctx-);
)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
         PURLS0]%  0% %6\"
 WARN_ON_ONCE)
  return
 }

 memset  * ----- ---------------  * 0000: 00 00 00 05 28 00 00 00 07 00  * 0010: ab ec 0  * 0020: 00 00 00 00 00 00 00 00 00 00 00   *
 opcode = (u8 *)&p->payload[0];
aopcode opcode[3]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
a = p-;
 a.nport_handle:
 a.ox_id (xmt_reject{
 a.xchg_address qla_nvme_ls_reject_iocb(, (rsp)>, &, false)

 id.java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 2
 id.b.area   = p->s_id.area;
 id.b.al_pa  = p->s_id.al_pa;
 d_id.b.domain = p->d_id[2];
 d_id.b.area   = p->d_id[1];
 d_id.b.al_pa  = p->d_id[0];

 fcport = qla2x00_find_fcport_by_nportid(vha, &id, 0);
 if (!fcport) {
  ql_dbg(ql_dbg_unsol, vha, 0x211e,
         "Failed to find sid=%06x did=%06x\n",
         id.b24, d_id.b24);
  a.reason = FCNVME_RJT_RC_INV_ASSOC;
  a.explanation = FCNVME_RJT_EXP_NONE;
  xmt_reject = true;
  goto out;
 }
 rport = fcport->nvme_remote_port;
 qla_rport = rport->private;

 item = qla27xx_copy_multiple_pkt(vha, pkt, rsp, true, false);
 if (!item) {
  a.reason = FCNVME_RJT_RC_LOGIC;
  a.explanation = FCNVME_RJT_EXP_NONE;
  xmt_reject = true;
  goto out;
 }

 uctx = kzalloc(sizeof(*uctx), GFP_ATOMIC);
 if (!uctx) {
  ql_log(ql_log_info, vha, 0x2126, "Failed allocate memory\n");
  a.reason = FCNVME_RJT_RC_LOGIC;
  a.explanation = FCNVME_RJT_EXP_NONE;
  xmt_reject = true;
  kfree(item);
  goto out;
 }

 uctx->vha = vha;
 uctx->fcport = fcport;
 uctx->exchange_address = p->exchange_address;
 uctx->nport_handle = p->nport_handle;
 uctx->ox_id = p->ox_id;
 qla_rport->uctx = uctx;
 INIT_LIST_HEAD(&uctx->elem);
 list_add_tail(&uctx->elem, &fcport->unsol_ctx_head);
 item->purls_context = (void *)uctx;

 ql_dbg(ql_dbg_unsol, vha, 0x2121,
        "PURLS OP[%01x] size %d xchg addr 0x%x portid %06x\n",
        item->iocb.iocb[3], item->size, uctx->exchange_address,
        fcport->d_id.b24);
 /* +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, item->size);

 qla24xx_queue_purex_item(vha, item, qla2xxx_process_purls_pkt);
out:
 if (xmt_reject) {
  qla_nvme_ls_reject_iocb(vha, (*rsp)->qpair, &a, false);
  __qla_consume_iocb(vha, pkt, rsp);
 }
}