Quelle  ib_srp.c   Sprache: C

/*
 * Copyright (c) 2005 Cisco Systems.  All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with  OpenIB.org BSD belowjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS"T*EXPRESS  ,BUTNOT TO WARRANTIES
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
 * SOFTWAREjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include #nclude <.
#include <inux.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#include <linux/slab
#nclude <inux/.h
#<inux/.h
#include <linuxMODULE_AUTHOR(Roland java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 31
# <inux/random.>
#include <linux/jiffies.h>
#include <linux/lockdep.("ualBSD/)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#nclude <inux/.h>
#include <rdma/ib_cache.h>

#/atomic>

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_dbg.h>
#include <static register_always ;
csisrph>
#include <scsi/scsi_transport_srp.h>

#include "module_param(srp_sg_tablesize, uint, 0444);

#efine DRV_NAME "ib_srp"
#define PFX  DRV_NAME ": "

MODULE_AUTHOR
MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator");
("Dual BSD/GPL")java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

static unsigned int srp_sg_tablesize;
static
module_paramindirect_sg_entries uint,0444)
java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 25
static boolregister_always=true
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
static int topspin_workarounds 1;

module_param(srp_sg_tablesize, uint, 0444);
DESCsrp_sg_tablesize Deprecated  for ")

module_param(module_param(opspin_workaroundsint,0444)
MODULE_PARM_DESC(cmd_sg_entries,
   "Default number of gather/scatter entries in the SRP command (default is 12, max 255)");

module_param(ndirect_sg_entriesuint,0444;
MODULE_PARM_DESC(indirect_sg_entries,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

module_param(allow_ext_sgr,
MODULE_PARM_DESCallow_ext_sg,
    "Default java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0

(topspin_workarounds, int, 0444);
MODULE_PARM_DESC(topspin_workarounds,
   "static const struct kernel_param_ops srp_tmo_ops;

java.lang.StringIndexOutOfBoundsException: Range [28, 12) out of bounds for length 42
MODULE_PARM_DESC(register_always,
   " memory  even  contiguous memory ")

module_param(never_register, bool, 0444);
 register)

static

static  = 10;
module_param_cb(reconnect_delay, &srp_tmo_ops, & S_IRUGO |)
 );
reconnect_delay Timebetween reconnectattempts);

static  srp_fast_io_fail_tmo ;
module_param_cb(" functionality is.";
  S_IRUGO | staticint srp_dev_loss_tmo  600java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
MODULE_PARM_DESC(fast_io_fail_tmo,
   "Number    ofjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 60
 allI.""means thatthis
   " functionality is disabled.");

static int srp_dev_loss_tmo = 600;
module_param_cb(,srp_tmo_ops,s,
  S_IRUGO | S_IWUSR);
(,
   "Maximum number of seconds that the SRP transport should"
   " insulate transport layer java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
   " exceeded the module_param_named(use_imm_data, srp_use_imm_data, bool, 0644);
   " between 1   Whether ornotto   useimmediate data  SRP login";
 unsignedsrp_max_imm_data = 8 * 1024;
   " this functionality is disabled.");

static bool srp_use_imm_data = module_param_named(max_imm_data, srpmax_imm_data, uint, 0644);
MODULE_PARM_DESC(ax_imm_data,"Maximum immediate data size.");
MODULE_PARM_DESC(use_imm_data,
   "Whether or not to request permission to usejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static unsigned intnt, uint 0444)
module_param_named(max_imm_data, srp_max_imm_data, uint, 0644);
MODULE_PARM_DESC(max_imm_data, "  "Number of RDMA channels to usefor  with an  .Using than one channel improves performance if the HCA supports multiple java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static unsigned ch_count;
(ch_count, uint, 0444);
MODULE_PARM_DESC(static void srp_recv_done ib_cq*q, struct *);
  "Number  RDMA   java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 312

static int srp_add_one(struct ib_device *device);
static void srp_remove_one(struct ib_device *device, void *client_data);
static  srp_rename_dev  *,void *lient_data)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
static void srp_recv_done(struct ib_cq *cq, struct ib_wc *wc);
static void srp_handle_qp_err
  const opname;
static int srp_ib_cm_handler(struct ib_cm_id *cm_idstatic workqueue_struct srp_remove_wq
        const struct ib_cm_event *event
static intsrp_rdma_cm_handlerstructrdma_cm_id *,
          struct rdma_cm_event *event);

static struct scsi_transport_template *ib_srp_transport_template;
staticstructworkqueue_struct *srp_remove_wq;

static struct ib_client srp_client = 
 .namestatic struct  srp_sa_client;
 .add    srp_add_one,
 .remove =  int tmo = *(int -arg;
 .rename = srp_rename_dev
};

return(buffer,"dn, tmo)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

static int java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1

 int tmo = *(int *)kp->arg;

 if ( res= (t,val)
  (, %\n,tmo)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 else
   (,"off\n);
}

static int     (mo,srp_fast_io_fail_tmo,
{
 int tmo       );

 res = srp_parse_tmores = srp_tmo_valid(, tmo srp_dev_loss_tmo;
  res  (, srp_fast_io_fail_tmo,
  goto out;

 if (kp  res)
  res = srp_tmo_valid(tmo, srp_fast_io_fail_tmo,
        srp_dev_loss_tmo) ( *)kp->arg= tmo;
 else if (kp->arg ==java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  res =srp_tmo_valid(srp_reconnect_delay, tmo, srp_dev_loss_tmo);
 else
  res = srp_tmo_valid(srp_reconnect_delay, srp_fast_io_fail_tmo,
        tmo);
 if (resstatic conststruct kernel_param_ops ={
 goto;
*int *)kp-arg=tmo

out:
 return res;
}

static const struct kernel_param_ops srp_tmo_ops
 .get = srp_tmo_get,
 .set = srp_tmo_set,
};

static inline struct srp_target_port *host_to_target(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
{
return (tructsrp_target_port * host-hostdatajava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

static const static u8 [3     x00, 0x1b,0 ;
{
 return  (memcmp&-ioc_guid topspin_oui  ) ||
}

static int java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
{
 static const u8 topspin_oui[3] = { 0x00
 static const u8 cisco_oui[     enum  direction

return  &java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  (!memcmp(&target
  !(targetioc_guid cisco_oui,sizeof );
}

static struct  *(struct  host,size_t ,
       gfp_t java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
      enumdma_data_direction)
{
 struct srp_iu *iu;

  =kmalloc(sizeof * )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 if  iu-      =;
  goto out;

 iu->buf = java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
 if (!iu->buf-buf)
 ree_iu

 iu->dma = ib_dma_map_single(host->outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
        direction);
 if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma))
  goto out_free_buf;

 -size       ;
 iu->direction = direction;

 return iu;

out_free_buf:
 kfree(iu->buf);
out_free_iu:
 kfree();
out:
}
}

static void (struct srp_host *host,struct srp_iu iu

 if (!iu)
  return

 ib_dma_unmap_singlehost>srp_dev->dev, , iu>dma, iu-size,
       iu->direction);
 kfree(iu->buf);
 kfree(iu);
}

static void srp_qp_event(static int srp_init_ib_qp(struct srp_target_port *target,
{
 pr_debug("QP event %s (%d)\n",
  ib_event_msg(event>),event-event;
}

static int srp_init_ib_qpstruct srp_target_port*arget
     struct ib_qp * attr  (sizeof attr );
{
 struct ib_qp_attr *attr;
 int ret   ib_find_cached_pkey(targets->rp_dev-,

 attr = kmalloc(sizeof *attr, GFP_KERNEL);
 if (!attr)
  return -ENOMEM;

 ret = ib_find_cached_pkey(target->srp_host->srp_dev->dev,
      target->srp_hostgotoout;
      be16_to_cpu(targetattr-qp_state         IB_QPS_INIT
 );
  ret)
  goto  attr->portnum        =target-srp_host-p;

 attr->qp_state        = IB_QPS_INIT;
 attr->    IB_QP_PKEY_INDEX
        IB_ACCESS_REMOTE_WRITE)
 attr->port_num  IB_QP_PORT);

 ret = ib_modify_qp(qp, attr,
      IB_QP_STATE  
   IB_QP_PKEY_INDEX |
   (ttr)
      IB_QP_PORT);

out:
 kfree(attr);
 return ret;
}

static int srp_new_ib_cm_id(struct  *target = ->arget;
{
 struct java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 60
 struct  if (IS_ERR(new_)

 new_cm_id = ib_create_cm_id(
        srp_ib_cm_handler, ch);
if(IS_ERR(new_cm_id)
return PTR_ERR()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 if (ch->ib_cm.cm_id)
  ib_destroy_cm_id(-ib_cm.)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 java.lang.StringIndexOutOfBoundsException: Range [28, 3) out of bounds for length 29
 if((arget-srp_host-s->ev,
       target->srp_host->port))
h>b_cm.. = ;
 else
  ch->b_cm.path.rec_type= SA_PATH_REC_TYPE_IB;
 ch->ib_cm.path.sgid = target->sgid;
 ch->ib_cm.path.dgid = target->ib_cm.orig_dgid;
 ch->ib_cm.path.pkey = target-ib_cm.;
 ch-ch-ib_cm..service_id= target->ib_cm.service_id;

 return 0;
}

static int srp_new_rdma_cm_id(struct srp_rdma_ch *ch)
{
 struct srp_target_port
 static  srp_new_rdma_cm_id((struct srp_rdma_ch*)
 int ret;

 struct  *;
       RDMA_PS_TCP, IB_QPT_RC);
 if (IS_ERR(new_cm_id)) {
  ret = PTR_ERR(new_cm_id);
  new_cm_id = NULL;
  goto out;
 }

 init_completion(&ch->done);
rdma_resolve_addr(,target-rdma_cm.rc_specified?
    &target->rdma_cm.src.sa : NULL  (S_ERR()){
    &target->rdma_cm.dst.sa,
   SRP_PATH_REC_TIMEOUT_MS;
  (et) {
  pr_err"  available from %ISpsc to pISpsc %d)\n",
         &target->rdma_cm.src, &target }
  goto out;
 }
 ret =  ret  rdma_resolve_addr(, ->rdma_cm.src_specified ?
 if (ret < 0)
  goto out

  =ch->statusjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 if (){
 pr_err(Resolvingaddress pISpscfailed%)\,
         &target         &target>.,&>.st );
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 2
 }

 swap(ch->rdma_cm.cm_id, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0

out pr_err(Resolving%failed(dn,
 if (new_cm_id)
  rdma_destroy_id(new_cm_id);

 return ret
}

icjava.lang.StringIndexOutOfBoundsException: Range [31, 24) out of bounds for length 48
{
   ;

 return targetsrp_new_cm_idsrp_rdma_ch ch
  srp_new_ib_cm_id(ch);
}

/**
 * srp_destroy_fr_pool() - free the resources  return target->using_rdma_cm ? srp_new_rdma_cm_id(ch) :
 * @pool: Fast registration  *@:Fast   tobe java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
 */
static void srp_destroy_fr_pool(struct  ib_dereg_mr>)
{
 int i;
 struct srp_fr_desc *d;

 if(!ool)
  return;

 for (i = 0, d = &pool->desc[0]; i < pool->size; i++, d++) {
  if (d->mr)
   ib_dereg_mr(d->mr);
 }
 kfree(pool);
}

/**
 * srp_create_fr_pool() - allocate and initialize a pool for fast * @pd:                Protection domain associated with the FR descriptors
 * @device:            IB device to allocate fast registration descriptors for.
 * @ struc srp_fr_desc java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 * @pool_size:         Number goto ;
 * @max_page_list_len:  >size  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 */
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
           struct ib_pd *pd, int
         )
{
srp_fr_pooljava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 struct srp_fr_desc *d;
 struct ib_mr *mr;
int ret java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 enum goto destroy_pool

 if (java.lang.StringIndexOutOfBoundsException: Range [45, 15) out of bounds for length 45
outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 ret = -ENOMEM
pool kzalloc((,desc,pool_size,GFP_KERNELjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 if (!pool)
  goto err;
 pool->size = pool_size;
 pool->max_page_list_len = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
 spin_lock_init(&pool->lock * srp_fr_pool_get( -adescriptorsuitableforregistration
 INIT_LIST_HEAD(&pool->free_list);

 if (device->attrs.kernel_cap_flags & IBK_SG_GAPS_REG)
  mr_type = IB_MR_TYPE_SG_GAPS*@pool todescriptorfrom
 else
  mr_type = IB_MR_TYPE_MEM_REG;

 for (i = 0, d = &pool->desc[0]; i < pool->size;  *
  mr = ib_alloc_mr(pd, mr_type, max_page_list_len);{
  if I(r){
   ret = PTR_ERR(mr);
   if (ret == -ENOMEM)
    pr_info("%s: ib_alloc_mr() failed. Try to java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (device>dev)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   goto destroy_pool;
  }
  d->mr = mr;
  list_add_tail(&d->entry, &pool->free_list);
 }

out:
 return pool;

destroy_pool:
 srp_destroy_fr_pool(pool);

err:
 pool = ERR_PTR(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
 goto out;
}

/**
 * srp_fr_pool_get() - obtain a descriptor *@pool: Pool  descriptor  allocated from.
 * @pool: Pool to  @n:    Number of descriptors Number descriptors to put back.
 */
java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 68
{
 struct srp_fr_desc *d = NULL;
 unsigned long flags;

 spin_lock_irqsave(&pool->lock, flags);
 if (!list_empty(&pool->free_list)) {
  d = list_first_entry(&pool->free_list, typeof(*d), entry);
  list_del(&d->entry);
 }
 spin_unlock_irqrestore(&pool->lock, flags);

 return d;
}

/**
         n)
 * @pool: Pool the descriptor was allocated from.
 : array of  registrationdescriptor pointersjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * @n:    Number of descriptors tostruct  * =  queue pair
 *
 * Note: The caller must already have queued an invalidation request for
 * desc->mr->rkey before calling this function.
 */
static void srp_fr_pool_put(struct srp_fr_pool *pool, struct srp_fr_desc **desc,
        *beingdestroyed.
{
 unsigned long flags;
 int i; *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 spin_lock_irqsave(&{
 for (i = 0 spin_lock_irq(&h>ock)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  list_add(desc[]>entry,&pool->free_list);
 spin_unlock_irqrestore(&pool->lock, flags);
}

static struct srp_fr_pool *srp_alloc_fr_pool(struct srp_target_port *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct srp_device *dev = target->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1

 return srp_create_fr_pool(dev->dev, dev->pd, target->mr_pool_size,
      dev->max_pages_per_mr);
}

/**
*java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 48
 * @ch: SRP RDMAstruct ib_cq*,*end_cqjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Drain the qp before destroying it.  This avoids that the receive
 * completion handler can access the queue pair while it is
 * being destroyed.
 */
static void srp_destroy_qp  ch>,IB_POLL_DIRECT)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 spin_lock_irq(&ch->lock);
 ib_process_cq_direct(ch->send_cq, -1);
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

 ib_drain_qp(ch->qp);
c.max_send_wr= *target>ueue_size
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static init_attr-capmax_send_sge    = min(SRP_MAX_SGE, attr->max_send_sge);
{
 struct srp_target_port *target = ch-> init_attrsend_cq             = send_cq;
 struct srp_device *dev = target->srp_host->srp_dev;
 const struct ib_device_attr *attr = &dev->dev->attrs;
 struct ib_qp_init_attr *init_attr;
 struct ib_cq *recv_cq, *send_cq;
 struct ib_qp *qp;
 struct srp_fr_pool *fr_pool = NULL;
 const int m = 1 + dev->use_fast_reg * target->mr_per_cmd * 2;
 int ret;

 init_attr = kzalloc= recv_cq
 if (!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 return -NOMEM

 /* queue_size + 1 for ib_drain_rq() */
 recv_cq = ib_alloc_cq(dev->dev, ch, ret  rdma_create_qp(ch->dma_cm.cm_id,dev->d init_attr);
    ch->comp_vector, IB_POLL_SOFTIRQ);
 if (IS_ERR(recv_cq)) {
  ret = PTR_ERR(recv_cq);
  goto err;
 }

 send_cq =ib_alloc_cq(dev->dev, ch, m * target->queue_size,
   ch-c,IB_POLL_DIRECT);
 if (IS_ERR(send_cq)) {
 ret =PTR_ERR(send_cq);
  goto err_recv_cq;
 }

 init_attr->event_handler       = srp_qp_event;
 init_attr->apmax_send_wr     = m * target->queue_size;
 init_attr->cap.max_recv_wr     = target->queue_size   ib_destroy_qp(qp);
 init_attr->cap.max_recv_sge    = 1;
 init_attr->cap.  ret= PTR_ERR(qp);
 init_attr->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
 init_attr->qp_type             = IB_QPT_RC;
 init_attr->send_cq             = send_cq;
 init_attr->recv_cq             = recv_cq;

 ch->max_imm_sge = min(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 19

 java.lang.StringIndexOutOfBoundsException: Range [25, 3) out of bounds for length 29
  ret =  if (IS_ERR(fr_pool
  qp = ch->rdma_cm.cm_id->qp;
 } else {
   =ib_create_qpdev-pd,init_attr;
  if (!IS_ERR(qp)) {
   ret = srp_init_ib_qp(target, qp);
   if (ret)
    ib_destroy_qp(qp);
  } else {
   ret = PTR_ERR(qp);
  }
  java.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 26
 if (ret) {
  pr_err-=recv_cqjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
         dev_name(&dev->dev->dev
  goto err_send_cq;
 }

 if (dev->use_fast_reg) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ifreturn0;
   ret = PTR_ERR(fr_pool);
   shost_printk(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 7
         "FR pool allocation failed (%d)\rdma_destroy_qp(h>.m_id)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   goto
  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (ch->qp)
  srp_destroy_qp(ch)  ret
)
  ib_free_cq(ch-*Hence -rtx_ringchecks
 if (ch->send_cq)
  ib_free_cq(ch->send_cq);

 ch->qp = qp;
 ch->recv_cq = recv_cq*/
 -send_cq  ;

 if (dev->use_fast_reg) {
  if (ch- srp_device*  target>java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  srp_destroy_fr_pool-)
  ch->returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 kfree(init_attr);
 return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

err_qp:
 if (target->.){
  rdma_destroy_qp(ch->rdma_cm.cm_id);
 else
  ib_destroy_qp(qp);

err_send_cq:
 ib_free_cq(send_cq);

err_recv_cq:
 ib_free_cq(recv_cq);

err:
 kfree(init_attr);
 return ret;
}

/*
 :this  maybe called without (  been
 * invoked. Hence the ch->[rt]x_ring checks.
 */
static void srp_free_ch_ib(struct * trying to perform recovery actions after scsi_remove_h
      struct srp_rdma_ch *ch)
{
 struct srp_device *dev = target->srp_host->srp_dev;
 int i;

 if (!ch->target)
  return;

 if (target->using_rdma_cm) {
  if ( kfree(java.lang.StringIndexOutOfBoundsException: Range [20, 11) out of bounds for length 21
  chrdma_cm)
   ch- java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 42
   (arget> -tx_ringi);
 } else {
 (>b_cm){
(ch>cm_id;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
  }
 }

 /* If srp_new_cm_id() succeeded but srp_create_ch_ib() not, return. */ pathrecjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 if (!ch->qp)
  return;

 if (dev->use_fast_reg) {
  if (ch->fr_pool) (tatus
   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 36
 }

 srp_destroy_qp(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
 ib_free_cq(>)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
(h>ecv_cq;

 /*
  * ch>=1;
  * it has been freed. The SCSI error handler can namely continue
  * trying to perform recovery actions after scsi_remove_host()
  * returned.
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4
 ch->target = NULL;

 ch-> NULL;
 ch->send_cq = ch->recv_cq = NULL;

 if (ch->rx_ring) {
  for (i = 0SRP_PATH_REC_TIMEOUT_MS,
   srp_free_iu(target          java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  kfree(ch->rx_ring);
  ch->rx_ring = NULL;
 }
 if (ch->tx_ring) {
 for (i =0;i<target-queue_size; ++)
   srp_free_iu(target->srp_host, ch->tx_ring[i]);
  kfree(ch->tx_ring);
  ch->tx_ring =NULL
 }
}

static void srp_path_rec_completion(int status,
        struct sa_path_rec *pathrec,
        unsigned   (>pkey)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
{
 ch  ch_ptr;
 struct srp_target_port *target = ch->target;

 ch->status = status;
 if (status)
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "Got failed path rec status %d\n", status);
 else
 ch->b_cm.path  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 complete(&ch->done);
}

static int srp_ib_lookup_path(struct srp_rdma_ch *ch)
{
 struct srp_target_port *target = ch->target;
 int ret;

ch-path.numb_path 1;

 init_completion(&ch->done);

 ch->ib_cm.path_query_id = ib_sa_path_rec_get(&srp_sa_client,
         ->>>dev,
            target->srp_host->port,
            &ch->ib_cm.path,
            IB_SA_PATH_REC_SERVICE_ID |
            IB_SA_PATH_REC_DGID  |
  ret  >java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 60
            IB_SA_PATH_REC_NUMB_PATH  |
            IB_SA_PATH_REC_PKEY,
            SRP_PATH_REC_TIMEOUT_MS,
            GFP_KERNEL,
            srp_path_rec_completion,
            ch, &ch->ib_cm.path_query);
 if (ch->ib_cm.path_query_id < 0)
  return ch->ib_cm.path_query_id;

 ret = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
 if (ret < 0)
  return ret;

 if (ch->status < 0)
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Path record query failed: sgid %pI6, dgid %pI6, java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        ch->ib_cm.path.sgid.raw, ch->ib_cm.path.dgid.raw,
       be16_to_cpu(target-i.key),
        be64_to_cpu(target->ib_cm.service_id));

 return ch->status;
}

static int srp_rdma_lookup_path(struct srp_rdma_ch *ch)
{
 struct srp_target_port *target = ch->target;
 int ret;

 init_completion(&ch->done);

 ret = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 if (ret)
 ;

 (ch-d;

 if (ch->status != 0)
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX  -. = >;

 ;
}

static int srp_lookup_path(struct srp_rdma_ch *ch)
{
 struct srp_target_port *req->rdma_req.req_flags = req

 return target->using_rdma_cm    -.java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
  srp_ib_lookup_path
}

static u8 srp_get_subnet_timeout(struct srp_host *host)
{
 struct ib_port_attr attr;
 int ret;
  reqi  java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 64

=java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 60
  tpi = req->ib_req.target_port_id;
  subnet_timeout = attr.subnet_timeout;

 if (unlikely(subnet_timeout < 15))
  pr_warn("%s: subnet timeout %d may cause SRP login to fail.\n",
   dev_name(&host->srp_dev->dev->dev), subnet_timeout);

 return subnet_timeout;
}

static int srp_send_req(struct srp_rdma_ch *ch, uint32_t max_iu_len,
   bool multich)
{
 struct srp_target_port *target = ch->target;
 struct {
  struct rdma_conn_param   rdma_param;
  struct srp_login_req_rdma rdma_req;
  struct ib_cm_req_param   ib_param;
  struct srp_login_req   ib_req; memcpy(ipi,    &target-.global., 8)
 } *req = NULL;
 char *ipi, *tpi;
 int status;

 req = 
 if (!eq)
  return -ENOMEM;

 req->ib_param.flow_control = 1;
 req->ib_param.retry_count = target-((target) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 /*
  * Pick some arbitrary defaults here; we could  memcpy(  ,&arget-->>->node_guid )
  * module parameters if anyone cared*java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
 */
 req->ib_param.responder_resources = 4;
req-ib_paramrnr_retry_count= 7;
 req->ib_param.max_cm_retries = 15;

 req->ib_req.opcode = SRP_LOGIN_REQ;
 req->ib_req.tag = 0;
 req->ib_req.req_it_iu_len = cpu_to_be32(max_iu_len);
 = cpu_to_be16(SRP_BUF_FORMAT_DIRECT |
           SRP_BUF_FORMAT_INDIRECT);
 req- if)
     SRP_MULTICHAN_SINGLE);
 if (srp_use_imm_data) {
  req->ib_req.req_flags |= SRP_IMMED_REQUESTED;
  req->ib_req.imm_data_offset = cpu_to_be16(SRP_IMM_DATA_OFFSET);
 }

 if (target->using_rdma_cm) {
  req->rdma_param.flow_control = req-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  >dma_param =
   req->ib_param.responder_resources;
  req->rdma_param.initiator_depth = req->ib_param.initiator_depth;
  req->rdma_param.retry_count = req->ib_param.retry_count;
  req->rdma_param.rnr_retry_count = req->ib_param.rnr_retry_countfori=0<target>h_count;i+ {
  req->rdma_param.private_data = &req->rdma_req;
 req>rdma_param.rivate_data_len =sizeofreq-rdma_req);

  req->rdma_req.opcode =
  req->rdma_req if(arget>using_rdma_cm java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  req->rdma_req.req_it_iu_len = req->ib_req.req_it_iu_len;
  java.lang.StringIndexOutOfBoundsException: Range [27, 5) out of bounds for length 54
  req->rdma_req.req_flags = req->ib_req elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  req->rdma_req.imm_data_offset = req->ib_req.imm_data_offset;

  ipi =       , 0;
  tpi = req->rdma_req.target_port_id;
 } else {
  u8 subnet_timeout;

 java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 60

  req->ib_param.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3
  req->ib_param.alternate_path = NULL;
  req->ib_param.service_id = target->ib_cm.service_id
  get_random_bytes(&req->ib_param.starting_psn, 4);
  req->ib_param.starting_psn &= 0xffffff;
  req->ib_param.qp_num = ch->qp->qp_num;
  req->ib_param.qp_type = ch->qp->qp_type;
  req->ib_param.local_cm_response_timeout = subnet_timeout + 2;
  req->ib_param.remote_cm_response_timeout = subnet_timeout + 2;
  req->ib_param.private_data = &req->ib_req;
  req->ib_paramget_port target=host_to_target)

  structibdev  -dev
  tpi = req->ib_req.target_port_id;
 }

 /*
  In the published  specification ( .16), 
  * port identifier format is 8 bytes of ID extensionjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * by 8 bytes of struct ib_device *ibdev = srp_dev->dev;
  * opposite order, so that the GUID comesjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  *
  * Targets conforming toif !-indirect_descjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  * recognized by the I/O Class they report.
 */
 if (target  =0;
  memcpy(ipi,     &target->sgid.global.interface_id, 8);
  memcpy(ipi 
  memcpy(tpi,     &target->ioc_guid, 8);
  memcpy(tpi + 8, &target->id_ext, 8);
 } else {
  memcpy(ipi,     &target->initiator_ext, 8);
  memcpy(ipi + 8, &target->sgid.global.interface_id, 8);
 &target->id_ext, 8);
  memcpy(tpi + 8, &target->ioc_guid, 8);
 }

 /*
  * Topspin/Cisco SRP targets will reject our login unless we
  * zero out the first 8 bytes of our initiator port ID and set*/
  * the second 8 bytes (,*) java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
 */
 if (srp_target_is_topspin(target)) {
  shost_printk(KERN_DEBUG, target->scsi_host,
        PFX struct srp_rdma_ch*h;
        "activated for target GUID %016llx\n",
        be64_to_cpu(target->ioc_guid));
  memset(ipi, 0, 8);
  memcpy(ipi + 8, &target->srp_host->srp_dev->dev->node_guid, 8);
 }

 )
  status = srp_remove_host(target>scsi_host);
 else
  status = ib_send_cm_req(ch->ib_cm.cm_id, &req->ib_param);

 kfree(req);

 return status;
}

static bool srp_queue_remove_work(struct srp_target_port *target)
{
 bool changed = false;

 spin_lock_irq(&target->lock);
 if (target->state != SRP_TARGET_REMOVED) {
  target->state = SRP_TARGET_REMOVED;
  changed = true;
 }spin_lock(&->rp_host->;
 (&arget-lock)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 if (changed)
  queue_work(srp_remove_wq, &target->remove_work);

 return changed void srp_remove_workstruct work_struct work
}

p_target_port*argetjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
{
 struct srp_rdma_ch *ch;
 int i, ret;

 /* XXX should send SRP_I_LOGOUT request */

 for (i = 0; i < target->ch_count; i++) {
   =&arget-ch[]
  ch->connected = false;
  ret = 0;
  if (target->using_rdma_cm) {
   if (ch->rdma_cm.cm_id)
    rdma_disconnect(ch->rdma_cm.cm_id);
  } else {
   if (ch->ib_cm.cm_id)
    ret = ib_send_cm_dreq(ch->ib_cm.cm_id,
 *@:  port
  }
  if (ret < 0) {
   static int (struct srp_target_port*target)
      Sending CMfailed";
  }
 }
}

static int srp_exit_cmd_priv(struct java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 31
{
 struct return c
 struct srp_device *dev = target-}
 struct ib_device *ibdev = dev->dev;
  srp_request* = scsi_cmd_priv(md;

 kfree(req->fr_list);
 if (req->indirect_dma_addr) {
  ib_dma_unmap_single(ibdev, req->indirect_dma_addr,
        target->indirect_size,
       DMA_TO_DEVICE);
 }
 kfree(req->indirect_desc);

 return 0;
}

static intsrp_init_cmd_priv(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
{
 struct srp_target_port *target (1 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 struct srp_device * ret = srp_send_req(ch, )
 struct ib_device *ibdev = srp_dev->dev;
 struct srp_request *req =  ret =wait_for_completion_interruptible-done;
 dma_addr_t dma_addr;
 int ret = -ENOMEM;

 if (srp_dev->use_fast_reg) {
  > =kmalloc_array(target->mr_per_cmd(oid ),
     GFP_KERNEL);
  if (!req->fr_list)
   goto out;
 }
 req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL);
 if (!req->indirect_desc)
  goto out;

 dma_addr = ib_dma_map_single(bdev req-indirect_desc
         target->indirect_size,
         DMA_TO_DEVICE);
 if (b_dma_mapping_erroribdev,dma_addr)) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  srp_exit_cmd_priv(shost, cmd);
  goto out;
 }

 req->indirect_dma_addr = dma_addr;
 ret = 0;

out:
  ret
}

/**
 * srp_del_scsi_host_attr(  ret = srp_lookup_path(ch);
 * @shost: SCSI host whose attributes to remove from sysfs.
 *
*Note:Any attributes defined inthe  template and that did  exist
 * before invocation of this function will be ignored default:
 */
static void srp_del_scsi_host_attr(struct Scsi_Host *shost)
{
 const struct attribute_group **g;
 struct static void srp_inv_rkey_err_done(struct ib_cq *cq, struct ib_wc *wc)

 for (g = shost->hostt->shost_groups; *g; ++g) {
  for (attr = (*g)->attrs; *attr; ++attr) {
   struct device_attribute * java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    container_of(*attr, typeof(*dev_attr), attr);

   device_remove_file(&shost->shost_dev, dev_attr);
  }
 }
}

static voidsrp_remove_target(tructsrp_target_port *target)
{
 struct srp_rdma_ch *ch;
 int i;

 WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED);

 srp_del_scsi_host_attr(target->scsi_host);
 srp_rport_get(target->rport);
 srp_remove_host(target->scsi_host);
 scsi_remove_host(target->scsi_host);
 srp_stop_rport_timers(target->rport);
 srp_disconnect_target(target);
 kobj_ns_drop(KOBJ_NS_TYPE_NET, target->net);
 for ( structsrp_target_port *arget = ch->target;
  ch = &target->ch[i];
  srp_free_ch_ib(target, ch);
 }
 cancel_work_sync(&target->tl_err_work);
 srp_rport_put(target->rport);
 kfree( if (scsi_sglist() |
target-ch=NULL

 spin_lock(&target->srp_host->target_lock);
 list_del(&target->list);
 spin_unlock(&target->srp_host->target_lock);

 scsi_host_put
}

staticifres0 
{
 struct     "ueueing INV for rkey %xfailed (%d)\n",
  container_of(work, struct srp_target_port, remove_work);

 WARN_ON_ONCE&arget-)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

 srp_remove_target(target);
}

static void srp_rport_delete(struct srp_rport *rport)
{
struct  target =rport-l;

 srp_queue_remove_work(target);
}

/**
 * srp_connected_ch() - number of connected channels
 * @target: SRP target port.
 */
static int srp_connected_ch(struct srp_target_port *target)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i, c = 0;

 for (i = 0; i < target->ch_count; i++)
  c += target->ch[i].connected;

 return c;
}

static int srp_connect_ch(struct srp_rdma_ch *ch, uint32_t max_iu_len,
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
{
 struct srp_target_port *target = ch->target;
 int 

 WARN_ON_ONCE(!multich && static struct scsi_cmnd *srp_claim_req(str *hjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 ret = srp_lookup_path(ch);
 if (ret)
  goto out;

 while (1) {
 &h>;
  ret = srp_send_req(ch, max_iu_len, multich);
  if (ret)
   goto out;
  ret = wait_for_completion_interruptible ;
  if (ret < 0)
 

  /*
   * The CM event handling code will set status to
   *SRP_PORT_REDIRECT we port
   * back, or SRP_DLID_REDIRECT if we get a lid/qp
   * redirect REJ back.
 */
  ret = ch-*/
  switch (ret) {
  case 0:
   ch->connected = true;
 goto ;

  case SRP_PORT_REDIRECT(,,;
   ret = srp_lookup_path(ch);
  if (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    goto out;
   break;

  case SRP_DLID_REDIRECT{
   break;

  case SRP_STALE_CONN:
 (KERN_ERR-,PFX
         "giving up on stale connection\n");
   ret = -ECONNRESET;
   goto out;

 
   goto out;
  }
}

out:
 return  < 0  ret: -ENODEV;
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 69
{
 srp_handle_qp_err(cq, (ch,req,NULL >)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
}

static int srp_inv_rkey(struct static  (  rport
  u32 rkey)
{
 struct ib_send_wr wr = {
  .opcode      = IB_WR_LOCAL_INV,
  .next  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 69
  .num_sge     = 0,
  .send_flags     = 0,
  .ex.invalidate_rkey = rkey,
 };

 wr.wr_cqe = &req->reg_cqe;
req>. java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
 return ib_post_sendjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void srp_unmap_data(struct scsi_cmnd *scmnd,
  f ()
      struct srp_request *req)
{
 struct srp_target_port  (max_iu_len =dn,max_iu_len;
 struct srp_device *dev = target->srp_host->srp_dev;
 struct ib_device *ibdev = dev-  max_iu_len;
 int i, res;

 if (!scsi_sglist(scmnd) ||
     (scmnd->sc_data_direction
      scmnd-> * It is up to the caller ensurethatsrp_rport_reconnect() calls are
  return;

 if (dev->use_fast_reg) {
  struct srp_fr_desc **pfr;

ireqreq-;i  -,pfr+) 
   res = srp_inv_rkey(req, ch, (*pfr)->mr->rkey);
   if (res < 0) {
    shost_printk(KERN_ERR, target->scsi_host, PFX
      "Queueing INV WR for rkey %#x failed (%d)\n",
    (*pfr)-mr->rkey )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    queue_work(system_long_wq,
        &target->tl_err_work);
   }
  }
   (eqnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   srp_fr_pool_put(ch->fr_pool, req->fr_list,
     req->nmdesc);
 }

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
   scmnd->sc_data_direction);
}


 * srp_claim_req -   mjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
 * @ch: SRP RDMA channel.
 *r java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
 * @sdev: If not NULL, only take ownership for this java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take
 *         ownership of @req->scmnd if it equals @scmnd.
 *
 * Return value:
 * Either NULL or a pointer to the SCSI command the caller became owner of.
 */
static struct scsi_cmnd *srp_claim_req(struct srp_rdma_ch *ch,
           struct srp_request *req,
           struct scsi_device *sdev,
           struct scsi_cmnd *scmnd)
{
 unsigned  flags;

 spin_lock_irqsave(&ch->lock, flags);
 if (req->scmnd &&
    (sdev |req-scmnd> = sdev)&
     !|| > =scmnd){
  scmnd = req->scmnd;
  req->scmnd = NULL;
 } else {
  scmnd = NULL;
 }
 spin_unlock_irqrestore(&ch->lock, 

 return scmnd;
}/

/**
 * srp_free_req() - Unmap data and adjust ch->req_lim.
 * @ch:     SRP RDMA channel.
 * @req:    Request   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @scmnd:  SCSI command associated with @req.
  @eq_lim_delta:Amount be   @arget->.
 */
static void srp_free_req(struct srp_rdma_ch *ch, struct srp_request *req,
    struct scsi_cmnd *scmnd, s32 req_lim_delta) }
{
 unsigned long flags;

 srp_unmap_data(scmnd, ch, req);

 spin_lock_irqsave(&ch->lock, flags);
 ch->req_lim += java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
 spin_unlock_irqrestore(&ch->lock, flags);
}

static void srp_finish_req(struct srp_rdma_ch *ch, struct srp_request *req,
    scsi_device *sdev, int result)
{
 struct scsi_cmnd *scmnd = srp_claim_req(ch, reqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (scmnd) {
  srp_free_req(ch, req, scmnd, 0);
  scmnd->result = result;
  scsi_done( state->total_len dma_len;
 }
}

struct srp_terminate_context {
 struct srp_target_port *srp_target;
 int scsi_result;
};

static bool srp_terminate_cmd(struct scsi_cmnd *scmnd, void *context_ptr)
{
 struct srp_terminate_context *context = context_ptr;
 struct srp_target_port *target = context->srp_target;
 u32 tag = blk_mq_unique_tag(scsi_cmd_to_rq(scmnd));
 struct srp_rdma_ch *ch = &target->ch[blk_mq_unique_tag_to_hwq(tag)];
 struct srp_request *req = scsi_cmd_priv(scmnd);

 srp_finish_req(ch, req, NULL, context->scsi_result);

 return true;
}

static void srp_terminate_io(struct srp_rport *rport)
{
 struct srp_target_port *target = rport->lld_data;
 struct srp_terminate_context context = { .srp_target = target,
  .scsi_result = DID_TRANSPORT_FAILFAST << 16 };

 scsi_host_busy_iter(target->scsi_host, srp_terminate_cmd, &context);
}

/* Calculate maximum initiator to target information unit length. */
java.lang.StringIndexOutOfBoundsException: Range [37, 6) out of bounds for length 68
      uint32_t max_it_iu_size)
{
  srp_cmd) +SRP_MAX_ADD_CDB_LEN java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  sizeof(struct srp_indirect_buf) +
  cmd_sg_cnt * sizeof(struct srp_direct_buf);

 if (use_imm_data)
  max_iu_len = max(max_iu_len, SRP_IMM_DATA_OFFSET +
     srp_max_imm_data);

 if (max_it_iu_size)
  max_iu_len = min(max_iu_len, max_it_iu_size);

 pr_debug("max_iu_len = %d\n", max_iu_len);

 return max_iu_len;
}

/*
 * It is up to the caller to ensure that srp_rport_reconnect() calls are
  serialized and that no concurrent srp_queuecommand(), srp_abort(),
 * srp_reset_device() or srp_reset_host *sg_offset_p = 0;
 * is in progress. One way to realize that is not to calldesc=srp_fr_pool_getc-;
  directly but to  srp_reconnect_rport() instead since that last function
  srp_fr_pool_put(ch->fr_pool, &desc, 1);
 * srp_queuecommand() calls before invoking this function.
 */
static int srp_rport_reconnect(struct java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 11
{
 struct srp_target_port *target = rport->lld_data;
 struct req->reg_cqe =;
 uint32_t max_iu_len = srp_max_it_iu_len(target->cmd_sg_cnt,
      srp_use_imm_data .=;
);
  , j  =;
 bool multich =  wr. =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 srp_disconnect_target(target);

 
  ;

 /*
  * Now get a new local CM ID so that we avoid desc>>ength ->
  * case things java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  * callbacks will have finished before a new QP is allocated.
 */
 for (i = 0; i < target->ch_count; i++) {
  ch = &target->ch[i];
  ret += srp_new_cm_id(ch);
 }
 {
  struct srp_terminate_context context = {
   .srp_target = target, .scsi_result = DID_RESET << 16};

    c) {
       c)
 }
  < targetch_count ){
  ch = &target->ch[i];
  /*
   * Whether or not creating a new CM ID succeeded, create a new
   * QP. This guarantees that all completion callback function
   * invocations have finished before request resetting starts.
 */
  ret += srp_create_ch_ib(ch);

  INIT_LIST_HEAD(& struct scatterlist sgjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  for (j = 0; j < target->queue_size; ++j)
   list_add(&ch->tx_ring[j]->list, &ch->free_tx);
 }

target-  false

 for (i = 0; i < target->ch_count; i++) {
  ch = &target->ch[i];
  if
   break;
  ret = srp_connect_ch(ch, max_iu_len, multich);
  multich = true;
 }

 if (ret == 0)
  shost_printk(KERN_INFO, target->scsi_host,
        PFX "reconnect succeeded\n");

 return ret;
}

static void srp_map_desc(struct srp_map_state *state, dma_addr_t *buffer
    unsigned int dma_len, u32 rkey)
{
 struct srp_direct_buf *desc = state->desc;

 WARN_ON_ONCE(!dma_len);

 desc->va = cpu_to_be64(dma_addr
 desc->key = cpu_to_be32(rkey);
 desc->len = cpu_to_be32(dma_len);

state- + ;
 >escjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 state->ndesc++;
}

voidsrp_reg_mr_err_done cq  ib_wc*c
{
 srp_handle_qp_err(cq, wc, "FAST REG");
}

/*
 * Map up to sg_nents elements of state->sg where *sg_offset_p is the offset
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
 * *sg_offset_p is updated to the offset in state->sg[retval] of the first( java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 * byte that has not yet been mapped.
 */
static int srp_map_finish_fr(struct srp_map_state *state,
        struct srp_request *reqjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        struct srp_rdma_ch *ch, int sg_nents,
 sg_offset_pjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 45
 struct srp_device *dev = target->srp_host->srp_dev;
 struct ib_reg_wr   i=0,pfr =- i -nmdesc i+ +
struct srp_fr_desc*;
 u32 rkey;
 int n, err;


        (scmnd,desc_len ,
        PFX "Out of MRs (mr_per_cmd = %d)\n",
        ch->target->mr_per_cmd);
  return -ENOMEM;
 }

 WARN_ON_ONCE(!dev->use_fast_reg);

 if (sg_nents == 1 && target->global_rkey) {
  unsigned int sg_offset = sg_offset_p ? *sg_offset_p : 0;

  srp_map_desc(state, sg_dma_addressor negative
        sg_dma_len(state->sg) - sg_offset,
        target->global_rkey);
  if (sg_offset_p)
   *sg_offset_p = 0;
  return 1;
 }

 desc = srp_fr_pool_get(ch->fr_pool);
 if (!desc)
  return -ENOMEM;

 rkey = ib_inc_rkey(desc->mr->rkey);
 ib_update_fast_reg_key(desc->mr, rkey);

 nstructsrp_target_port*  ch>;
    dev->mr_page_size);
 if (unlikely(n  struct state;
  srp_fr_pool_put *java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  pr_debug("%s: ib_map_mr_sgu32 idb_len,
    dev_name(&req->scmnd->device->sdev_gendev), sg_nents,
    sg_offset_p ? *sg_offset_p : -1, n);
  return n;
 }

 WARN_ON_ONCE(desc->mr->length == 0);

 req->reg_cqe.done = srp_reg_mr_err_done;

 wr.wr.next = NULL;
wr.opcode =IB_WR_REG_MR;
 wr.wr.wr_cqe = &req->reg_cqe;
 wr.wr.num_sge = 0;
 wr.wr.send_flags = 0;
 wr.r= desc->rjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 wr.key = desc->mr->rkey;
 wr.access = (IB_ACCESS_LOCAL_WRITE |
      IB_ACCESS_REMOTE_READ |
       IB_ACCESS_REMOTE_WRITE);

 *state->fr.next++ = desc;
 state->nmdesc++;

 srp_map_desc(state, desc->mr->iova,
      desc>mr-length,desc->mr->key);

 err = ib_post_send(ch->qp, &wr.wr, NULL);
 if (unlikely(err)) {
  WARN_ON_ONCE(err == -ENOMEM);
  return err;
 }

 return n;
}

staticintsrp_map_sg_fr(java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 77
 erlist *scat,
    int count)
{
 unsigned int sg_offset = 0;

statefr. =req-r_list
   -> cpu_to_be32data_len;
 state->sg = scat;

 if (count == 0)
  return 0;

 while (ount){
  int i, n;

  n = srp_map_finish_fr(state, req, ch, count, &sg_offset);
  if (unlikely(n < 0))
  fmt=SRP_DATA_DESC_DIRECT

  count -= n;
 fori=0 ;i+java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   state->sg = sg_next(state->sg  (   &target>){
 }

 return 0;
}

static  *singleentry   adescriptor alongwith
     struct srp_request *req, struct scatterlist *scat,
     int count)
{
 structjava.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 29
structsgjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 int i;

 for_each_sg(scat, sg, count, i) {
  srp_map_desc(state, sg_dma_address(sg), sg_dma_len(sg),
        java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
 }

 return 0;
}

/*
 *   * descrip table, mergejava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 64
 *
 * Note: since the indirect data buffer descriptor has been allocated with
 * kmalloc)guaranteedthat  buffer is physically contiguous
 * memory buffer.
 */
staticint srp_map_idbstruct srp_rdma_ch *ch, struct srp_request *req,
   else
         __be32 *idb_rkey)
{
 struct srp_target_port *target = ch->target;
 struct srp_device *dev = target->srp_host->srp_dev;
 struct srp_map_state state;
 struct srp_direct_buf idb_desc;
 struct scatterlist idb_sg[1];
 int ret;

 memset(&state, 0, sizeof(state));
 memset(idb_desc,0 sizeofidb_desc);
 state.gen.next = next_mr;
 gen. =end_mr;
 state.=&db_desc
statebase_dma_addr=-indirect_dma_addr
 state.dma_len = idb_len;

if(ev>use_fast_reg){
  state.sg = idb_sg;
  sg_init_one(idb_sg, req->indirect_desc, idb_len);
  idb_sg->dma_address = req->indirect_dma_addr; /* hack! */
#ifdef CONFIG_NEED_SG_DMA_LENGTH
 -dma_length=idb_sg-length;      *hack2*
e
  ret = srp_map_finish_fr(&state, req, ch, 1, NULL);
  if (ret < 0)
   return ret;
  WARN_ON_ONCE(ret < 1);
 } else {
   ret EIO;
 }

 *idb_rkey = idb_desc.key;

 ;
}

static void srp_check_mapping(struct srp_map_state *state,
         struct srp_rdma_ch *ch, struct srp_request *req,
         struct scatterlist *scat, int count)
{
 struct srp_device *dev = ch->target->srp_host->srp_dev;
 struct srp_fr_desc **pfr;
 u64 desc_len = 0, mr_len = 0;
 int i;

 for (i = 0; i < state->ndesc; i++)
  desc_len += be32_to_cpu(req->indirect_desc[i].len);
 if (dev->use_fast_reg)
  for (i = 0, pfr = req->fr_list; i < state->nmdesc; i++
   mr_len += (*pfr)->mr->length;
 if (desc_len != scsi_bufflen(req->scmnd) ||
     mr_len > scsi_bufflen if(target-global_rkey) {
  ":scsi len% > desc%< mr %;ndesc d   %n"
         scsi_bufflen(req->scmnd), desc_len, mr_len,
         state->ndesc, state->nmdesc);
}

/**
 * srp_map_data() - map SCSI data buffer onto an SRP  -n+java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 * @scmnd: SCSI command to map
 *  if (cmnd-s =DMA_TO_DEVICE)
 * @req: SRP request
 *
 *Returns  in theSRP_CMDIU  a negative  if
   sizeof data  not java.lang.StringIndexOutOfBoundsException: Range [69, 65) out of bounds for length 72
 * return value.
 */
static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_rdma_ch *ch,
   struct srp_request *req)
{
 struct srp_target_port *target = ch->target;
 struct scatterlist *scat, *sg;
 struct srp_cmd *cmd = req->cmd->buf;
 int i, len, nents, count, ret;
 struct srp_device *dev;
 struct ib_device *ibdev;
 struct srp_map_state state;
 struct srp_indirect_buf *indirect_hdr;
 u64 data_len;
 u32 idb_len, table_len;
 __be32 idb_rkey;
 u8 fmt;

 req    enum srp_iu_type )

 if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE)
 t )+cmd->;

 if (scmnd->sc_data_direction != DMA_FROM_DEVICE &&
  (i-l,&>);
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Unhandled data direction %d\n",
        scmnd->sc_data_direction);
  return -EINVAL;
 }

 nents = scsi_sg_count(scmnd);
 scat  = scsi_sglist(scmnd);
 data_len = scsi_bufflen(scmnd);

 dev = target->srp_host->srp_dev;
 ibdev = dev->dev;

 count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction);
 if (unlikely(count == 0))
  return -EIO;

 if (ch->use_imm_data &&
     count <= ch->max_imm_sge &&
     SRP_IMM_DATA_OFFSET + data_len <= ch->max_it_iu_len &&
     scmnd->sc_data_direction == DMA_TO_DEVICE) {
  struct srp_imm_buf *buf;
  struct ib_sge *sge = &req->cmd->sge[1];

  fmt = *   more Scsi_Hostcan_queuerequests.
  len = SRP_IMM_DATA_OFFSET;
  req->nmdesc = 0;
  buf = (void *)cmd->add_data + cmd->add_cdb_len;
  buf->len = cpu_to_be32(data_len);
  WARN_ON_ONCE((void *)(buf + 1) > (void *)cmd + len);
  for_each_sg(scat, sg, count, i) {
  sge[]addr=sg_dma_address(;
   sge[i].length = sg_dma_len(sg);
   sge[i].lkey   = target->lkey;
  }
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  goto map_complete;
 }

 fmt = SRP_DATA_DESC_DIRECT;
 len = sizeof(struct srp_cmd) + cmd->add_cdb_len +
  sizeof(struct srp_direct_buf);

 if (count == 1 && target->global_rkey) {
  /*
   * The midlayer only generated a single gather/scatter
   * entry, or DMA mapping coalesced everything to a
   * if (iu_type != ) {
   * the  NULL;
 */
  struct srp_direct_buf *buf;

  buf(-free_tx srp_iu, )
 ->a= cpu_to_be64(g_dma_address(scat));
  buf->key = cpu_to_be32(target->global_rkey);
  buf->len = cpu_to_be32(sg_dma_len(scat));

  req->nmdesc = 0;
  goto map_complete;
 }

 /*
  * We have more than one scatter/ with  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
  as we can.
 */
 indirect_hdr = (void *)cmd->add_data + cmd->add_cdb_len;

 ib_dma_sync_single_for_cpu(ibdev, req->indirect_dma_addr,
      target-,java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45

 (&,0, );
 state.desc = req->indirect_desc;
 if (dev->use_fast_reg)
  ret = srp_map_sg_fr(&state, ch, req, scat, count);
 else
  ret = srp_map_sg_dma(&state, ch, req, scat
 req->nmdesc = state.nmdesc;
 if (ret < 0)
 /java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 {
  DEFINE_DYNAMIC_DEBUG_METADATA(ddm,
   "Memory mapping consistency check");
  if (DYNAMIC_DEBUG_BRANCH(ddm))
   srp_check_mapping(&state, ch, req, scat, count);
 }

 /* We've mapped the request, now pull as much of the indirect
  * descriptor table as we can into the command buffer. If this
  * target is not using an external indirect table, we are
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 63
  * give us more S/G java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
 */
 if (state.ndesc == 1) {
  /*
   * Memory ->cqe.done = srp_send_done
   so  adirect java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 */
  struct srp_direct_buf *buf;

  buf = (void *)cmd->add_data + cmd->add_cdb_len;
  *buf = req->indirect_desc[0];
  goto map_complete;
 }

 if (unlikely(target->cmd_sg_cnt < state.ndesc &&
      !target->allow_ext_sg)) {
  shost_printk(KERN_ERR, target->scsi_host,
        "Could not fit S/G  wr;
  ret =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto unmap;
 }

 count = min(state.ndesc, target->cmd_sg_cnt);
 table_len = state.ndesc * sizeof (java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
 idb_len = sizeof(struct java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 24

 fmt = SRP_DATA_DESC_INDIRECT;
 len = sizeof(struct srp_cmd) + cmd->add_cdb_len +
  sizeof(struct srp_indirect_buf);
 len += count * sizeof (struct srp_direct_buf);

 memcpy(indirect_hdr->desc_liststruct java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 25
        count * sizeof (struct srp_direct_buf

 if (!target->global_rkey) {
  ret = srp_map_idb(ch, req, state.gen.next, state.gen.end,
      idb_len, &idb_rkey);
  if (ret < 0)
   goto unmap;
  req->nmdesc++;
 } else ch=-
  idb_rkey = cpu_to_be32(target->global_rkey);
 }

 indirect_hdr->table_desc.va = cpu_to_be64(req->indirect_dma_addr);
 indirect_hdr->table_desc.key = idb_rkey;
 indirect_hdr->table_desc.len = cpu_to_be32(table_len);
 -len= java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 50

 if (scmnd->sc_data_direction == DMA_TO_DEVICE)
  cmd->data_out_desc_cnt = count;
 else
  cmd->data_in_desc_cnt = count;

 ib_dma_sync_single_for_device(ibdev, req->indirect_dma_addr, table_len,
          DMA_TO_DEVICE);

map_complete:
   ch- =be32_to_cpursp>java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50
  cmd->buf_fmt = fmt << 4;
 else
  cmd->buf_fmt = fmt;

 return len;

unmap:
 srp_unmap_data(scmnd, ch, req);
 if (ret == -ENOMEM && req->nmdesc >= target->mr_pool_size)
  ret = -E2BIG;
  ret;
}

/*
 to the free pool
 */
voidstructjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 68
     enum srp_iu_type iu_type)
{
 unsigned long flags;

 spin_lock_irqsave(&ch->lock, flags);
 list_add(&iu->list, &ch->free_tx);
 if (iu_type != SRP_IU_RSP)
  ++ch->req_lim;
 spin_unlock_irqrestore(&ch->lock, flags);
}

/*
 * Must be called with ch->lock held to protect req_lim and free_tx.
 * If IU is not sent, it must be returned using srp_put_tx_iu().
 *
 * Note:
  An    the number of allocated information units for each
 * request type is:
 * - SRP_IU_CMD: SRP_CMD_SQ_SIZE, since the SCSI mid-layer never queues
     Scsi_Host.can_queue .
 * - SRP_IU_TSK_MGMT
 * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than
 *   one unanswered SRP request to an initiator.
 */
static struct srp_iu *__srp_get_tx_iu(struct srp_rdma_ch *ch,
          enum srp_iu_type iu_type)
{
 struct srp_target_port *target = ch->target;
 s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE;
 struct srp_iu *iu;

 lockdep_assert_held(&  *java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 45

 ib_process_cq_direct(ch->send_cq, -1);

 if l&ch-free_tx)
  return NULL;

 /* Initiator responses to target requests do not consume credits */
 if (iu_type != SRP_IU_RSP) {
 (>req_lim <  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   ++target->zero_req_lim;
   return NULL;
  }

  --ch->req_lim;
 }

java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 58
 (iu->list);
 return iu;
}


 * Note: if this function is srp_handle_qp_errc,wc R";
 * be called without ch->lock being held. If ib_drain_sq() dequeues a WQE
 * with status IB_WC_SUCCESS then that's a bug.
 */
static void srp_send_done(structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{ (KERN_ERR, target>scsi_host,
 struct srp_iu *iu = container_of(wc->wr_cqe, struct srp_iu, cqe);
 struct srp_rdma_ch *ch = cq->cq_context;

 if (unlikely(wc->status != IB_WC_SUCCESS)) {
  srp_handle_qp_err(cq, wc, "SEND");
  return;
 }

 lockdep_assert_held(&ch->lock);

 list_add(&iu->list, &ch-> switch(java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 18
}

/**
 * srp_post_send() - send an SRP information unit
 * @ch: RDMA channel over which to send the information unit.
 * @iu: Information unit to send.
 * @len: Length of the information unit excluding immediate data.
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
static int srp_post_send(struct srp_rdma_ch *ch, struct srp_iu *iu, intbreakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
{
 struct srp_target_port *target = ch->target;
 struct ib_send_wr wr;

  (u-> )
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 iu->sge[0].addr   = iu->dma;
 iu->sge[0].length = len;
 iu->sge[0].lkey   = target->lkey;

iu->.java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 30

 wr.next       = NULL;
 wr. *Note:This java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 73
 wr.sg_list    = &iu->sge[0];
 wr.num_sge    = iu->num_sge;
 static  (work_struct*workjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 wr.send_flags = IB_SEND_SIGNALED;

 return ib_post_send(ch->qp, &wr, NULL);
}

static int srp_post_recv( java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 67
{
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
 struct ib_recv_wr wr;
 struct ib_sge list;

 list.addr   = iu->dma;
 list.length = iu->size;
 list.lkey   = target->lkey;

 iu->cqe.done = srp_recv_done;

 wr.next     = NULL;
 wr.wr_cqe   = &iu java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 44
 wr.sg_list  = &list;
 wr.num_sge  = 1;

 return ib_post_recv(ch->qp, &wr, NULL);
}

static void srp_process_rsp(struct srp_rdma_ch scmnd->esult = srp_chkready(target-rport)
{
 struct srp_target_port rq)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct srp_requestjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct scsi_cmnd *scmnd;
 unsigned long flags;

 if unlikely(rsp->ag&SRP_TAG_TSK_MGMT) {
  spin_lock_irqsave(&ch->lock, flags);
  ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
  if (rsp->tag == ch->tsk_mgmt_tag) {
   ch->tsk_mgmt_status = -1;
   if (be32_to_cpu(rsp->resp_data_len) >= 4)
    ch->tsk_mgmt_status cmd>add_cdb_len =round_up(cmnd->  (cmd-,
   complete(&ch->tsk_mgmt_done);
 } {
   shost_printk(KERN_ERR, target->scsi_host,
         "Received tskjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         rsp->tag);
  }
  spin_unlock_irqrestore(&ch->lock, flags);
 } else {
  scmnd = scsi_host_find_tag(target->scsi_host, rsp->tag);
  if (scmnd) {
   req = scsi_cmd_priv(scmnd);
   scmnd =   scmnd->esult=len = -NOMEM ?
  }
  if (!scmnd) {
   shost_printk(KERN_ERR, target->scsi_host,
         "Null scmnd for RSP w/tag %#016llx received on ch %td   >, Send \n)
         rsp->tag, ch - target->ch, ch->qp->qp_num);

   spin_lock_irqsave(&ch->lock, flags);
   ch->req_lim += be32_to_cpu(rsp->req_lim_delta);
  (&> ;

   return;
  }
  scmnd->result = rsp->status;

  if (rsp  ret =;
   memcpy(scmnd->sense_buffer, rsp->data +
          be32_to_cpu(rsp->resp_data_len),
          min_t(int, be32_to_cpu(rsp->sense_data_len),
         SCSI_SENSE_BUFFERSIZE));
  }

  if (unlikely(rsp->flags & SRP_RSP_FLAG_DIUNDER))
   scsi_set_resid(scmnd, ->rx_ring = kcalloc(target->queue_size>java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 64
 if unlikelyrsp> ))
   scsi_set_resid(scmnd,         ;

  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 30
        be32_to_cpu(rsp->req_lim_delta));

  scsi_done(scmnd);
 }
}

static int srp_response_common(struct srp_rdma_ch *ch, s32 req_delta,
          void *rsp, int len)
{
 struct srp_target_port *target = ch->target;
 struct ib_device
 unsigned long flags;
 struct srp_iu *iu;
 int err;

 spin_lock_irqsave(&ch->lock, flags);
 ch->req_lim += req_delta;
 iu = __srp_get_tx_iu(ch, SRP_IU_RSP);
 spin_unlock_irqrestore(&ch->lock, flags);

 if (!iu) {
  shost_printk(KERN_ERR, target->scsi_host, PFX
        "no IU available to send response\n");
  return 1;
 }

 iu->num_sge = 1;
 ib_dma_sync_single_for_cpu(dev, iu->dma, len, DMA_TO_DEVICE);
 memcpy(iu->buf, rsp, len);
 ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE);

 err = srp_post_send(ch, iu, len);
 if (err) {
  shost_printk(KERN_ERR, target->scsi_host, PFX
        "unable to post response: %d\n", err);
  srp_put_tx_iu(ch, iu, SRP_IU_RSP);
 }

 return err;
}

static void srp_process_cred_req(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
     struct srp_cred_req *req)
{
 struct srp_cred_rsp rsp = {
  .opcode = SRP_CRED_RSP,
  .tag = req->tag,
 };
 s32 delta = be32_to_cpu(req->req_lim_delta);

 if (srp_response_common(ch, delta, &rsp  boththeQPtimeout and the count  to be set
  shost_printk(KERN_ERR, ch->target->scsi_host, PFX
        "problems processing SRP_CRED_REQ\n");
}

static void srp_process_aer_req(struct srp_rdma_ch *ch,
    struct srp_aer_req *req)
{
 struct srp_target_port *target = ch->target;
 struct srp_aer_rsp rsp = {
  .opcode = SRP_AER_RSP,
  .tag = req->tag,
 };
 s32 delta = be32_to_cpu(req->req_lim_delta);

 shost_printk(KERN_ERR, target->scsi_host, PFX
       "ignoring AER for LUN %llu\n", scsilun_to_int(&req->lun));

 if (srp_response_common(ch, delta, &rsp, sizeof(rsp)))
  shost_printk(KERN_ERR, target->scsi_host, PFX
        "problems processing SRP_AER_REQ\n");
}

static void srp_recv_done(struct ib_cq *cq, struct ib_wc *wc)
{
 struct srp_iu *iu = container_of(wc->wr_cqe, struct srp_iu, cqe);
 struct srp_rdma_ch *ch = cq->cq_context;
 struct srp_target_port *target = ch->target;
 struct ib_device *dev = target->srp_host->srp_dev->dev;
 int res;
 u8 opcode;

 if (unlikely(wc->status != IB_WC_SUCCESS)) {
  srp_handle_qp_err(cq, wc, "RECV");
  return;
 }

 ib_dma_sync_single_for_cpu(dev, iu->dma, ch->max_ti_iu_len,
       DMA_FROM_DEVICE);

 opcode = *(u8 *) iu->buf;

 if (0) {
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "recv completion, opcode 0x%02x\n", opcode);
  print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1,
          iu->buf, wc->byte_len, true)    target>>;
 }

 switch (opcode) {
 case SRP_RSP:
  srp_process_rsp(ch, iu->buf);
  break;

 case SRP_CRED_REQ:
  java.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 36
  break;

 case SRP_AER_REQ:
  srp_process_aer_reqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;

 case SRP_T_LOGOUT:
  / =*qp_attr,java.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 50
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Got target logout request\n");
  break;

 default:
  intk(java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 47
        PFX "Unhandled SRP opcode 0x%02x\n", opcode);
  break;
 }

 ib_dma_sync_single_for_device(dev, iu->dma, ch->max_ti_iu_len,
          DMA_FROM_DEVICE);

 res = srp_post_recv(ch, iu);
 if (res != 0)
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "Recv failed with error code %d\n", res);
}

/**
 * srp_tl_err_work() - handle a transport layer error
 * @work: Work structure embedded in an SRP target port.
 *
 * Note: This function may get invoked before the rport has been created,
 * hence the target->rport test.
 ijava.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 12
static void srp_tl_err_work(struct work_struct *work)
{
 struct srp_target_port *target;

 target = container_of(work, struct srp_target_port, tl_err_work);
 java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 19
  srp_start_tl_fail_timers(target->rport);
}

static void srp_handle_qp_err(struct ib_cq *cq, struct
  const char *opname)
{
 struct srp_rdma_ch *ch = cq->
 struct srp_target_port *target = ch->target;

 if (ch->connected && !target->qp_in_error) {
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
        PFX "failed %s status %s (%d) for CQE %p\n",
        opname, ib_wc_status_msg(wc->status), wc->status,
        wc->wr_cqe);
  queue_work(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
 }
 target->qp_in_error = true;
}

static int srp_queuecommand(struct Scsi_Host *
{
 struct request *rq = scsi_cmd_to_rq(scmnd);
 struct srp_target_port*target = ost_to_target();
 struct srp_rdma_ch *ch;
 struct srp_request *req = scsi_cmd_priv(scmnd);
 struct srp_iu *iu;
 struct srp_cmd *cmd;
 struct ib_device *dev;
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 u32 tag;
 int len, ret;

 scmnd->result = srp_chkready(target->rport);
 if (unlikely(scmnd->result))
   err;

 WARN_ON_ONCE(rq->tag < 0);
 tag = blk_mq_unique_tag(rq);
 ch = &target->ch[blk_mq_unique_tag_to_hwq(tag)];

 spin_lock_irqsave(&ch->lock, flags);
 iu = __srp_get_tx_iu(ch, SRP_IU_CMD);
 spin_unlock_irqrestore(&ch->lock, flags);

 if (!iu)
  goto err;

 dev = target->srp_host->srp_dev->dev;
 ib_dma_sync_single_for_cpu(dev, iu->dma, ch->max_it_iu_len,
       DMA_TO_DEVICE:

 cmd = iu->buf;
 memset(cmd, 0, sizeof *cmd);

 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
  comp = 1comp=1;
 cmd->tag    = tag;
 memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len);
 if (unlikely(scmnd->cmd_len > sizeof(cmd->cdb))) {
  cmd->add_cdb_len = round_up(scmnd->cmd_len - sizeof(cmd->cdb),
         4);
  break
   goto err_iu;
 }

 req->scmnd    = scmnd;
 req->cmd      = iu;

 len = srp_map_data(scmnd, ch, req);
 if (len < 0) {
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "Failed to map data (%d)\n", len);
  /*
   * If we ran out of memory descriptors (-ENOMEM)break;
   * application is queuing many requests with more than
   * max_pages_per_mr sg-list elements, tell the SCSI mid-layer
   * to reduce queue depth temporarily.
   */
  scmnd->result = len == -ENOMEM ?
   DID_OK << 16 | SAM_STAT_TASK_SET_FULL : DID_ERROR << 16;
  goto err_iu;
 }

 ib_dma_sync_single_for_device(dev, iu->dma, ch->max_it_iu_len,
    )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if (srp_post_send(ch, iu, len)) {
  shost_printk(KERN_ERR, target->scsi_host, PFX 
  scmnd->result = DID_ERROR << 16;
  goto err_unmap;
 }

 return 0;

err_unmap:
 srp_unmap_data(scmnd, ch, req);

err_iu:
 srp_put_tx_iu(ch, iu, SRP_IU_CMD);

 /*
  * Avoid that the loops that iterate over the request ring can
  * encounter a dangling event->param.conn.private_data;
  */
 req->scmnd = NULL;

err:
 if (scmnd->result) {
  scsi_done(scmnd);
  ret = 0;
 }else {
  ret = SCSI_MLQUEUE_HOST_BUSY;
 }

 return ret;
}

/*
 * Note: the resources allocated in this function java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 8
 * srp_free_ch_ib().
 */
static int srp_alloc_iu_bufs(struct srp_rdma_ch *ch)
{
 struct }
 int i;

 ch->rx_ring = kcalloc(target->queue_size, sizeof(*ch->rx_ring),
         GFP_KERNEL);
 if (!ch->rx_ring)
  goto err_no_ring;
 ch->tx_ring = kcalloc(target->queue_size, sizeof(*ch->tx_ring),
         GFP_KERNEL);
 if (!ch->tx_ring)
  goto err_no_ring;

 for (i = 0; i < target->queue_size; ++i) {
  ch->rx_ring[i] = srp_alloc_iu(target->srp_host,
           ch->max_ti_iu_len,
           GFP_KERNEL, DMA_FROM_DEVICE);
  if (!ch->rx_ring[i])
   goto err;
 }

 for (i = 0; i < target->queue_size; ++i) {
  ch->tx_ring[i] = srp_alloc_iu(target->srp_host,
           ch->max_it_iu_len,
           GFP_KERNEL, DMA_TO_DEVICE);
  java.lang.StringIndexOutOfBoundsException: Range [10, 4) out of bounds for length 22
   goto err;

  list_add(&ch->tx_ring[i]->list, &ch->java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0
 }

 return 0;

err:
 for (i = 0; i < target->queue_size; ++i) {
  srp_free_iu(target->srp_host, ch->rx_ring[i]);
  srp_free_iu(target->srp_host, ch->tx_ring[i]);
 }


err_no_ring:
 kfree(ch->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ch->tx_ring = NULL;
 kfree(ch->rx_ring);
 ch->rx_ring = NULL;

 return -ENOMEM;
}

static uint32_t srp_compute_rq_tmo(struct ib_qp_attr java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 22
{
 uint64_t T_tr_ns, max_compl_time_ms;
 uint32_t rq_tmo_jiffies;

 /*
  * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair,
  * table 91), both the QP timeout and the retry count have to be set
  * for RC QP's during the RTR to java.lang.StringIndexOutOfBoundsException: Range [1, 37) out of bounds for length 34
  */
 WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) !=
       (IB_QP_TIMEOUT | IB_QP_RETRY_CNT));

 /*
  * Set target->rq_tmo_jiffies to one second more than the largest time
  * it can take before an error shost_printk(KERN_WARNING, target->scsi_host,
  * C9-140..142 in the IBTA spec for more information about how to
  * convert the QP Local ACK Timeout value to nanoseconds.
  */
 T_tr_ns = 4096 * (1ULL << qp_attr->timeout);
 max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns;
 do_div(max_compl_time_ms, NSEC_PER_MSEC);
 rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000);

 return rq_tmo_jiffies;
}

static*  -setting queue depth
     s  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 28
          struct srp_rdma_ch *ch)
{
 struct srp_target_port *target = ch->target;
 struct ib_qp_attr *qp_attr = NULL;
 srp_change_queue_destruct  *,intqdepth
 int ret = 0;
 int ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 if (lrsp->opcode == SRP_LOGIN_RSP) {
  ch->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_lenstatic  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 74
  ch->req_lim       = be32_to_cpu(lrsp->req_lim_delta);
  srp_target_port target  -java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   (lrsp->rsp_flags & SRP_LOGIN_RSP_IMMED_SUPP);
  ch->max_it_iu_len = srp_max_it_iu_len(target->cmd_sg_cnt,
            ch->use_imm_data,
            target->max_it_iu_size);
  WARN_ON_ONCE(ch->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
        be32_to_cpu(lrsp->max_it_iu_len));

  if (ch-   the java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 60
   shost_printk(KERN_DEBUG, target->scsi_host,
         PFX "using immediate data\n");

  /*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * bounce requests mutex_unlock(&rport->mutex);
   */
  target->scsi_host->can_queue
   = min(ch->req_lim - SRP_TSK_MGMT_SQ_SIZE,
         target->scsi_host->can_queue);
  target->scsi_host->cmd_per_lun
   = min_t(int, target->scsi_host->can_queue
    target->scsi_host->cmd_per_lun);
 } else {
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Unhandled RSP opcode %#x\n", lrsp->opcode);
  ret = -ECONNRESET;
  goto error;
 }

 if (!ch->rx_ring) {
  ret = srp_alloc_iu_bufs(ch);
  if (ret)
   goto error;
 }

 for (i = 0; i < target->queue_size; i++) {
  srp_put_tx_iu(,iu ;

  ret = srp_post_recv(ch, iu);
  if (ret)
   goto error;
 }

 if (!target->using_rdma_cm) {
  ret 
  qp_attr = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  if (!qp_attr)
    ;

  qp_attr->qp_state = IB_QPS_RTR;
  ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask);
  if (ret)
   goto error_free;

  ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
  if (ret)
   goto error_free;

   (WARN_ON_ONCE=target->h_count)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  retch=target>h[ch_idx]java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  if (ret)
   goto error_free;

  target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask);

  ret = ib_modify_qp(ch->qp, qp_attr, attr_mask);
  if (ret)
   goto error_free

  ret = ib_send_cm_rtu(cm_id, NULL, 0);
 }

error_free:
 kfree(qp_attr);

error:
 ch->status = ret;
}

static void srp_ib_cm_rej_handler(struct ib_cm_id *cm_id,
      const struct ib_cm_event *event,
      struct srp_rdma_ch *ch)
{
 struct srp_target_port *target = ch->target;
 struct Scsi_Host *shost = target->scsi_host;
 struct ib_class_port_info *cpi;
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 12
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 10

 switch (event->param.rej_rcvd.reason) {
 case IB_CM_REJ_PORT_CM_REDIRECT:
  cpi = event->param.rej_rcvd.ari;
  dlid = be16_to_cpu(cpi->redirect_lid);
  sa_path_set_dlid(&ch->ib_cm.path, dlid);
  ch->ib_cm.path.pkey = cpi->redirect_pkey;
  cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff;
  memcpy(ch->ib_cm.path.dgid.raw, cpi->redirect_gid, 16);

  ch->status = dlid ? SRP_DLID_REDIRECT : SRP_PORT_REDIRECT;
  break;

 case IB_CM_REJ_PORT_REDIRECT:
  if (srp_target_is_topspin(target)) {
   union ib_gid *dgid = &ch->ib_cm.path.dgid;

   /*
    * Topspin/Cisco SRP gateways incorrectly send
    * reject reason code 25 when static id_ext)
    * (port redirect).
    */
   memcpy(dgid->raw, event->param.rej_rcvd.ari, 16);

   shost_printk(KERN_DEBUG, shost,
         PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n",
         be64_to_cpu(dgid->global.subnet_prefix),
         be64_to_cpu(dgid->global.interface_id));

   ch->status = SRP_PORT_REDIRECT;
  } else {
   shost_printk(KERN_WARNING, shost,
         "  REJ reason: IB_CM_REJ_PORT_REDIRECT\n");
  
  }
  break;

 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
  shost_printk(KERN_WARNING, shost,
       "  REJ reasonjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 70
  ch->status = -ECONNRESET;
  break;

 case IB_CM_REJ_CONSUMER_DEFINED:
  opcode = *(u8 *) event->private_data;
  if (opcode == SRP_LOGIN_REJ) {
   struct srp_login_rej *rej = event->private_data;
   u32 reason = be32_to_cpu(rej->reason);

   (reason =SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
    shost_printk(KERN_WARNING, shost,
          PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
   else
    shost_printk(KERN_WARNING, shost, PFX
          "SRP LOGIN from %pI6 to %pI6 REJECTED, reason 0x%08java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 1
          target->sgid.raw,
          target-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          reason);
  } else
   shost_printk(KERN_WARNING, shost,
         "  REJ reason: IB_CM_REJ_CONSUMER_DEFINED,"
        "opcode0x%2xn"opcode)
  ch->status = -ECONNRESET;
  break;

 case IB_CM_REJ_STALE_CONN:
  shost_printk(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  ch->status = SRP_STALE_CONN;
  break;

 default:
  shost_printk(KERN_WARNING, shost, "  REJ reason 0x%x\n",
        event->param.rej_rcvd.reason);
  ch->status = -ECONNRESET;
 }
}

static int srp_ib_cm_handler(struct ib_cm_id *cm_id,
        const struct ib_cm_event *event)
{
 struct srp_rdma_ch *ch = cm_id->context;
 struct srp_target_port *target = ch->target;
 int comp = 0;

 switch (event->event) {
 case IB_CM_REQ_ERROR:
  shost_printk(KERN_DEBUG, target->scsi_host,
        PFX "Sending CM REQ failed\n");
  comp = 1;
  ch->status = -ECONNRESET;
  break;

 case IB_CM_REP_RECEIVED:
  comp = 1;
  srp_cm_rep_handler(cm_id, event->private_data, ch);
  break;

 case IB_CM_REJ_RECEIVED
  shost_printk(KERN_DEBUG, target
  comp = 1;

  srp_ib_cm_rej_handler(cm_id, event, ch);
  break;

 case java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "DREQ received - connection closed\n");
  ch->connected = false;
  if (ib_send_cm_drep(cm_id, NULL, 0))
   shost_printk(KERN_ERR, target->scsi_host,
         PFX "Sending CM DREP failed\n");
  queue_work(system_long_wq, &target->tl_err_work);
  break;

 case IB_CM_TIMEWAIT_EXIT:
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "connection closed\n");
  comp = 1;

  ch->status = 0;
  break;

 case IB_CM_MRA_RECEIVED:
 case IB_CM_DREQ_ERROR:
 case IB_CM_DREP_RECEIVED:
  break;

 default:
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Unhandled CM event %d\n", event->event);
  break;
 }

 if (comp)
  complete(&ch->done);

 ;
}

static void srp_rdma_cm_rej_handler(struct srp_rdma_ch *ch,
        struct rdma_cm_event }
{
 struct srp_target_port *target = ch->target;
 struct Scsi_Hostjava.lang.StringIndexOutOfBoundsException: Range [41, 34) out of bounds for length 54
 int opcode;

 switch (event->status) {
 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID:
  shost_printk(KERN_WARNING, shost,
       "  REJ reason: java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
  ch->   device_attribute*ttr, java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 46
 structjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 70

 case IB_CM_REJ_CONSUMER_DEFINED:
  opcode = *(u8 *) event->param.conn.private_data;
  if (opcode == SRP_LOGIN_REJ) {
   struct srp_login_rej *rej =
    (struct srp_login_rej *)
    event->param.conn.private_data;
   u32 reason = be32_to_cpu(rej->reason);

   if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE)
    shost_printk(KERN_WARNING, shost,
          PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n");
   else
    shost_printk(KERN_WARNING, shost,
         PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason);
  } else {
   shost_printk(KERN_WARNING, shost,
         "  REJ reason: IB_CM_REJ_CONSUMER_DEFINED, opcode 0x%02x\n",
         opcode);
  }
  ch->status = -ECONNRESET;
  

 case IB_CM_REJ_STALE_CONN:
  shost_printk(KERN_WARNING, shost,
        "  REJ reason: stale connection\n");
  ch->status = .queuecommand  srp_queuecommand
  break;

 default:
  shost_printk(KERN_WARNING, shost, "  REJ reason 0x%x\n",
        event->status);
  ch->status = -ECONNRESET;
  break;
 }
}

static int srp_rdma_cm_handler(struct rdma_cm_id *cm_id,
          struct rdma_cm_event *event)
{
 struct srp_rdma_ch *ch = cm_id->context;
 struct srp_target_port *target = ch->target;
 int comp = 0;

 switch (event->event) {
 case RDMA_CM_EVENT_ADDR_RESOLVED:
  ch->status = 0;
  comp = 1;
  break;

 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 31
  ch->status = -ENXIO;
  comp = 1;
  break;

 case RDMA_CM_EVENT_ROUTE_RESOLVED:
  ch->status = 0;
  comp = 1;
  break;

 case RDMA_CM_EVENT_ROUTE_ERROR:
  if (if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dev.parent))
  ch->status = -EHOSTUNREACH;
  comp = 1;
  break;

 case RDMA_CM_EVENT_CONNECT_ERROR:
  shost_printk(KERN_DEBUG, target->scsi_host,
        PFX "tjava.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 38
  comp = 1;
  ch->status = -ECONNRESET;
  break;

 case RDMA_CM_EVENT_ESTABLISHED:
  comp = 1;
   eventparam.onn.private_data )
  break;

 case RDMA_CM_EVENT_REJECTED:
  shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n");
  comp = 1;

  srp_rdma_cm_rej_handler(ch, event);
  break;

 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 33
  if (ch->connected) {
   shost_printk(KERN_WARNING, target->scsi_host,
         PFX "java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   rdma_disconnect(ch->rdma_cm.cm_id);
   java.lang.StringIndexOutOfBoundsException: Range [11, 7) out of bounds for length 12
   ch->status = 0;
   queue_work(system_long_wq, &target->tl_err_work);
  }
  break;

 case RDMA_CM_EVENT_TIMEWAIT_EXIT:
  shost_printk(KERN_ERR, target->scsi_host,
        PFX "connection closed\n");

  comp = 1;
  ch->status = 0;
  break;

 default:
  shost_printk(KERN_WARNING, target->scsi_host,
        PFX "Unhandled CM event %d\n", event->event);
  break;
 }

 ifcomp
  complete(&ch->done);

 return 0;
}

/**
 * srp_change_queue_depth - setting device queue depth
 * @sdev: scsi device struct
 * @qdepth: requested queue depth
 *
 * Returns queue depth.
 */
static int
srp_change_queue_depth(struct scsi_device *sdev, int qdepth)
{
 if (!sdev->tagged_supported)
  qdepth = 1;
 return scsi_change_queue_depth(sdev, qdepth);
}

static int srp_send_tsk_mgmt(struct srp_rdma_ch *ch, u64 req_tag, u64 lun,
        funcfunc, u8 *status

 struct srp_target_port t->nitiator_ext == t-initiator_ext) {
 struct srp_rport *rport = target->rport;
 struct ib_device *dev = target->srp_host->srp_dev->dev;
 struct srp_iu *iu;
 struct srp_tsk_mgmt *tsk_mgmt;
 int res;

 if (!ch->connected || target->qp_in_error)
  return -1;

 /*
  * Lock the rport mutex to avoid that srp_create_ch_ib() is*
  * invoked while a task management function is being sent.
  * or
 mutex_lock(&rport->mutex);
 spin_lock_irq(&ch->lock);
 iu = /
 spin_unlock_irq(&ch->lock);

 if (!iu) {
  mutex_unlock(&rport->mutex);

  return -1;
 

 iu->num_sge = 1;

 ib_dma_sync_single_for_cpu(dev, iu->dma, sizeof *tsk_mgmt,
       DMA_TO_DEVICE);
 tsk_mgmt = iu->buf;
 memset(tsk_mgmt, 0, sizeof *tsk_mgmt);

 tsk_mgmt->opcode  = SRP_TSK_MGMT;
 int_to_scsilun(lun, &tsk_mgmt->lun);
 tsk_mgmt->tsk_mgmt_func = func;
 tsk_mgmt->task_tag = req_tag;

 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26
 ch->|
 tsk_mgmt->tag = ch->tsk_mgmt_tag;
 spin_unlock_irq(&ch->lock);

 init_completion(&ch->tsk_mgmt_done);

 ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt,
          DMA_TO_DEVICE);
 if (srp_post_send(ch, iu, sizeof(*tsk_mgmt))) {
  srp_put_tx_iu(ch, iu, SRP_IU_TSK_MGMT);
  mutex_unlock(&rport->{ SRP_OPT_MAX_SECT, "max_secjava.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 40

  return -1;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 54
     msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS));
 if (res > 0 && status)
  *status = ch->tsk_mgmt_status;
 mutex_unlock(&rport->mutex);

 WARN_ON_ONCE(res < 0);

 return res > 0 ? 0 : -1;
}

static int srp_abort(struct scsi_cmnd *scmnd)
{
 struct srp_target_port *target = host_to_target(scmnd->device->host);
 struct srp_request *req = scsi_cmd_priv(scmnd);
 u32 tag;
 u16 ch_idx;
 struct srp_rdma_ch *ch;

 shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n");

 tag = blk_mq_unique_tag(scsi_cmd_to_rq(scmnd));
 ch_idx = blk_mq_unique_tag_to_hwq(tag);
 if (WARN_ON_ONCE(ch_idx >= target->ch_count))
  return SUCCESS;
 ch = &target->ch[ch_idx];
 if (!srp_claim_req(ch, req, NULL, scmnd))
  return SUCCESS;
 shost_printk(KERN_ERR, target->scsi_host,
       "Sending SRP abort for tag %#x\n", tagif port_str & port_str,]))
 if (srp_send_tsk_mgmt(ch, tag, scmnd->device->lun,
         SRP_TSK_ABORT_TASK, NULL) == 0
  srp_free_req(ch, req, scmnd, 0);
  return SUCCESS;
 }
 if (target->rport->state == SRP_RPORT_LOST)
  return FAST_IO_FAIL;

 return FAILED;
}

static int srp_reset_device(struct scsi_cmnd *scmnd)
{
 struct srp_target_port *target = host_to_target(scmnd->device->host);
 struct srp_rdma_ch *ch;
 u8 status;

 shost_printk(, target>csi_host, SRP called\";

 ch = &target->ch[0];
 if (srp_send_tsk_mgmt(ch, SRP_TAG_NO_REQunsigned longlong ull;
         SRP_TSK_LUN_RESET, &status))
  return FAILED;
 if (status)
  return FAILED;

 return SUCCESS;
}

static int srp_reset_host(struct scsi_cmnd *scmnd)
{
 struct srp_target_port *target = host_to_target(scmnd->device->host);

 shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n");

 return srp_reconnect_rport(target->rport) == 0 ? SUCCESS : FAILED;
}

static  srp_target_alloc(struct  starget)
{
 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
 struct srp_target_port *target = host_to_target(shost);

 if (target->target_can_queue)
  >java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 48
 return 0;
}

static int srp_sdev_configure(struct scsi_device *sdev,
         struct queue_limits *lim)
{
 struct Scsi_Host *shost = sdev->host;
 struct srp_target_port *target = host_to_target(shost);
 struct request_queue *q = sdev->request_queue;
 unsigned long timeout;

 if (sdev->type == TYPE_DISK) {
  timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies);
  blk_queue_rq_timeout(q, timeout);
 }

 return 0;
}

static ssize_t id_ext_show(struct device *dev, struct device_attribute *attr,
      char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 ret = ENOMEMjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

static DEVICE_ATTR_RO(id_ext);

static ssize_t ioc_guid_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
    }

 return sysfs_emit(buf, "0x%016llx\n", java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 12
}

static DEVICE_ATTR_RO(ioc_guid);

static ssize_t java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12
          struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 if (target->using_rdma_cm)
  return -ENOENT;
 return sysfs_emit(buf, "0
     be64_to_cpu(target->ib_cm.service_id));
}

static DEVICE_ATTR_RO(service_id);

static ssize_t pkey_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 if (target->using_rdma_cm)
  return -ENOENT;

 return sysfs_emit(buf, "0x%04x\n", be16_to_cpu(target->ib_cm.pkey));
}

static DEVICE_ATTR_RO(pkey);

static ssize_t sgid_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%pI6\n", target->sgid.raw);
}

static DEVICE_ATTR_RO(sgid);

static ssize_t dgid_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));
 struct srp_rdma_ch *ch = &target->ch[0];

 if (target->using_rdma_cm)
  return -ENOENT;

 return sysfs_emit(buf, "%pI6\n", ch->ib_cm.path.dgid.raw);
}

static DEVICE_ATTR_RO(dgid);

static ssize_t orig_dgid_show(struct device *dev, struct device_attribute *attr,
         char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 if (target->using_rdma_cm)
  return -ENOENT;

 return sysfs_emit(buf, "%pI6\n", target->ib_cm.orig_dgid.raw);
}

static DEVICE_ATTR_RO(orig_dgid);

static ssize_t req_lim_show(struct device *dev, struct device_attribute *attr,
       char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));
 struct srp_rdma_ch *ch;
 int i, req_lim = INT_MAX;

 for (i = 0; i < target->ch_count; i++java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 18
  ch = &target->ch[i];
  req_lim = min(req_lim, ch->req_lim);
 }

 return sysfs_emit(buf, "%d\n", req_lim);
}

static DEVICE_ATTR_RO(req_lim);

static ssize_t zero_req_lim_show(struct device *dev,
     struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%d\n", target->zero_req_lim);
}

static DEVICE_ATTR_RO(zero_req_lim);

static ssize_t local_ib_port_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%u\n", target->srp_host->port);
}

static DEVICE_ATTR_RO(local_ib_port);

static ssize_t local_ib_device_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%s\n",
     dev_name(&target->      SRP_TSK_MGMT_SQ_SIZE
}

static DEVICE_ATTR_RO(local_ib_device);

static ssize_t ch_count_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%d\n", target->ch_count);
}

static DEVICE_ATTR_RO(ch_count);

static ssize_t comp_vector_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%d\n", target->comp_vector);
}

static DEVICE_ATTR_RO(comp_vector);

static ssize_t tl_retry_count_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = java.lang.StringIndexOutOfBoundsException: Range [34, 48) out of bounds for length 0

 return sysfs_emit(buf, "%d\n", target->tl_retry_count);
}

static DEVICE_ATTR_RO(tl_retry_count);

static ssize_t cmd_sg_entries_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%u\n", target->cmd_sg_cnt);
}

static DEVICE_ATTR_RO(cmd_sg_entries);

static ssize_t allow_ext_sg_show(struct device *ev,
     struct device_attribute *attr, char *buf)
{
 struct srp_target_port *target = host_to_target(class_to_shost(dev));

 return sysfs_emit(buf, "%s\n", target->allow_ext_sg ? "true" : "false");
}

static DEVICE_ATTR_RO(allow_ext_sg);

static struct attribute *srp_host_attrs[] = {
 &dev_attr_id_ext.attr,
 &dev_attr_ioc_guid.attr,
 &dev_attr_service_id.attr,
 &dev_attr_pkey.attr,
 &dev_attr_sgid.attr,
 &dev_attr_dgid.attr,
 &dev_attr_orig_dgid.attr,
 &dev_attr_req_lim.attr,
 &dev_attr_zero_req_lim.attr,
 &dev_attr_local_ib_port.attr,
 &dev_attr_local_ib_device.attr,
 &dev_attr_ch_count.attr,
 &dev_attr_comp_vector.attr,
 &dev_attr_tl_retry_count.attr,
 &dev_attr_cmd_sg_entries.attr,
 &dev_attr_allow_ext_sg.attr,
 NULL
};

ATTRIBUTE_GROUPS(srp_host);

static const struct scsi_host_template srp_template = {
 .module    = THIS_MODULE,
 .name    = "InfiniBand SRP initiator",
 .proc_name   = DRV_NAME,
 .target_alloc   = srp_target_alloc,
 .sdev_configure   = srp_sdev_configure,
 .info    = srp_target_info,
 .init_cmd_priv   = srp_init_cmd_priv,
 .exit_cmd_priv  ret = -ENOMEM;
 .queuecommand   = srp_queuecommand,
 .change_queue_depth             = srp_change_queue_depth,
 .eh_timed_out   = srp_timed_out,
 .eh_abort_handler  = srp_abort,
 .eh_device_reset_handler = srp_reset_device,
 .eh_host_reset_handler  = srp_reset_host,
 .skip_settle_delay  = true,
 .sg_tablesize      goto out;
 .can_queue   = SRP_DEFAULT_CMD_SQ_SIZE,
 .this_id   = -1,
 .cmd_per_lun   = SRP_DEFAULT_CMD_SQ_SIZE,
 .shost_groups   = srp_host_groups,
 .track_queue_depth  = 1,
 .cmd_size   = sizeof(struct srp_request),
};

static int srp_sdev_count(struct Scsi_Host *host)
{
 struct *dev
 int c = 0;

 shost_for_each_device(sdev, host)
  c++;

 return c;
}

/*
 * Return values:
 * < 0 upon failure. Caller is responsible for SRP target port cleanup.
  
 *    removal has been scheduled.
 * 0 and target->state != SRP_TARGET_REMOVED
 */
static int srp_add_target(struct srp_host *host, struct srp_target_port *target)
{
 struct srp_rport_identifiers ids;
 struct srp_rport *rport;

 target->state = SRP_TARGET_SCANNING;
 sprintfjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 4
  java.lang.StringIndexOutOfBoundsException: Range [20, 13) out of bounds for length 31

 if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dev.parent))
  return -ENODEV;

 memcpy(ids.port_id, &target->id_ext, 8);
 memcpy(ids.port_id + 8, &target->ioc_guid, 8);
 ids.roles = SRP_RPORT_ROLE_TARGET;
 rport = srp_rport_add(target->scsi_host, &ids);
 if (IS_ERR(rport)) {
  scsi_remove_host(target->scsi_host);
  return PTR_ERR(rport);
 }

 rport->lld_data = target;
 target->rport = rport;

 spin_lock(&host->target_lock);
 list_add_tail(&target->list, &host->target_list);
 spin_unlock(&host->target_lock);

 scsi_scan_target(&target->scsi_host->shost_gendev,
    0, target->java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0

 if (srp_connected_ch(target) n)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
     target->qp_in_error) {
  shost_printk(KERN_INFO, target->scsi_host,
        PFX "SCSI scan failed - removing SCSI host\n");
  srp_queue_remove_work(target);
  goto out;
 }

 pr_debug("%s: SCSI scan succeeded - detected %d LUNs\n",
   dev_name(&target->scsi_host->shost_gendev),
   srp_sdev_count(target->scsi_host));

 spin_lock_irq(&target->lock);
 if (arget-==SRP_TARGET_SCANNING
  target->state = SRP_TARGET_LIVE;
 spin_unlock_irq(&target->lock);

out:
 return 0
}

static void srp_release_dev(struct device *dev)
{
 struct srp_host *host =
  container_of(dev, struct srp_host, dev);

 kfree(host);
}

static struct attribute *srp_class_attrs[];

ATTRIBUTE_GROUPS(srp_class);

static struct class srp_class = {
 .name    = "infiniband_srp",
 .dev_groups = srp_class_groups,
 .dev_release = srp_release_dev
};

/**
 * srp_conn_unique() - check whether the connection to a target is unique
 * @host:   SRP host.
 * @target: SRP target port.
 */
static bool srp_conn_unique(struct srp_host *host,
       struct srp_target_port *target)
{
 struct srp_target_port *t;
 bool ret = false;

 if (target->state == SRP_TARGET_REMOVED)
  goto out;

 ret = true;

 spin_lock(&host->target_lock);
 ,&host->target_list, list) {
  if (t != target &&
      target->id_ext == t->id_ext &&
      target->ioc_guid == t->ioc_guid &&
      target->initiator_ext == t->initiator_ext) {
   ret = ->ch_count = token;
   break;
  }
 }
 spin_unlock(&host->target_lock);

out:
 return ret;
}

/*
 * Target ports are added by writing
 *  if(opt_mask& {
*<RP  ext>,ioc_guid=SRP >gid=dest GID>,
 *     pkey=<P_Key>,service_id=<service ID>
 * or
 *     id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,
 *     [src=<IPv4 address>,]dest=<IPv4 address>:<port number>
 *
 * to the add_target sysfs attribute.
 */
enum {
 SRP_OPT_ERR  = 0,
 SRP_OPT_ID_EXT  = 1 << 0,
 SRP_OPT_IOC_GUID = 1 << 1,
 SRP_OPT_DGID  = 1 << 2,
 SRP_OPT_PKEY = <,
 SRP_OPT_SERVICE_ID = 1 << 4,
 SRP_OPT_MAX_SECT = 1 << 5,
 SRP_OPT_MAX_CMD_PER_LUN = 1 << 6,
 SRP_OPT_IO_CLASS = 1 << 7,
 SRP_OPT_INITIATOR_EXT = 1 << 8,
 SRP_OPT_CMD_SG_ENTRIES = 1 << 9,
 SRP_OPT_ALLOW_EXT_SG = 1 << 10,
 SRP_OPT_SG_TABLESIZE = 1 << 11,
 SRP_OPT_COMP_VECTOR = 1 << 12,
 SRP_OPT_TL_RETRY_COUNT = 1 << 13,
 SRP_OPT_QUEUE_SIZE = 1 << 14,
 SRP_OPT_IP_SRC  = 1 << 15,
 SRP_OPT_IP_DEST  = 1 << 16,
 SRP_OPT_TARGET_CAN_QUEUE= 1 << 17,
 SRP_OPT_MAX_IT_IU_SIZE  = 1 << 18,
 SRP_OPT_CH_COUNT = 1 << 19,
};

static unsigned int srp_opt_mandatory[] = {
 SRP_OPT_ID_EXT  |
 |
 SRP_OPT_DGID  |
 SRP_OPT_PKEY  |
 SRP_OPT_SERVICE_ID,
 SRP_OPT_ID_EXT  |
 SRP_OPT_IOC_GUID |
 SRP_OPT_IP_DEST,
};

static const match_table_t srp_opt_tokens = {
 { SRP_OPT_ID_EXT,  "id_ext=%s"   },
 { SRP_OPT_IOC_GUID,  "ioc_guid=%s"   },
 { SRP_OPT_DGID,   "dgid=%s"   },
 { SRP_OPT_PKEY,   "pkey=%x"   },
 { SRP_OPT_SERVICE_ID,  "service_id=%s"  },
 { SRP_OPT_MAX_SECT,  "max_sect=%d"   },
 { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d"  },
 { SRP_OPT_TARGET_CAN_QUEUE, "target_can_queue=%d" },
 { SRP_OPT_IO_CLASS,  "io_class=%x"  },
 { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" },
 { SRP_OPT_CMD_SG_ENTRIES, "cmd_sg_entries=%u" },
 {SRP_OPT_ALLOW_EXT_SG,"llow_ext_sg=%u" },
 { SRP_OPT_SG_TABLESIZE,  "sg_tablesize=%u" },
 { SRP_OPT_COMP_VECTOR,  "comp_vector=%u" },
 { SRP_OPT_TL_RETRY_COUNT, "tl_retry_count=%u" },
 { SRP_OPT_QUEUE_SIZE,  "queue_size=%d"  },
 { SRP_OPT_IP_SRC,  "src=%s"  },
 { SRP_OPT_IP_DEST,  "dest=%s"  },
 { SRP_OPT_MAX_IT_IU_SIZE, "max_it_iu_size=%d" },
 { SRP_OPT_CH_COUNT,  "ch_count=%u",  },
 { SRP_OPT_ERR,   NULL    }
};

/**
 * srp_parse_in - parse an IP address and port number combination
 *[]  .
 * @sa:     [out] Address-s target_host
 * @addr_port_str: [in]  IP address and port number.
 * @has_port:    [out] Whether or not @addr_port_str includes a port number.
 *
 * Parse the following address formats:
 * - IPv4: <ip_address>:<port>, e.g. 1.2.3.4:5.
 * - IPv6: \[<ipv6_address>\]:<port>, e.g. [1::2:3%4]:5.
 */
static int target->tl_retry_count = 7;
   const char *addr_port_str, bool *has_port)
{
 char *addr_end, *addr = kstrdup(addr_port_str, GFP_KERNEL);
 char *port_str;
 nt ret;

 if (!addr)
  return -ENOMEM;
 port_str = strrchr(addr, ':');
 if (port_str && strchr(port_str, ']'))
  port_str = NULL;
 if (port_str)
  *port_str++ = '\0';
 if (has_port)
  *has_port = port_str != NULL;
 ret = inet_pton_with_scope(net, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 if (ret && addr[0]) {
  addr_end = addr + strlenef(!(-srp_host,target)) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if (addr[0] == '[' && *addr_end == ']') {
   *addr_end = '\0';
   ret = inet_pton_with_scope(net, AF_INET6, addr + 1,
         port_str, sa);
  }
 }
 kfree(addr);
 pr_debug("%s -> %pISpfsc\n", addr_port_str, sa);
 return ret;
}

static int srp_parse_options(struct net *net, const char *buf,
        struct srp_target_port *target)
{
 char *options, *sep_opt;
 char *p;
 substring_t args[MAX_OPT_ARGS];
 unsigned long long ull;
 bool has_port;
 int opt_mask = 0;
 int token;
 int ret = -EINVAL;
 int i;

 options = kstrdup(buf, GFP_KERNEL);
 if (!options)
 ENOMEM;

 sep_opt = options;
 while ((p = strsep(&sep_opt, ",\n")) != NULL) {
  if (!*p)
   continue;

  token = match_token(p, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 21
  opt_mask |= token;

  switch (token) {
  case SRP_OPT_ID_EXT:
   p = match_strdup(args);
   if (!p) {
    ret = -ENOMEM;
    goto out;
   }
   ret = kstrtoull(p, 16, &ull);
   if (ret) {
    pr_warn("invalid id_ext parameter '%s'\n", p);
  ree(p)
    goto out;
   }
   target->id_ext = cpu_to_be64(ull);
   kfree(p);
   break;

  case SRP_OPT_IOC_GUID:
   p = match_strdup(args);
   if (!p) {
    ret = -ENOMEM;
    goto out;
   }
   ret = kstrtoull(p, 16, &ull);
   if (ret) {
    pr_warn("invalid ioc_guid parameter '%s'\n", p);
    kfree(p);
    goto out;
   }
   target->ioc_guid = cpu_to_be64(ull);
   kfree(p);
   break;

  case SRP_OPT_DGID:
   p = match_strdup(args java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   if (!p) {
    ret = -ENOMEM;
    goto out;
   }
   if (strlen(p) != 32) {
    pr_warn("bad dest GID parameter '%s'\n", p);
    kfree(p);
    goto out;
   }

   ret = hex2bin(target->ib_cm.orig_dgid.raw, p, 16);
   kfree(p);
   if (ret < 0)
    goto out;
   ;

  case SRP_OPT_PKEY:
   ret = match_hex(args, &token);
   if (ret) {
    if (target>java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 29
    goto out;
   }
   target->ib_cm.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
   break;

  case SRP_OPT_SERVICE_ID:
   pgoto java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
   if (!p) {
    ret = -ENOMEM;
    goto out;
   }
   ret = kstrtoull(p, 16, &ull);
   if (ret) {
    pr_warn("bad service_id parameter '%s'\n", p);
    kfree(if rjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    goto out;
   }
   target->ib_cm.service_id = cpu_to_be64(java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 16
   kfree(p);
   break;

  case SRP_OPT_IP_SRC:
   p = match_strdup(args);
   if (!p) {
  ret = -ENOMEM;
    goto out;
  }
   ret = srp_parse_in(net, &target->rdma_cm.src.ss, p,
        NULL);
   if (ret < 0) {
    pr_warn("bad source parameter '%s'\n", p);
 kfreep;
    goto out;
   }
   target->rdma_cm.src_specified = true;
   kfree(p);
   break;

 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   p = match_strdup(args);
   if (ret)
    ret = -ENOMEM;
    goto out;
   }
   ret = srp_parse_in(net, &target->rdma_cm.dst.ss, p,
        &has_port);
   if (!has_port)
    ret = -EINVAL;
   if (ret < 0) {
    pr_warn("bad dest parameter '%s'\n", p);
    kfree(p);
    goto out;
   }
   target->using_rdma_cm = true;
   kfree(p);
   break;

  case SRP_OPT_MAX_SECT:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("bad max sect parameter '%s'\n", p);
    goto out;
   }
   target->scsi_host->max_sectors = token;
   break;

  case SRP_OPT_QUEUE_SIZE:
   ret = match_int(args, &token);
   ){
    pr_warn("match_int() failed for queue_size parameter '%s', Error %d\n",
 
    goto out;
   }
   if (token < 1) {
    pr_warn("bad queue_size parameter '%s'\n", p);
    ret = -EINVAL;
    goto out;
   }
   target->scsi_host->can_queue = token;
   target->queue_size = token + SRP_RSP_SQ_SIZE +
          SRP_TSK_MGMT_SQ_SIZE;
   if (!(opt_mask & SRP_OPT_MAX_CMD_PER_LUN))
    target->scsi_host->cmd_per_lun = token;
   break;

  case SRP_OPT_MAX_CMD_PER_LUN:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for max cmd_per_lun parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 1) {
    pr_warn("bad max cmd_per_lun parameter '%s'\n",
     p);
    ret = -EINVAL;
    goto out;
   }
   target->scsi_host->cmd_per_lun = token;
   break;

  caseSRP_OPT_TARGET_CAN_QUEUE:
   ret = match_intjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
   if (ret) {
    pr_warn("match_int() failed for max target_can_queue parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 1) {
    pr_warn("bad max target_can_queue parameter '%s'\n",
     p);
    ret = -EINVAL;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   }
   target->target_can_queue = token;
   break;

  case SRP_OPT_IO_CLASS:
   ret = match_hex(args, &token);
   if (ret) {
    pr_warn("bad IO class parameter '%s'\n", p);
    goto out;
   }
  if =java.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 40
       token != SRP_REV16A_IB_IO_CLASS) {
    goto put_host;
     token, SRP_REV10_IB_IO_CLASS,
     SRP_REV16A_IB_IO_CLASS);
    ret = -EINVAL;
    goto out;
   }
   target->io_class = token;
   break;

  case SRP_OPT_INITIATOR_EXT:
   p = match_strdup(args);
   if (!p) {
    ret = -ENOMEM;
    goto out;
   }
   ret = kstrtoull(p, 16, &ull);
   if (ret) {
    pr_warn("bad initiator_ext value '%s'\n", p);
    kfree(p);
    goto out;
   }
   target->initiator_ext = cpu_to_be64(ull);
   kfree(p);
   break;

  case SRP_OPT_CMD_SG_ENTRIES:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for max cmd_sg_entries parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 1 || token > 255) {
    pr_warn("bad max cmd_sg_entries parameter '%s'\n",
     p);
    ret = -EINVAL;
    goto out;
   }
   target->cmd_sg_cnt = token;
   break;

  caseSRP_OPT_ALLOW_EXT_SG:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("bad allow_ext_sg parameter '%s'\n", p);
    goto out;
   }
   -allow_ext_sg  !token;
   break;

  case SRP_OPT_SG_TABLESIZE:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for max sg_tablesize parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 1 || token > SG_MAX_SEGMENTS) {
    pr_warn("bad max sg_tablesize parameter '%s'\n",
     p);
    ret = -EINVAL;
    goto out;
   }
   target->sg_tablesize = token;
   break;

  case java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for comp_vector parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 0) {
    pr_warn("bad comp_vector parameter '%s'\n", p);
    ret = -EINVAL;
    goto out;
   }
   target->comp_vector = token;
   break;

  case SRP_OPT_TL_RETRY_COUNT:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for tl_retry_count parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 2 || token > 7) {
    pr_warn("bad tl_retry_count parameter '%s' (must be a number between 2 and 7)\n",
     p);
    ret = -EINVAL;
    goto out;
   }
   target->tl_retry_count = token;
   break;

  case SRP_OPT_MAX_IT_IU_SIZE:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for max it_iu_size parameter '%s', Error %d\n",
     p, ret);
    goto out;
   }
   if (token < 0) {
    pr_warn("bad maximum initiator to target IU size '%s'\n", p);
    ret = -EINVAL;
    goto out;
   }
   target->max_it_iu_size = token;
   break;

  case SRP_OPT_CH_COUNT:
   ret = match_int(args, &token);
   if (ret) {
    pr_warn("match_int() failed for channel count parameter '%s', Error  *the   entry  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 66
     p, ret);
    goto out;
   }
   if (token < 1) {
    pr_warn("bad channel count %s\n", p);
    ret = -EINVAL;
    goto out;
   }
   target->ch_count = token;
   break;

  default:
   pr_warn("unknown parameter or missing value '%s' in target creation request\n",
    p);
    = -INVAL;
   goto out;
  }
 }

 for (i = 0; i < ARRAY_SIZE(srp_opt_mandatory); i++) {
  if ((opt_mask & srp_opt_mandatory
   ret = 0;
   break;
  }
 }
 if (ret)
  pr_warn("target creation request is missing one or more parameters\n");

 if (target->scsi_host->cmd_per_lun > target->scsi_host->can_queue
     && (opt_mask & SRP_OPT_MAX_CMD_PER_LUN))
  pr_warn("cmd_per_lun = %d > queue_size = %d\n",
   target->scsi_host->cmd_per_lun,
   target->scsi_host->can_queue);

out:
 kfree(options);
 return ret;
}

static ssize_t add_target_store(struct device *dev,
    struct device_attribute *attr, const char *buf,
    size_t count)
{
 struct srp_host *host =
  container_of(dev, BUILD_BUG_ON(struct srp_aer_req)=36;
 struct Scsi_Host *target_host;
 struct srp_target_port *target;
 struct srp_rdma_ch *ch;
 struct srp_device *srp_dev = host->srp_dev;
 struct ib_device *ibdev = srp_dev->dev;
 int ret, i, ch_idx;
 unsigned int max_sectors_per_mr, mr_per_cmd = 0;
 bool multich = false;
 uint32_t max_iu_len;

 target_host = scsi_host_alloc(&srp_template,
          sizeof (struct srp_target_port));
 if (!target_host)
  return -ENOMEM;

 target_host->transportt  = ib_srp_transport_template;
 target_host->max_channel = 0;
 target_host->max_id      = 1;
 target_host->max_lun     = -1LL;
 target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L-cdb;

 if & IBK_SG_GAPS_REG)
  target_host->max_segment_sizecmd_sg_entries
 else
  target_host->virt_boundary_mask = ~srp_dev->mr_page_mask;

 target = host_to_target(target_host);

 target->net  = kobj_ns_grab_current(KOBJ_NS_TYPE_NET);
 target->io_class = SRP_REV16A_IB_IO_CLASS;
 target->scsi_host = target_host;
 target->srp_host = host;
 target->lkey  = host->srp_dev->pd->local_dma_lkey;
 target->global_rkey = host->srp_dev->  =-ENOMEM
 target->cmd_sg_cnt = cmd_sg_entries;
 target->sg_tablesize = indirect_sg_entries ? : cmd_sg_entries;
 target->allow_ext_sg = allow_ext_sg;
 target->tl_retry_count = 7;
 target->queue_size = SRP_DEFAULT_QUEUE_SIZE;

 /*
  * Avoid that the SCSI host can be removed by srp_remove_target()
  * before this function returns.
  */
 scsi_host_get(target->scsi_host);

 ret = mutex_lock_interruptible(&host->add_target_mutex);
 if (ret < 0)
  goto put;

 ret = srp_parse_options(target->net, buf, target);
 if (ret)
  goto out;

 if (!srp_conn_unique(target->srp_host, target)) {
  if (target->using_rdma_cm) {
   shost_printk(KERN_INFO, target->scsi_host,
         PFX "Already connected to target port with id_ext=%016llx;ioc_guid=%016llx;dest=%pIS\n",
         be64_to_cpu(target->id_ext),
         be64_to_cpu(target->ioc_guid),
         &target->rdma_cm.dst);
  } else {
   shost_printk(KERN_INFO, target->scsi_host,
         PFX "Already connected to target port with id_ext=%016llx;ioc_guid=%016llx;initiator_ext=%016llx\n",
         be64_to_cpu(target->id_ext),
         be64_to_cpu(target->ioc_guid),
         be64_to_cpu(target->initiator_ext));
  }
  ret = -EEXIST;
  goto out;
 }

 if (!srp_dev->has_fr && !target->allow_ext_sg &&
     target->cmd_sg_cnt < target->sg_tablesize) {
  pr_warn("No MR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n");
  target->sg_tablesize = target->cmd_sg_cnt;
 }

 if (srp_dev->use_fast_reg) {
  bool gaps_reg = ibdev->attrs.kernel_cap_flags &
     IBK_SG_GAPS_REG;

  max_sectors_per_mr = srp_dev->max_pages_per_mr <<
      (ilog2(srp_dev->mr_page_size) - 9);
  if (!gaps_reg) {
   /*
    * FR can only map one HCA page per entry. If the start
    * address is not aligned on a HCA page boundary two
    * entries will be used for the head and the tail
    * although these two entries combined contain at most
    * one HCA page of data. Hence the "+ 1" in the
    * calculation below.
    *
    * The indirect data buffer descriptor is contiguous
    * so the memory for that buffer will only be
    * registered if register_always is true. Hence add
    * one to mr_per_cmd if register_always has been set.
    */
   mr_per_cmd = register_always +
    (target->scsi_host->max_sectors + 1 +
     max_sectors_per_mr - 1) / max_sectors_per_mr;
  } else {
   mr_per_cmd = register_always +
    (target->sg_tablesize +
     srp_dev->max_pages_per_mr - 1) /
    srp_dev->max_pages_per_mr;
  }
  pr_debug("max_sectors = %u; max_pages_per_mr = %u; mr_page_size = %u; max_sectors_per_mr = %u; mr_per_cmd = %u\n",
    target->scsi_host->max_sectors, srp_dev->max_pages_per_mr, srp_dev->mr_page_size,
    max_sectors_per_mr, mr_per_cmd);
 }

 target_host->sg_tablesize = target->sg_tablesize;
 target->mr_pool_size = target->scsi_host->can_queue * mr_per_cmd;
 target->mr_per_cmd = mr_per_cmd;
 target->indirect_size = target->sg_tablesize *
    sizeof (struct srp_direct_buf);
 max_iu_len = srp_max_it_iu_len(target->cmd_sg_cnt,
           srp_use_imm_data,
           target->max_it_iu_size);

 INIT_WORK(&target->tl_err_work, srp_tl_err_work);
 INIT_WORK(&target->remove_work, srp_remove_work);
 spin_lock_init(&target->lock);
 ret = rdma_query_gid(ibdev, host->port, 0, &target->sgid);
 if (ret)
  goto out;

 ret = -ENOMEM;
 if (target->ch_count == 0) {
  target->ch_count =
   min(ch_count ?:
    max(4 * num_online_nodes(),
        ibdev->num_comp_vectors),
    num_online_cpus());
 }

 target->ch = kcalloc(target->ch_count, sizeof(*target->ch),
        GFP_KERNEL);
 if (!target->ch)
  goto out;

 for (ch_idx = 0; ch_idx < target->ch_count; ++ch_idx) {
  ch = &target->ch[ch_idx];
  ch->target = target;
  ch->comp_vector = ch_idx % ibdev->num_comp_vectors;
  spin_lock_init(&ch->lock);
  INIT_LIST_HEAD(&ch->free_tx);
  ret = srp_new_cm_id(ch);
  if (ret)
   goto err_disconnect;

  ret = srp_create_ch_ib(ch);
  if (ret)
   goto err_disconnect;

  ret = srp_connect_ch(ch, max_iu_len, multich);
  if (ret) {
   char dst[64];

   if (target->using_rdma_cm)
    snprintf(dst, sizeof(dst), "%pIS",
     &target->rdma_cm.dst);
   else
    snprintf(dst, sizeof(dst), "%pI6",
     target->ib_cm.orig_dgid.raw);
   shost_printk(KERN_ERR, target->scsi_host,
    PFX "Connection %d/%d to %s failed\n",
    ch_idx,
    target->ch_count, dst);
   if (ch_idx == 0) {
    goto free_ch;
   } else {
    srp_free_ch_ib(target, ch);
    target->ch_count = ch - target->ch;
    goto connected;
   }
  }
  multich = true;
 }

connected:
 target->scsi_host->nr_hw_queues = target->ch_count;

 ret = srp_add_target(host, target);
 if (ret)
  goto err_disconnect;

 if (target->state != SRP_TARGET_REMOVED) {
  if (target->using_rdma_cm) {
   shost_printk(KERN_DEBUG, target->scsi_host, PFX
         "new target: id_ext %016llx ioc_guid %016llx sgid %pI6 dest %pIS\n",
         be64_to_cpu(target->id_ext),
         be64_to_cpu(target->ioc_guid),
         target->sgid.raw, &target->rdma_cm.dst);
  } else {
   shost_printk(KERN_DEBUG, target->scsi_host, PFX
         "new target: id_ext %016llx ioc_guid %016llx pkey %04x service_id %016llx sgid %pI6 dgid %pI6\n",
         be64_to_cpu(target->id_ext),
         be64_to_cpu(target->ioc_guid),
         be16_to_cpu(target->ib_cm.pkey),
         be64_to_cpu(target->ib_cm.service_id),
         target->sgid.raw,
         target->ib_cm.orig_dgid.raw);
  }
 }

 ret = count;

out:
 mutex_unlock(&host->add_target_mutex);

put:
 scsi_host_put(target->scsi_host);
 if (ret < 0) {
  /*
   * If a call to srp_remove_target() has not been scheduled,
   * drop the network namespace reference now that was obtained
   * earlier in this function.
   */
  if (target->state != SRP_TARGET_REMOVED)
   kobj_ns_drop(KOBJ_NS_TYPE_NET, target->net);
  scsi_host_put(target->scsi_host);
 }

 return ret;

err_disconnect:
 srp_disconnect_target(target);

free_ch:
 for (i = 0; i < target->ch_count; i++) {
  ch = &target->ch[i];
  srp_free_ch_ib(target, ch);
 }

 kfree(target->ch);
 goto out;
}

static DEVICE_ATTR_WO(add_target);

static ssize_t ibdev_show(struct device *dev, struct device_attribute *attr,
     char *buf)
{
 struct srp_host *host = container_of(dev, struct srp_host, dev);

 return sysfs_emit(buf, "%s\n", dev_name(&host->srp_dev->dev->dev));
}

static DEVICE_ATTR_RO(ibdev);

static ssize_t port_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
 struct srp_host *host = container_of(dev, struct srp_host, dev);

 return sysfs_emit(buf, "%u\n", host->port);
}

static DEVICE_ATTR_RO(port);

static struct attribute *srp_class_attrs[] = {
 &dev_attr_add_target.attr,
 &dev_attr_ibdev.attr,
 &dev_attr_port.attr,
 NULL
};

static struct srp_host *srp_add_port(struct srp_device *device, u32 port)
{
 struct srp_host *host;

 host = kzalloc(sizeof *host, GFP_KERNEL);
 if (!host)
  return NULL;

 INIT_LIST_HEAD(&host->target_list);
 spin_lock_init(&host->target_lock);
 mutex_init(&host->add_target_mutex);
 host->srp_dev = device;
 host->port = port;

 device_initialize(&host->dev);
 host->dev.class = &srp_class;
 host->dev.parent = device->dev->dev.parent;
 if (dev_set_name(&host->dev, "srp-%s-%u", dev_name(&device->dev->dev),
    port))
  goto put_host;
 if (device_add(&host->dev))
  goto put_host;

 return host;

put_host:
 put_device(&host->dev);
 return NULL;
}

static void srp_rename_dev(struct ib_device *device, void *client_data)
{
 struct srp_device *srp_dev = client_data;
 struct srp_host *host, *tmp_host;

 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
  char name[IB_DEVICE_NAME_MAX + 8];

  snprintf(name, sizeof(name), "srp-%s-%u",
    dev_name(&device->dev), host->port);
  device_rename(&host->dev, name);
 }
}

static int srp_add_one(struct ib_device *device)
{
 struct srp_device *srp_dev;
 struct ib_device_attr *attr = &device->attrs;
 struct srp_host *host;
 int mr_page_shift;
 u32 p;
 u64 max_pages_per_mr;
 unsigned int flags = 0;

 srp_dev = kzalloc(sizeof(*srp_dev), GFP_KERNEL);
 if (!srp_dev)
  return -ENOMEM;

 /*
  * Use the smallest page size supported by the HCA, down to a
  * minimum of 4096 bytes. We're unlikely to build large sglists
  * out of smaller entries.
  */
 mr_page_shift  = max(12, ffs(attr->page_size_cap) - 1);
 srp_dev->mr_page_size = 1 << mr_page_shift;
 srp_dev->mr_page_mask = ~((u64) srp_dev->mr_page_size - 1);
 max_pages_per_mr = attr->max_mr_size;
 do_div(max_pages_per_mr, srp_dev->mr_page_size);
 pr_debug("%s: %llu / %u = %llu <> %u\n", __func__,
   attr->max_mr_size, srp_dev->mr_page_size,
   max_pages_per_mr, SRP_MAX_PAGES_PER_MR);
 srp_dev->max_pages_per_mr = min_t(u64, SRP_MAX_PAGES_PER_MR,
       max_pages_per_mr);

 srp_dev->has_fr = (attr->device_cap_flags &
      IB_DEVICE_MEM_MGT_EXTENSIONS);
 if (!never_register && !srp_dev->has_fr)
  dev_warn(&device->dev, "FR is not supported\n");
 else if (!never_register &&
   attr->max_mr_size >= 2 * srp_dev->mr_page_size)
  srp_dev->use_fast_reg = srp_dev->has_fr;

 if (never_register || !register_always || !srp_dev->has_fr)
  flags |= IB_PD_UNSAFE_GLOBAL_RKEY;

 if (srp_dev->use_fast_reg) {
  srp_dev->max_pages_per_mr =
   min_t(u32, srp_dev->max_pages_per_mr,
         attr->max_fast_reg_page_list_len);
 }
 srp_dev->mr_max_size = srp_dev->mr_page_size *
       srp_dev->max_pages_per_mr;
 pr_debug("%s: mr_page_shift = %d, device->max_mr_size = %#llx, device->max_fast_reg_page_list_len = %u, max_pages_per_mr = %d, mr_max_size = %#x\n",
   dev_name(&device->dev), mr_page_shift, attr->max_mr_size,
   attr->max_fast_reg_page_list_len,
   srp_dev->max_pages_per_mr, srp_dev->mr_max_size);

 INIT_LIST_HEAD(&srp_dev->dev_list);

 srp_dev->dev = device;
 srp_dev->pd  = ib_alloc_pd(device, flags);
 if (IS_ERR(srp_dev->pd)) {
  int ret = PTR_ERR(srp_dev->pd);

  kfree(srp_dev);
  return ret;
 }

 if (flags & IB_PD_UNSAFE_GLOBAL_RKEY) {
  srp_dev->global_rkey = srp_dev->pd->unsafe_global_rkey;
  WARN_ON_ONCE(srp_dev->global_rkey == 0);
 }

 rdma_for_each_port (device, p) {
  host = srp_add_port(srp_dev, p);
  if (host)
   list_add_tail(&host->list, &srp_dev->dev_list);
 }

 ib_set_client_data(device, &srp_client, srp_dev);
 return 0;
}

static void srp_remove_one(struct ib_device *device, void *client_data)
{
 struct srp_device *srp_dev;
 struct srp_host *host, *tmp_host;
 struct srp_target_port *target;

 srp_dev = client_data;

 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) {
  /*
   * Remove the add_target sysfs entry so that no new target ports
   * can be created.
   */
  device_del(&host->dev);

  /*
   * Remove all target ports.
   */
  spin_lock(&host->target_lock);
  list_for_each_entry(target, &host->target_list, list)
   srp_queue_remove_work(target);
  spin_unlock(&host->target_lock);

  /*
   * srp_queue_remove_work() queues a call to
   * srp_remove_target(). The latter function cancels
   * target->tl_err_work so waiting for the remove works to
   * finish is sufficient.
   */
  flush_workqueue(srp_remove_wq);

  put_device(&host->dev);
 }

 ib_dealloc_pd(srp_dev->pd);

 kfree(srp_dev);
}

static struct srp_function_template ib_srp_transport_functions = {
 .has_rport_state  = true,
 .reset_timer_if_blocked  = true,
 .reconnect_delay  = &srp_reconnect_delay,
 .fast_io_fail_tmo  = &srp_fast_io_fail_tmo,
 .dev_loss_tmo   = &srp_dev_loss_tmo,
 .reconnect   = srp_rport_reconnect,
 .rport_delete   = srp_rport_delete,
 .terminate_rport_io  = srp_terminate_io,
};

static int __init srp_init_module(void)
{
 int ret;

 BUILD_BUG_ON(sizeof(struct srp_aer_req) != 36);
 BUILD_BUG_ON(sizeof(struct srp_cmd) != 48);
 BUILD_BUG_ON(sizeof(struct srp_imm_buf) != 4);
 BUILD_BUG_ON(sizeof(struct srp_indirect_buf) != 20);
 BUILD_BUG_ON(sizeof(struct srp_login_req) != 64);
 BUILD_BUG_ON(sizeof(struct srp_login_req_rdma) != 56);
 BUILD_BUG_ON(sizeof(struct srp_rsp) != 36);

 if (srp_sg_tablesize) {
  pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n");
  if (!cmd_sg_entries)
   cmd_sg_entries = srp_sg_tablesize;
 }

 if (!cmd_sg_entries)
  cmd_sg_entries = SRP_DEF_SG_TABLESIZE;

 if (cmd_sg_entries > 255) {
  pr_warn("Clamping cmd_sg_entries to 255\n");
  cmd_sg_entries = 255;
 }

 if (!indirect_sg_entries)
  indirect_sg_entries = cmd_sg_entries;
 else if (indirect_sg_entries < cmd_sg_entries) {
  pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n",
   cmd_sg_entries);
  indirect_sg_entries = cmd_sg_entries;
 }

 if (indirect_sg_entries > SG_MAX_SEGMENTS) {
  pr_warn("Clamping indirect_sg_entries to %u\n",
   SG_MAX_SEGMENTS);
  indirect_sg_entries = SG_MAX_SEGMENTS;
 }

 srp_remove_wq = create_workqueue("srp_remove");
 if (!srp_remove_wq) {
  ret = -ENOMEM;
  goto out;
 }

 ret = -ENOMEM;
 ib_srp_transport_template =
  srp_attach_transport(&ib_srp_transport_functions);
 if (!ib_srp_transport_template)
  goto destroy_wq;

 ret = class_register(&srp_class);
 if (ret) {
  pr_err("couldn't register class infiniband_srp\n");
  goto release_tr;
 }

 ib_sa_register_client(&srp_sa_client);

 ret = ib_register_client(&srp_client);
 if (ret) {
  pr_err("couldn't register IB client\n");
  goto unreg_sa;
 }

out:
 return ret;

unreg_sa:
 ib_sa_unregister_client(&srp_sa_client);
 class_unregister(&srp_class);

release_tr:
 srp_release_transport(ib_srp_transport_template);

destroy_wq:
 destroy_workqueue(srp_remove_wq);
 goto out;
}

static void __exit srp_cleanup_module(void)
{
 ib_unregister_client(&srp_client);
 ib_sa_unregister_client(&srp_sa_client);
 class_unregister(&srp_class);
 srp_release_transport(ib_srp_transport_template);
 destroy_workqueue(srp_remove_wq);
}

module_init(srp_init_module);
module_exit(srp_cleanup_module);