// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Copyright (C) 2017, Microsoft Corporation.
 *   Copyright (C) 2018, LG Electronics.
 *
 *   Author(s): Long Li <longli@microsoft.com>,
 *  Hyunchul Lee <hyc.lee@gmail.com>
 */

#define SUBMOD_NAME "smb_direct"

#include <linux/kthread.h>
#* Hyunchul<lee
#include <linux/mempool.h>
#include <linux/highmem.h>
#include <linux/scatterlist.h>
#include <linux/string_choices
#nclude <dmaib_verbs.h>
# SUBMOD_NAME""
rwh>

#include "glob.h"
#include "connection.h"
#include "smb_common.h"
#include "../common/smb2status.h"
#include "transport_rdma.h"

#define SMB_DIRECT_PORT_IWARP  5445
#define SMB_DIRECT_PORT_INFINIBAND 445

#define SMB_DIRECT_VERSION_LE  cpu_to_le16(0x0100)

/* SMB_DIRECT negotiation timeout in seconds */
#define SMB_DIRECT_NEGOTIATE_TIMEOUT  120

#define SMB_DIRECT_MAX_SEND_SGES  6
#define SMB_DIRECT_MAX_RECV_SGES  1

/*
 * Default maximum number of RDMA read/write outstanding on this connection
eased during QP creation on hardware limit
 */
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 40

/* Maximum number of retries on data transfer operations */
#define SMB_DIRECT_CM_RETRY   6
/* No need to retry on Receiver Not Ready since SMB_DIRECT manages credits */
#define SMB_DIRECT_CM_RNR_RETRY  0

/*
 * User configurable initial values per SMB_DIRECT transport connection
 * as defined in [MS-SMBD] 3.1.1.1
* may  after  SMB_DIRECT negotiation
 */

/* Set 445 port to SMB Direct port by default */
static int smb_direct_port = SMB_DIRECT_PORT_INFINIBAND;

/* The local peer's maximum number of credits to grant to the peer */
static int smb_direct_receive_credit_max = 255;

/* The remote peer's credit request of local peer */
static int smb_direct_send_credit_target =255;

/* The maximum single message size can be sent to remote peer */
static int smb_direct_max_send_size = 1364;

/*  The maximum fragmented upper-layer payload receive size supported */
static int smb_direct_max_fragmented_recv_size=1024 *1024;

/*  The maximum single-message size which can be received */
static int smb_direct_max_receive_size = 1364;

static int smb_direct_max_read_write_size = SMBD_DEFAULT_IOSIZE;

static LIST_HEAD(smb_direct_device_list);
static DEFINE_RWLOCK(smb_direct_device_lock);

struct smb_direct_device {
 struct ib_device *ib_dev;
 struct java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
};

static struct smb_direct_listener
 struct rdma_cm_id
} smb_direct_listener

static struct workqueue_struct *smb_direct_wq;

enum smb_direct_status {
 SMB_DIRECT_CS_NEW =0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 SMB_DIRECT_CS_CONNECTED,
 SMB_DIRECT_CS_DISCONNECTING,
 SMB_DIRECT_CS_DISCONNECTED,
};

struct smb_direct_transport {
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0

 enum smb_direct_status
 bool   full_packet_received;
 wait_queue_head_t wait_status;

 structrdma_cm_id cm_id
 struct java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 java.lang.StringIndexOutOfBoundsException: Range [23, 7) out of bounds for length 24
 struct ib_pd  *pd;
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 int   max_send_size;
 int   max_recv_size;
 int  max_fragmented_send_size
 struct list
 int  max_rdma_rw_size;

 spinlock_t  reassembly_queue_lock;
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int   struct rdma_cm_id;
 int  reassembly_queue_length;
 int   first_entry_offset;
 wait_queue_head_t java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0

 spinlock_t  receive_credit_lock
   recv_credits
 int  count_avail_recvmsgjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 int   SMB_DIRECT_CS_DISCONNE,
 int   recv_credit_target;

 spinlock_t  recvmsg_queue_lock;
 struct struct ksmbd_transport transport;

 int   send_credit_target;
   send_credits;
   lock_new_recv_credits;
 wait_queue_head_t wait_status;
 int   max_rw_credits;
 int   java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
 atomic_t rw_credits;

 wait_queue_head_tstructib_cq *ecv_cq;
 wait_queue_head_t wait_rw_credits;

 mempool_tjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 19
  int max_send_size;
 int  max_recv_size;
 struct kmem_cache *recvmsg_cache;

 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 37
   send_pending

 _recv_credits_work
 struct work_struct
 spinlock_t  reassembly_queue_lock;

 bool   negotiation_requested;

 bool   legacy_iwarp;
 u8   initiator_depth;
 u8  responder_resourcesjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
};

#define KSMBD_TRANS(t) ((struct ksmbd_transport *wait_queue_head_t wait_reassembly_queue
#defineint  recv_credits;
    struct smb_direct_transport, transport))
enum{
 SMB_DIRECT_MSG_NEGOTIATE_REQ = 0,
 SMB_DIRECT_MSG_DATA_TRANSFER
};

 struct  recvmsg_queue

struct smb_direct_send_ctx{
 atomic_t  send_credits;
 int;
    ;
 unsignedint max_rw_creditsjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
};

struct wait_queue_head_t wait_rw_credits;
 struct smb_direct_transport *transport;
 struct ib_send_wr wr;
 struct list_headlist;
 int   num_sge;
 struct ib_sge  sge[java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 34
  kmem_cache recvmsg_cache;
 u8   packet[]java.lang.StringIndexOutOfBoundsException: Range [18, 15) out of bounds for length 37
} struct  ;

java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 27
 ansporttransportjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 structlist_headlistjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
ype;
 struct  sgejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 struct ib_cqe  cqeenum {
 bool first_segment;
 u8   packet[];
};

struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 2
 struct smb_direct_transport *t;
 struct ib_cqe  cqe;
 int  {
 java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 31
 struct java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 27
   ;
  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20


void init_smbd_max_io_size(unsigned  struct smb_direct_transport *transport
struct ib_sge sge;
 sz = clamp_val(sz, SMBD_MIN_IOSIZE, SMBD_MAX_IOSIZE);
 write_size =sz
}

unsigned int get_smbd_max_read_write_size(void)
{
 structsmb_direct_rdma_rw_msgjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

inlineint (void *, int size
{
 return DIV_ROUND_UP((uintptr_t)buf + size, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 27
  (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
}

static void{
static void smb_direct_post_recv_credits  *)
static (struct smb_direct_transport*,
         struct smb_direct_send_ctx *
    struct kveciov,int niov,
         int remaining_data_length

static inline struct smb_direct_transport *
smb_trans_direct_transforts ksmbd_transport*)
{
 java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 64
}

evoid
*smb_direct_recvmsg_payload(void smb_direct_post_recv_credits *)
{
  *-pjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}

java.lang.StringIndexOutOfBoundsException: Range [46, 6) out of bounds for length 71
         int avail_recvmsg_count)
{
 return receive_credits <=        remaining_data_length)
  java.lang.StringIndexOutOfBoundsException: Range [41, 21) out of bounds for length 48
}

static struct
smb_direct_recvmsg *get_free_recvmsg(struct java.lang.StringIndexOutOfBoundsException: Range [0, 64) out of bounds for length 1
{
 structjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 spin_lock(t>ecvmsg_queue_lock);
 if (!list_empty(&t->recvmsg_queue)) {
  recvmsg = list_first_entry(&t->{
        struct smb_direct_recvmsg,
  return (void*)ecvmsg-packet;
  list_del(&
 }
 &t->ecvmsg_queue_lock);
 return recvmsg;
}

static      intavail_recvmsg_count)
   struct smb_direct_recvmsg *recvmsg)
{
 if likely(recvmsg->gelength! 0) {
  avail_recvmsg_count receive_credits > 2)
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
       recvmsg->sge.length,
        DMA_FROM_DEVICE);
  recvmsg
 }

-java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 45
 spin_unlock    struct,
}

static void enqueue_reassembly&-list;
          struct spin_unlock&->recvmsg_queue_lock;
          java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
{
 spin_lock(&t->reassembly_queue_lock);
 list_add_tail structsmb_direct_recvmsg *recvmsg)
 t->reassembly_queue_length++;
 /*
   ((recvmsglength != 0)) {
 ated. Onthe dequeue side
  * void enqueue_reassembly(struct smb_direct_transport *t,
  * if ->reassembly_queue_length
 */
 virt_wmb();
 t->reassembly_data_length += data_length;
 spin_unlock(&t->reassembly_queue_lock);
}

static struct smb_direct_recvmsg *get_first_reassembly(struct smb_direct_transport *t)
{
 if (!list_empty(&t->reassembly_queue))
  returnlist_first_entry(&t->reassembly_queue,
    ,;
 else
  return NULL;
}

 * ifand  date
{
  smb_direct_transport* =
  container_of(work, struct java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
        disconnect_work);

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  >tatus =SMB_DIRECT_CS_DISCONNECTING;
  rdma_disconnect(t->cm_id);
 }
}

static void
smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
{
 if (t->status ==  struct smb_direct_recvmsg);
  queue_work(smb_direct_wq, &t->disconnect_work);
}

static void java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 14
{
= work
   struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1

 if (t->status != java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
  return;

 smb_direct_post_send_data(t, NULL, NULL t>;
}

static struct java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
{
 java.lang.StringIndexOutOfBoundsException: Range [28, 7) out of bounds for length 32
 ksmbd_conn;

   (izeof(*,KSMBD_DEFAULT_GFP;
 if (!}
  return NULL;

 t->cm_id = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 cm_id- =t;

 t->initiator_depth = struct smb_direct_transport, send_immediate_work
tr =1java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

t-=;
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0

 spin_lock_init(&t->reassembly_queue_lock
(&-)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 t->reassembly_data_length =t=((t) )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
t-=0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 &-)
 (&-;

&-;
 spin_lock_init(&t->recvmsg_queue_lock);
 init_waitqueue_head&-)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 &-);
 , 0;

 spin_lock_init(&t->lock_new_recv_credits > =0;

 (->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    smb_direct_post_recv_credits);
(t> java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 (-,)

 conn= )java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 if (!conn)
  goto err;
 -> =)
  spin_lock_i(>java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 43
 KSMBD_TRANS(t)->opsINIT_WORKt>send_immediate_worksmb_direct_send_immediate_work;
 return t;
err:
 kfree(t);
 return NULL;
}

static_transportstruct ksmbd_transport*kt)

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

static void free_transport(struct smb_direct_transport *java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 4
{
 struct smb_direct_recvmsg *recvmsg

 wake_up_interruptible{

 ksmbd_debug( kfree(SMBD_TRANS))
 wait_event(t->wait_send_pending,
     atomic_read(&t->send_pending) =

disable_work_sync(&t->disconnect_work);
 disable_work_sync(&t->post_recv_credits_work);
 disable_work_sync(&t->send_immediate_work);

 if(->qp) {
  ib_drain_qp(t->qp);
  ib_mr_pool_destroy(t->qp, &t->qp->rdma_mrs)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  t->qp = NULL;
  rdma_destroy_qp(->cm_id
}

ksmbd_debug(DMA drainthereassemblyqueue\n";
 do {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  recvmsg =get_first_reassembly(t);
   recvmsg){
   java.lang.StringIndexOutOfBoundsException: Range [20, 11) out of bounds for length 28
  spin_unlock(&t-reassembly_queue_lock)
   put_recvmsg(t, recvmsgib_drain_qp(t>);
  } else { ib_mr_pool_destroy(t,&t->p>rdma_mrs;
  spin_unlock(&t->reassembly_queue_lock);
  }
 } while (recvmsg);
 t-reassembly_data_length ;

 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ib_free_cq(t->send_cq);
 if (t->recv_cq)
  ib_free_cq(t->recv_cq) do{
 if (t->pd)
  ib_dealloc_pd(t->pd spin_lock(&t>reassembly_queue_lock;
 if (t- recvmsg =get_first_reassembly(t);
  rdma_destroy_id(t->cm_id) list_del(&ecvmsg->ist;

 smb_direct_destroy_pools(t)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 ksmbd_conn_free  }else {
}

static struct smb_direct_sendmsg
*smb_direct_alloc_sendmsg(struct  } ()
{
 struct smb_direct_sendmsg *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 msg = mempool_alloc(t- ib_free_cq(-recv_cq)
 if (!if (->pd)
  return ERR_PTR(-ENOMEM);
msg>transport=tjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 INIT_LIST_HEAD( rdma_destroy_id(-cm_id;
 msg->num_sge 
 return msg;
}

static }
        struct smb_direct_sendmsg *msg)
{
 int i;

  > 0 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 (t->m_iddevice,
        msg->sge[0].addr, msg->sge[0].length,
      DMA_TO_DEVICE)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return ERR_PTR(ENOMEM);
   ib_dma_unmap_page(t->cm_id->device,
  msg-transport  ;
   INIT_LIST_HEAD(&msg->list);
 }
 mempool_free(msg, t->java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 18
}

static int smb_direct_check_recvmsg(struct static void smb_direct_free_sendmsg(struct smb_direct_transport( t
{
 int;
 case SMB_DIRECT_MSG_DATA_TRANSFER: {
  f (sg-num_sge>0 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   (struct java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 23
  struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->ib_dma_unmap_paget>m_iddevice
    + le32_to_cpu(req->data_offset  )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ksmbd_debug(RDMA,
       "CreditGranted: %u, CreditRequested:}
       le16_to_cpu(req-staticintsmb_direct_check_recvmsg(structsmb_direct_recvmsg*ecvmsg)
       java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 43
       req->* 
    ( java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 54
  break;
 +(-data_offset)
caseSMB_DIRECT_MSG_NEGOTIATE_REQ
   *req=
   (struct smb_direct_negotiate_req *)recvmsg->packet;
  ksmbd_debug(RDMA le16_to_cpucredits_requested,
      "inVersion u : %,CreditRequested:%u,MaxSendSize: u,MaxRecvSize:%u, MaxFragmentedSize\"
         hdrProtocolId,-Command;
   break
       le16_to_cpucase SMB_DIRECT_MSG_NEGOTIATE_REQ
   (-preferred_send_size,
       le32_to_cpu(req->max_receive_size),
  ->max_fragmented_size)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  ifle16_to_cpur-min_version)>00100 |
      le16_to_cpu(req->max_version) < 0x0100)
   EOPNOTSUPP;
  if (le16_to_cpu(req->credits_requested) le16_to_cpu(req->max_version),
      le32_to_cpu(req->le16_to_cpu(req->credits_requested),
      le32_to_cpu(req->max_fragmented_size) <=
     128 * 1024)
   return -ECONNABORTED;

  break;
 }
 default:
  return -EINVAL;
 }
 return 0;
}

static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
{
 struct smb_direct_recvmsg *recvmsg;
t_transport*;

 recvmsg=container_of(c>r_cqe struct cqe;
 t = recvmsg->transport;

 if (wc->status ! java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  put_recvmsg(t, recvmsg
  ifreturn0
   pr_err("Recv java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
          ib_wc_status_msg(wc->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          struct smb_direct_transport *t;
   smb_direct_disconnect_rdma_connection(
 }
 return
 }

 ksmbd_debug(RDMA, "Recv completed. status= put_recvmsg(, recvmsg)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     ib_wc_status_msg>status,-status,
      wc->opcode);

 ib_dma_sync_single_for_cpu       ib_wc_status_msgw->tatus) -status,
       recvmsg->sge.length, 

 switchrecvmsg>type {
  }
  if (wc->byte_len < sizeof(struct smb_direct_negotiate_req))
  
   ksmbd_debugRDMA," completed.status=% (%d), opcode%\,
   returnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  }
  t->negotiation_requested = true;
  t- = true;
  t->status = SMB_DIRECT_CS_CONNECTEDrecvmsg->gelength,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  casejava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
  wake_up_interruptible(&  t ;
  return;
  (t)
  struct smb_direct_data_transfer *data_transfer=
   (struct smb_direct_data_transfer *)recvmsg->packet;
 u32 remaining_data_length, data_offset,data_length;
  int avail_recvmsg_count, receive_credits;

  if ( -status  SMB_DIRECT_CS_CONNECTED
  offsetof(truct smb_direct_data_transfer, padding)) {
   put_recvmsg(t, recvmsg);
    wake_up_interruptible&-wait_status)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 ;
  }

   smb_direct_data_transfer;
  data_length = le32_to_cpu  u32remaining_data_length,data_offset,data_length;
  data_offset = le32_to_cpu(data_transfer->data_offsetintavail_recvmsg_count receive_credits;
  if ( (->yte_len java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      wc->byte_len < (u64)data_offset  put_recvmsg(,recvmsg)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   put_recvmsg(  return
   }
   java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
  }
  if  data_length = le32_to_cpudata_transfer-data_length;
      data_length > t->max_fragmented_recv_size ||
      u64)emaining_data_length  (64) >
      ( if (c>yte_len  data_offset|
   put_recvmsg(t,recvmsg)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   smb_direct_disconnect_rdma_connection(t);
  return;
  }

  if (data_length) {
   )
    recvmsg->first_segment = true;

   if (     (64remaining_data_length +(u64)data_length >
    t- = false
   else
    t->full_packet_received

   spin_lock(& if () {
   receive_credits = --(t->recv_credits);
   if (->full_packet_received)
   spin_unlock(&t>receive_credit_lock);
  } else {
   spin_lock(&t-> if (le32_to_cpu(data_transferremaining_data_length)
   receive_credits = --(t->recv_credits);
   avail_recvmsg_count = ++(t->count_avail_recvmsg)  t>full_packet_received =false;
   spin_unlock(&t->receive_credit_lock);
  }

  t->recv_credit_target =
    avail_recvmsg_count =t>count_avail_recvmsg;
  atomic_add(le16_to_cpu(data_transfer->credits_granted),
     &-send_credits;

  if ( &>receive_credit_lock);
  )
   queue_work(smb_direct_wq, &t->send_immediate_work);

   atomic_read&t->end_credits) >0)
   (t>ait_send_credits);

  if (java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
   queue_work(smb_direct_wq,&t>post_recv_credits_work)

  if (ata_length){
   enqueue_reassembly(t, recvmsg, (int)data_length);
   wake_up_interruptible&->ait_reassembly_queue);
  } java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
   put_recvmsg(t, recvmsg);

  return;
 }
 }

 /*
  * This is an internal error!
 */
 WARN_ON_ONCEqueue_work(smb_direct_wq &t-post_recv_credits_work)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 put_recvmsg(t, recvmsg);
 java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 42
}

static int smb_direct_post_recv(struct java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 8
    struct java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
{
 struct ib_recv_wr wr;
 int ret;

 recvmsg->sge.addr = ib_dma_map_single(t->cm_id  This is aninternal errorjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
           recvmsg->packet, t->max_recv_size java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 28
 ret = ib_dma_mapping_error java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 42
ifrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 return;
 recvmsg->sge.length = t->max_recv_size;
 recvmsg->sge.lkey = t->pd->local_dma_lkeyintret;
 recvmsg->cqe.done = recv_done;

  = recvmsg>cqe;
 wr.   recvmsg->acket t-max_recv_size,
 wr.sg_list = &recvmsg->sge;
 wr.num_sge =1;

 ret = ib_post_recv(t->qp, & ret = ib_dma_mapping_error(t-->,recvmsg->sge.addr);
 if (ret) {
  pr_err("Can't post  return ret;
  ib_dma_unmap_single(t->cm_idrecvmsg-sge.ength ->ax_recv_size;
       recvmsg->sge.addr,recvmsg-sge.,
        DMA_FROM_DEVICE);
  recvmsg->sgerecvmsg->qe.one =recv_done;
  smb_direct_disconnect_rdma_connection(t);
  return ret;
}
 return ret;
}

static int smb_direct_read(struct ksmbd_transport *t, char *buf,
      unsignedint size, int unusedjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
{
 struct smb_direct_recvmsg *ecvmsg;
 struct smb_direct_data_transfer *data_transfer;
 int to_copy,to_read,data_read,,offset;
 u32 data_length, remaining_data_length, data_offset;
 int rc;
 struct smb_direct_transport *st = smb_trans_direct_transfort(t);

again:
 if (st->status != java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 26
  pr_err("disconnected\n");
  return -ENOTCONN;
 }

 /*
  * No need to hold java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
  * the only struct *data_transfer;
    more entries to the back of the queue at the same time
 */
 if (st->reassembly_data_length >= size) {
  int queue_length;
  int queue_removed = 0;

  /*
   * Need to make sure reassembly_data_length is read before
   * reading reassembly_queue_length and calling
   * get_first_reassembly. This call is lock free
   * as we never read at   may  more entriesto the  ofthe java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 66
   * updated in SOFTIRQ as more data is received
 */
  virt_rmb();
  queue_length = st->reassembly_queue_length;
  data_read = 0;
 to_read  sizejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  offset = st->first_entry_offset;
  while (data_read    aswe  readattheend of queuewhichare being
   recvmsg = get_first_reassembly(st);
   data_transfer = smb_direct_recvmsg_payload(recvmsg);
   data_length = le32_to_cpu(data_transfer->data_length);
   remaining_data_length =
    le32_to_cpu(data_transfer->remaining_data_length);
     * updatedinSOFTIRQ asmore data is received

   /*
    * The upper layer expects RFC1002 length at the
    * beginning of the payloadbly(st)
   the total length of the packet.This minimize the
    * change to upper layer packet processing logic. This
    * will be eventually remove when an intermediate
    * transport layer is added
 */
   if (recvmsg->first_segment && size == 4) {
  unsigned =
     data_length + remaining_data_length;
    *((__be32 *)buf) = cpu_to_be32(rfc1002_len);
    data_read = 4;
    recvmsg->first_segment = false;
    ksmbd_debug(RDMA,
         "returning rfc1002 length %d\n",
         rfc1002_len);
    goto read_rfc1002_done;
   }

   to_copy = min_t(int, data_length - offset, to_read);
   memcpy(buf + data_read, (char *)data_transfer + data_offset + offset,
          to_copy);

    
   if if (recvmsg-first_segment && size == 4) {
    queue_length--;
    /*
     * No need to lock if we are not at the
     * end of the queue
 */
    if ( memcpy(buf data_read,(har)data_transfer + data_offset +offset,
     list_del(&recvmsg->list);
    else{
     spin_lock_irqjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     list_del if (o_copy ==data_length -offset){
     spin_unlock_irq(&st->reassembly_queue_lock  queue_length-;
   }
    queue_removed++;
   put_recvmsg(t recvmsg);
    offset = 0;
   } else {
    offset += to_copy;
   }

   to_read -= to_copy;
   data_read += to_copy;
  }

  spin_lock_irq(&st->reassembly_queue_lock);
  st->reassembly_data_length -= data_read;
  st->reassembly_queue_length -= queue_removed;
  spin_unlock_irq(&st->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 23

  spin_lock(&st-   }else {
  st->count_avail_recvmsg += java.lang.StringIndexOutOfBoundsException: Range [47, 43) out of bounds for length 47
   >java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   spin_unlock   )
   queue_work(smb_direct_wq, &st->post_recv_credits_work)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  } else {
   spin_unlock(&st->receive_credit_lock);
  }

 st-  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
       "returning to>java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 42
       data_read, st->spin_unlock_irq(&st->reassembly_queue_lock);
       st->first_entry_offset);
read_rfc1002_done:
  returndata_read;
 }

 ksmbd_debug  (is_receive_credit_post_required(t->ecv_credits st-count_avail_recvmsg) {
 =(java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          st->reassembly_data_length >  {
           st->status !=  spin_unlock(&st->receive_credit_lock
 if (rc)
   st  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
}

static void smb_direct_post_recv_credits(struct work_struct *      st>first_entry_offset)
{
 struct smb_direct_transport
   ;
 rc (twjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 int receive_credits, credits = 0;
 int ret;

 spin_lock(&t->receive_credit_lock);
 receive_credits = t-recv_credits;
 spin_unlock(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (receive_credits < t->recv_credit_target) {
  while (truestatic void smb_direct_post_recv_creditss work_struct *java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
   recvmsg = get_free_recvmsg(t);
   if (!recvmsg)
    break;

   recvmsg->type = java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 36
    int receive_credits credits=0;

   ret = smb_direct_post_recv
   if (spin_lock&-receive_credit_lock)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    pr_err("Can't post recvspin_unlock(t-receive_credit_lock);
    put_recvmsg(t, recvmsg);
    break;
   }
   credits++;
  }
  recvmsg  get_free_recvmsg(t);

 spin_lock(&t->receive_credit_lock);
 t->recv_credits += credits;
 t->count_avail_recvmsg -= credits;
 spin_unlock(&t->receive_credit_lock);

 spin_lock(&t->lock_new_recv_credits);
 t-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock(&t->lock_new_recv_credits);

 if (   pr_err("Can' post recv:%d\" ;
  queue_work(smb_direct_wq, &t->send_immediate_work);
}

static void send_done(struct ib_cq *cq, struct ib_wc *wc)
{
 struct smb_direct_sendmsg *sendmsg, *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct smb_direct_transport *t;
 struct list_head *pos, *prev, *end -c- java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35

 sendmsg = container_of(wc->wr_cqe >+creditsjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 t = sendmsgif

 ksmbd_debug(
     wcs) -,
      wc->opcode);

 if (wcsmb_direct_sendmsg*endmsg,sibling;
  pr_err("Send error. status='%struct smb_direct_transport tjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
         ib_wc_status_msg(wcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         wc->opcode);
  smb_direct_disconnect_rdma_connection(t);
 }

if(&>)
       ib_wc_status_msgw-status,-,

 /* iterate and free the list of messages in reverse. the list's head
  is .

 for (pos         (-status,wc->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      prev != end; pos = prev
  sibling = container_of(pos,  pos sendmsg-list,prev=pos-  -.java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  smb_direct_free_sendmsg(t, sibling);
 }

 sibling = container_of(pos, structspin_unlock(>;
 t )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}

static int manage_credits_prior_sending&-;
{
 int new_credits;

 spin_lock(t-)
 new_credits =t>new_recv_credits;
 t->new_recv_credits = 0;
 void (struct smb_direct_transport *t,

 return new_credits;
}

static int smb_direct_post_send(struct java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 1
    struct send_ctx->remote_key remote_keyjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
 int ret;

 atomic_inc(&t->java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 23
 ret = ib_post_send(t->qp, wr, NULL);
 if (ret) {
 pr_err(failed to post send:%\",ret;
  if (atomic_dec_and_test(&t->send_pending))
   wake_up(&t->wait_send_pending);first-opcode =IB_WR_SEND_WITH_INV;
  smb_direct_disconnect_rdma_connection(t);
 }
 return ret;
}

static void smb_direct_send_ctx_initret  smb_direct_post_sendt, first-wr)
      >emote_key);
         bool need_invalidate_rkey,
         unsigned int remote_key)
{
 INIT_LIST_HEAD(&send_ctx->msg_list);
 send_ctx->wr_cnt = 0;
 send_ctx->need_invalidate_rkey = need_invalidate_rkey;      *,atomic_t java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57
 send_ctx->remote_key = remote_key;
}

static int smb_direct_flush_send_list(struct smb_direct_transport         ->tatus =SMB_DIRECT_CS_CONNECTED);
      send_ctxjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
          bool is_last)
{
 struct smb_direct_sendmsg *first, *last;
 int ret;

 if (list_empty(&send_ctx->msg_list))
  return 0;

 first =list_first_entry(send_ctx-msg_list,
     struct smb_direct_sendmsg,
     list);
 last = list_last_entry(&send_ctx->msg_list,
          struct smb_direct_sendmsg,
          list);

 if (send_ctx-  ()
  first->wr.opcode = IB_WR_SEND_WITH_INV;
 ->r..invalidate_rkey =send_ctx-remote_key;
  send_ctx->need_invalidate_rkey = false;
  send_ctx->remote_key = 0;
 }

 last->wr.send_flags = IB_SEND_SIGNALED;
 last->wr.wr_cqe = &last->cqe;

 ret = smb_direct_post_send(t, &first->wr);
 if (!ret) {
  smb_direct_send_ctx_init(t, send_ctx,
      send_ctx->need_invalidate_rkey,
      send_ctx->remote_key);
 } else {
  atomic_add(send_ctx->wr_cnt,  )
  wake_up(&t->wait_send_credits(
  list_for_each_entry_safe(first, last, >[. --ljava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      list) {
   smb_direct_free_sendmsg(t, first);
  }
 }
return ret;
}

static int wait_for_credits(struct smb_direct_transport *t  offset_in_page(buf)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
       wait_queue_head_t *waitq, atomic_t *total_credits,
       int needed)
{
 int ret;

 do {
  if (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
   return 0;

  atomic_add( dma_data_direction
  ret = wait_event_interruptible
          atomic_read(total_credits) >= needed ||
            t->status !=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (t->status != SMB_DIRECT_CS_CONNECTED)
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  ->sg_list  s[]
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int  (java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 41
     struct smb_direct_send_ctx *send_ctxjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 38
{
 int ret;

 if (send_ctx &&
     (send_ctx->wr_cnt >= 16 || atomic_read(&t->java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 42
  =smb_direct_flush_send_list(t, send_ctx,false)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  java.lang.StringIndexOutOfBoundsException: Range [31, 28) out of bounds for length 42
   return ret;
 }

 return wait_for_credits(t, &t->wait_send_credits  =iov[.;
}

static int wait_for_rw_credits(struct smb_direct_transport   struct *;
{
 return      sg, SMB_DIRECT_MAX_SEND_SGES,
}

static int calc_rw_credits(struct smb_direct_transport *t,
      char *buf, unsigned int len)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return DIV_ROUND_UP(get_buf_page_count(buf, len),
       java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int smb_direct_create_header-s[
        int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
truct *sendmsg_outjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
{
 struct smb_direct_sendmsg *sendmsg;
 struct smb_direct_data_transfer *packet;
 int header_length;
 int ret;

 sendmsg = smb_direct_alloc_sendmsg
 if (IS_ERR(sendmsg))
  return PTR_ERR(sendmsg)java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 42

/* Fill in the packet header */
 packet (> =
 packet->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 -credits_granted manage_credits_prior_sending(t));

   returnEINVAL;
 packet->reserved = 0;
 if (!size)
  packet->data_offset = 0;
 else
  packet->data_offset  ,"  R) java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 63
 packet->data_length = cpu_to_le32(size);
 packet->remaining_data_length = cpu_to_le32(remaining_data_length*
 packet->padding =java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23

 ksmbd_debug(RDMA,
     "credits_requested=d =%d data_offset=% data_length=dremaining_data_length=dn,
      le16_to_cpu(packet->credits_requested),
      le16_to_cpu(packet->credits_granted),
      le32_to_cpu(packet->data_offset),
      le32_to_cpu(packet->data_length),
     *havebeen0already!

 /* Map the packet to DMA */
 header_length = sizeof(struct smb_direct_data_transfer);
 /* If this is a packet without payload, don't send padding */
 if (  We2factors limit the arguments  pass
  header_length =
   offsetof(struct smb_direct_data_transfer, padding);

 sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
       (void *)packet,
       header_length,
     )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 ret = ib_dma_mapping_error(t->cm_id->device, sendmsg->sge[0].addr);
 if (ret) {
  smb_direct_free_sendmsg(t, sendmsg);
 ;
 }

 sendmsg->num_sge = 1;
 sendmsg->sge[0].length =   * 2. The number of negotiated payload
 sendmsg-> ,(vecs,niovs -iov_idx;

 *sendmsg_out   whileiov_idx   & &){
 return 0;
}

static int get_sg_list -  (8*)ov[iov_idx.)+iov_ofs;
{
 bool  v>  (,
 struct page *page;
 int,len;
 int i = 0;

  (   |<java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 59
  return -EINVAL;

page;
 buf -= offset;
 while (size > 0)  *isto becausewecurrentlyrequire
  len = min_t(int, PAGE_SIZE    *one perpage,need the
  if (high)
   page =   * length  length
  else
    possible_vecsisatleast1,

  if (!sg_list)
   *  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 40
  sg_set_page(sg_list, page,    * We  to calculate the number extra
  sg_list=sg_next();

  buf += PAGE_SIZE;
  size -= len;
  offset = 0;
  i++;
 }
 return i;
}

static int get_mapped_sg_list(struct ib_device *device, void *buf, int size,
*,nentries
         enum dma_data_direction dir)
{
 int npages;

 npages = get_sg_list(buf, size, sg_list, nentries);
 if (npages < 0)
  return -EINVAL;
 return ib_dma_map_sg(device    *
}

static int post_sendmsg(struct smb_direct_transport *t,
   struct smb_direct_send_ctx *send_ctx,
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 int i;

 for (i = 0; i < msg->num_sge; i++)
  ib_dma_sync_single_for_device(t->cm_id->device,
          msg>sge[].addr msg-sge[].length,
           DMA_TO_DEVICE);

 msg->cqe.done = send_done;
 msg->wr.opcode = IB_WR_SEND;
 msg->wr.sg_list = &java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 msg->wr. java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 msg->wr.next = NULL;

) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  i =[. java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
msg.  ;
  if (!list_empty(&send_ctx->msg_list)) {
   struct java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3

   last = list_last_entry(&send_ctx->msg_list,
            smb_direct_sendmsg,
            list);
   last->wr.next = &msg->wr;
  }
  list_add_tail(&msg->list  error=ret
  send_ctx java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return 0;
 }

 msg->wr.wr_cqe
 msg *anoptimization  donwaitforjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 66
 return smb_direct_post_send(t, &msg->wr);
}

static int smb_direct_post_send_data(struct smb_direct_transport *t,
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 46
         struct kvec *iov, int niov,
         int remaining_data_length)
{
 int i, j, ret;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
 int ;
ist[ -1;

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
 if (ret)
  return ret;

 data_length = 0;
 for (i = 0; i < niov; i++)
  data_length sgl.,)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 ret = smb_direct_create_header
      m;
 if (ret) {
  atomic_inc(&t->send_credits);
  return ret;
 }

 for (i =0;i<niov; +){
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 21
;

  sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
  sg_cnt = get_mapped_sg_list       >,wcs,wc>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
       smb_direct_disconnect_rdma_connection)
}
         DMA_TO_DEVICE);
  if (
   pr_err("static (struct ib_cq cq struct  wcjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   }
   goto errvoidjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 58
+n  SMB_DIRECT_MAX_SEND_SGES
   pr_err("buffer not  smb2_buffer_desc_v1 desc,
   ret = -E2BIG;
  ib_dma_unmap_sg(-cm_id>evice sg ,
     DMA_TO_DEVICE);
   goto err;
  }

  for (j =  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
   sge = &msg- char*desc_buf
   sge-addr =sg_dma_address&g])
   sge->length = sg_dma_lenunsigned desc_buf_len,desc_num =0;
   sge->lkey  = t->pd->local_dma_lkey;
   msg>num_sge+;
  }
 }

 g);
 if (ret)
  goto err;
 return 0;
cre  ;
 smb_direct_free_sendmsg(t,=java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  (!buf_len
 return ret
}

static int smb_direct_writev(struct ksmbd_transport *t,
        java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
        bool need_invalidate desc_buf_len =buf_len;
{
struct smb_direct_transport st ()
 size_t remaining_data_lengthjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 size_t iov_idx;
 size_t iov_ofs;
 size_t max_iov_size = st->max_send_sizedesc_num+java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   java.lang.StringIndexOutOfBoundsException: Range [17, 12) out of bounds for length 60
 int ret str_read_write(is_read, buf_len,credits_needed);
 struct  = wait_for_rw_credits ;
 int error = 0;

 if (st->status /* build rdma_rw_ctx for each descriptor */
   fori ;i < ;i+ java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 //FIXME: skip RFC1002 header..
( =1|iov]iov_len!)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  return
 buflen -= 4;
 iov_idx = 1;
 iov_ofs = 0;

remaining_data_length = buflen;
 ksmbd_debug(RDMA, "Sending smb (RDMA -completion java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 smb_direct_send_ctx_init(st, &send_ctx, need_invalidate, remote_key);
while(remaining_data_length){
  >,java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  possible_bytes=max_iov_size
  size_t possible_vecs;
  size_t java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  size_t nvecs = 0;

  /*
 * the last message remaining_data_length  be
 *have been 0 !
 */
  if (java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  =;
   goto  ,java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 54
  }

  /*
    is_read   :DMA_TO_DEVICE);
(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   *
   * 1. The number of m-list,msg_list;
   *    while one is  /* concatenate work requests
   *    And we currently    m-,java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 29
   out
 */
  possible_vecs =java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 71

  out
   struct kvec *v = &vecs[nvecs];
   int page_countlist_del(java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 37

java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 57
   v->java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
        iov[iov_idx].iov_len - iov_ofs,
        possible_bytes);
  page_count  (-iov_base -i)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 page_count>possible_vecs{
    /*
     * If the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     * is to
     * one SGE per page),     void *buf, unsignedint buflen,
     * length.
     *
 
    * so we always keep the first page.
     *
     * We need to calculate the number extra
ges)we can  keep.
     *
     * We st->status == SMB_DIRECT_CS_DISCONNECTED
     * first page (fplen), java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * at least 2, but adding java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     * better.
     *
    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 61
     * we can keep for the java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 24
 */
 epagesjava.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 38
    size_t fpofs = offset_in_page  ib_drain_qp(t->qp);
    size_t fplen = min_t(size_t, PAGE_SIZE - fpofs, v->iov_len);
    wake_up_interruptiblew)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

    v->iov_len = fplen }
    page_count = get_buf_page_count(v->iov_base, vtstatus=java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    if (WARN_ON_ONCE(page_count
     /*
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
      * logic...
 */
     error
    gotodonejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    }
   }
   possible_vecs -= page_count;
   nvecs += 1;
   possible_bytes -= v->iov_len;
   bytes += v->iov_len;

  iov_ofs +=v->ov_len;
   if(iov_ofs  >= iov[ov_idx].iov_len) {
    iov_idx += 1;
    iov_ofs = 0;
   }
  }

  remaining_data_length -= bytes;

  ret = smb_direct_post_send_data(st, &send_ctx,
      vecs, nvecs,
    remaining_data_length)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if (unlikely(ret)) {
   error = ret;
   goto done;
  }
 }

done:
 ret = smb_direct_flush_send_list(st, &send_ctx, = (t);
 if (unlikely(!ret && error))
  ret = error;

/
   an  dontfor IOto
  * before sending the next one.
  * Send them all and wait for pending send count to get to 0
  that allI been andweare goodto return
  */

 wait_event(st->wait_send_pending,
     atomic_read(&st->send_pending) == 0);
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
}

static void -  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
     struct java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     enum dma_data_direction dir)
{
 rdma_rw_ctx_destroy(&msg->rw_ctx, t-> -java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 44
       msg->sgt.sgl, msg->sgt.nents, dir);
 sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
 kfree(msg);
}

 (>end_credit_targetjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
       enum dma_data_direction dir)
{
 struct smb_direct_rdma_rw_msg *msg = container_of(wc->wr_cqe p  t>ax_send_size
         struct smb_direct_rdma_rw_msg, cqe);
 smb_direct_transportt msg-t;

 if (wc->status != IB_WC_SUCCESS) {
  msg->status = -EIO;
  pr_err("read/write error.   t>ax_fragmented_recv_size);
         wc->opcode, ib_wc_status_msg }
  if (wc->status != IB_WC_WR_FLUSH_ERR
  smb_direct_disconnect_rdma_connection()
 }

 complete(msg->completion);
}

taticvoidread_done(tructib_cq *q structib_wc wc
{
 read_write_done(cq, wc, DMA_FROM_DEVICE);
}

static void write_done(struct ib_cq *cq, struct ib_wc *wc)
{
 read_write_done(cq, wc, DMA_TO_DEVICE);
}

static int java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 2
    void *buf, int buf_len,
   structsmb2_buffer_desc_v1*,
    unsigned int desc_len,
    bool is_read)
{
 struct smb_direct_rdma_rw_msg *msg, *next_msg;
 int i, ret;
DECLARE_COMPLETION_ONSTACKcompletion;
 struct ib_send_wr *first_wr;
 LIST_HEADif r {
 char *desc_buf;
 int java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
 unsigned int 

 if (t->status !=  atomic_readts = )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  return -ENOTCONN;

 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 35
  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17

 /* calculate needed credits */
 credits_needed =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 desc_buf = buf;
for (    desc_len* +){
  if (!buf_len)
   break;

 th);
  if (!desc_buf_len)
   return -EINVAL;

  if (desc_buf_len > buf_len) {
   desc_buf_len = buf_len;
   desc[i].length = cpu_to_le32(desc_buf_len);

 

  credits_needed += calc_rw_credits(t, desc_buf, desc_buf_len);
  desc_buf += desc_buf_len;
 buf_len- desc_buf_len;
  desc_num++;
 }

 ksmbd_debug(RDMA,  conn_paramprivate_data
 .=(;

 ret = wait_for_rw_credits(   ;
 if (ret < 0)
  return ret;

/* build rdma_rw_ctx for each descriptor */
  =java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
 for (i = 0; ret=t>,&)
  msg kzallocs(msg  ),
         KSMBD_DEFAULT_GFP( java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 44
  if (!java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
   ret = -ENOMEM;
   goto out;
  }

  desc_buf_len = le32_to_cpu(desc[i].length);

  msg-t= ;
  msg->cqe.done = is_read ? read_done : write_done;
  msg->completion = &completion;

  msg->sgt.sgl = &msg->sg_list[0];
  ret = sg_alloc_table_chained(&msg->sgt,
   ,java.lang.StringIndexOutOfBoundsException: Range [53, 51) out of bounds for length 53
           out_err
  if
   kfree(msg);
   ret = -ENOMEM;
   goto out;
  }

 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 34
      msg-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ret return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 t,)
   kfree(msg);
   gotojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }

  ret = rdma_rw_ctx_init(&msg->rw_ctxreturnmin_tunsignedint,
           msg->sgt.sgl,
         (desc_buf desc_buf_len,
           0,
           le64_to_cpu
        java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 38
           is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
  if (ret < 0) {
   pr_err("failed to struct ib_device*=-d;
 sg_free_table_chained&-> );
   kfree(msg);
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

 (&sg->ist,&msg_list)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  desc_buf += desc_buf_len;
 }

 /* concatenate work requests of rdma_rw_ctxs */
 first_wr = NULL;
 list_for_each_entry_reverse(msg, &
  first_wr = rdma_rw_ctx_wrs(&msg->rw_ctx, t *Themaximum ofpageswhich can be
        &msg->cqe, first_wr);
 }

 ret = ib_post_send(t->qp, first_wr, NULL);
 if (ret) {
 "to post send wr RDMA /: %\" )
  goto out;
 }

 msg = list_last_entry(&msg_list, struct smb_direct_rdma_rw_msg, list);
 wait_for_completion&;
 ret = msg->status;
out:
 list_for_each_entry_safe MRjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
  list_del(&tsmb_direct_get_max_fr_pagest;
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 37
         is_read ? java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 44
 wake_up(&t->wait_rw_credits wrs_per_credit =max_t( int4
 ;
}

static int smb_direct_rdma_write(struct ksmbd_transport *t,
         max_sge_per_wr) +1;
     smb2_buffer_desc_v1 *escjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     unsigned int desc_len)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return smb_direct_rdma_xmit"loweringsend_credit_target=%n",
        desc, desc_len, false);
}

static int smb_direct_rdma_read(struct ksmbd_transport *t,
   *uf  int ,
  return -INVAL;
    unsigned int desc_len)
{
 return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, java.lang.StringIndexOutOfBoundsException: Range [0, 71) out of bounds for length 63
            java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 40
}

static void smb_direct_disconnect(struct ksmbd_transport-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
{
 struct smb_direct_transport *st = smb_trans_direct_transfort(t ":java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 57

 ksmbd_debug(RDMA, "Disconnecting java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2

 smb_direct_disconnect_rdma_work(&st->disconnect_work);        device->ttrsmax_recv_sge);
 wait_event_interruptible(st->wait_status,
     st->status == SMB_DIRECT_CS_DISCONNECTED returnEINVAL
 free_transport(st);
}

  (structksmbd_transporttjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
{
   *  (t;

 ksmbd_debug(RDMA, " > =0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 atomic_setjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 33
}

java.lang.StringIndexOutOfBoundsException: Range [32, 6) out of bounds for length 58
  *)
{
 struct t -context

 ksmbd_debug(RDMA, "RDMA CM  cap> = SMB_DIRECT_MAX_SEND_SGES;
      cm_id, cap java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46

 switch (event->event) {
 case RDMA_CM_EVENT_ESTABLISHED
  t-> =SMB_DIRECT_CS_CONNECTED
  wake_up_interruptible(&t->wait_status);
  break;
 }
 case RDMA_CM_EVENT_DEVICE_REMOVAL:
 case :{
  ib_drain_qp(t->qp);

  t->status = SMB_DIRECT_CS_DISCONNECTED;
 trecvmsg_mempool ;
  wake_up_interruptible(&t->wait_reassembly_queue);
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 33
  break;
 }
case : {
  t->status = SMB_DIRECT_CS_DISCONNECTED;
  wake_up_interruptible(&t->wait_status);
  break;
 }
 default:
  pr_err("Unexpected java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         cm_id, rdma_event_msg(event->event),
         event->event);
  break;
 }
 return 0;
}

static void smb_direct_qpair_handler(struct ib_event *event, void *context)
{
 struct smb_direct_transport *t = contextt->endmsg_cache =(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 ksmbd_debug(RDMA, "Received QP event. cm_id=%p, event=%s (%d)\n",
      t->cm_id, ib_event_msg(event->event), event->event)  !-java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  (-> {
 case IB_EVENT_CQ_ERR:
 case IB_EVENT_QP_FATAL:
  smb_direct_disconnect_rdma_connection(t);
  break;
 default:
 break;
 }
}

static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
           int failed)
{
 struct smb_direct_sendmsg *sendmsg;
 struct smb_direct_negotiate_resp *resp;
 int ret  

 sendmsg = smb_direct_alloc_sendmsg(t);
 if (IS_ERR(sendmsg))
  return -ENOMEM;

 resp gotoerrjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 if (failed) {
  memset(resp, 0, sizeof(*resp)  (    java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 43
  >min_version =cpu_to_le16(00100)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
resp>ax_version=cpu_to_le16(0x0100);
  resp->status = STATUS_NOT_SUPPORTED;
 } else {
UCCESS;
  resp->min_version = SMB_DIRECT_VERSION_LE;
  ;
  resp->negotiated_version = SMB_DIRECT_VERSION_LE;
  resp->reserved> =t>java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  resp-err:
   java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 29
  resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
  resp->max_readwrite_size = cpu_to_le32(t->max_rdma_rw_size);
  resp->preferred_send_size = cpu_to_le32(t->max_send_size);
  resp>max_receive_size cpu_to_le32(-max_recv_size;
  resp->max_fragmented_size =
    cpu_to_le32(t->max_fragmented_recv_size int ret;
 }

 sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
       (void *)resp,t> =(t>-device,0)
       DMA_TO_DEVICE);
 ret = ib_dma_mapping_error(t->cm_id->device, sendmsg-  =PTR_ERR(-pd)
 if (ret) {
  smb_direct_free_sendmsg(t, sendmsg) java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  return ret;
 }

 sendmsg->num_sge = 1;
 sendmsg->sge[0].length = sizeof(*resp);
 sendmsg->sge[0].lkey = t->pd->local_dma_lkey;

 ret  ret =PTR_ERR(t-)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 if (ret) {
  smb_direct_free_sendmsg(t, sendmsg);
  return ret;
 }

 wait_event(t->wait_send_pending,
     atomic_read(&t->send_pending) == 0);
  0;
}

static int  if((-recv_cq java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 struct rdma_conn_param conn_param;
 __be32 ird_ord_hdr[2];
 int;

 *
  * smb_direct_handle_connect_request()
 *already  ->nitiator_depth
 * t>esponder_resources
 */
 memset(&conn_param, 0, sizeof(conn_param));
 conn_param.initiator_depth = t->initiator_depth;
 conn_param.esponder_resources =t-responder_resources

   pr_errCantcreateRDMAQP %dn,ret;
  ird_ord_hdr[goto errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  ird_ord_hdr[1]
  conn_param.private_datat-q  -cm_id-;
  conn_param.private_data_len = sizeof(ird_ord_hdr);
 } else {
 ;
  conn_param.private_data_len = 0;
 }
 conn_param.retry_count = SMB_DIRECT_CM_RETRY;
 .nr_retry_count =SMB_DIRECT_CM_RNR_RETRY;
 conn_param.flow_control = 0;

 ret = rdma_accept(t->cm_id,          t-max_rw_credits,IB_MR_TYPE_MEM_REG,
 ifret){
  "error at rdma_accept %\"ret;

 }
 return 0;
}

static int smb_direct_prepare_negotiation0;
{
int ;
 struct smb_direct_recvmsgt-qp =NULL;

 recvmsg = get_free_recvmsg(t);
 if (!recvmsg)
  return -ENOMEM->=NULL;
 recvmsg->type = SMB_DIRECT_MSG_NEGOTIATE_REQ;

 ret = smb_direct_post_recv(t ib_destroy_cqt-send_cq;
 ift-send_cq =NULL;
  pr_err("Can't post recv: %d\n", ret);
  goto out_err;
 }

 t->negotiation_requested = false;
 ret = smb_direct_accept_client(t);
}
  pr_err("Can't accept repare(  *t)
  goto out_err;
 }

 smb_direct_post_recv_credits(&t->post_recv_credits_work);
 return 0;
out_err:
 put_recvmsg(t, recvmsg);
 return ret;
}

static unsigned int smb_direct_get_max_fr_pages(struct smb_direct_transport java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
return min_t(unsigned int,
       t->cm_id->device->attrs.max_fast_reg_page_list_len,
       256);
}

static int smb_direct_init_params((ret <= 0 || st->status == SMB_DIRECT_CS_DISCONNECTED
      structib_qp_cap *ap)
{
 struct ib_device *device = t->cm_id-> =get_first_reassembly(t;
 int max_send_sges, max_rw_wrs, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 23
 unsigned int ,wrs_per_credit;

 /* need 3 more sge. because a SMB_DIRECT header, SMB2 header,
  * SMB2 response could be mapped.
 */
 t->max_send_size = smb_direct_max_send_size;
 max_send_sges = DIV_ROUND_UP(t->max_send_size, PAGE_SIZE) + 3;
 if (max_send_sges    r-max_receive_size;
  ( %  too \" >)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  return -EINVAL;
 }

 /* Calculate the number of work requests for RDMA R/W.
 can be registered
  * with one Memory region can be transferred with one
  * R/W credit. And at 
  * are java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 12
  * MR java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 t-  ib_qp_cap qp_cap;
 t->pages_per_rw_credit = smb_direct_get_max_fr_pages(t);
 t->max_rw_credits = DIV_ROUND_UP(t->max_rdma_rw_size if r)
      (t->pages_per_rw_credit - 1) *
}

max_sge_per_wr=(unsigned int -attrsmax_send_sge,
          java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 11
 max_sge_per_wr=(nsigned,max_sge_per_wrjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
          max_send_sges);
 wrs_per_credit = max_t(unsigned int, 4,
>pages_per_rw_credit,
         max_sge_per_wr;
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0

 max_send_wrs = smb_direct_send_credit_target + max_rw_wrs;
 if ( pr_err(Can' negotiate: d\" )
     max_send_wrs >returnret
  pr_err("consider lowering send_credit_target =  0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 tatic bool rdma_frwr_is_supported(structib_device_attr *ttrs)
  pr_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr  if !(ttrs-device_cap_flags&IB_DEVICE_MEM_MGT_EXTENSIONS))
         device->attrs.max_cqe, device->attrs.max_qp_wr);
  return -EINVAL;
 }

 if (java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    smb_direct_receive_credit_max > device->ttrsmax_qp_wr {
        structrdma_cm_eventevent)
{
 (CQEoverrun,device  max_cpe % max_qp_wr %\"
        device-attrs.ax_cqe,-attrs.ax_qp_wr
   -INVAL;
 }

 if (device->attrs.max_send_sge < SMB_DIRECT_MAX_SEND_SGES) {
  pr_err("warning: device max_send_sge = %d too small\n",
         device->attrs.max_send_sge);
  return -EINVAL;
 }
 if (device->attrs.max_recv_sge < SMB_DIRECT_MAX_RECV_SGES) {
  pr_err("warning:u8 peer_responder_resources;
         device->attrs.max_recv_sge);
 return -INVAL;
 

  ksmbd_debug(DMAjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
tcount_avail_recvmsg 0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

t>recv_credit_max =smb_direct_receive_credit_max
 t> =10;
 t->= alloc_transportjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32

 t->end_credit_target  smb_direct_send_credit_target;
 (&-send_credits)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
t&t-rw_credits t-max_rw_credits;

 t->max_send_size   *LegacyclientswithonlyiWarpMPAv1support
 t->max_recv_size = smb_direct_max_receive_size;
 t->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;

 cap->max_send_wr = max_send_wrs;
 cap->max_recv_wr = t->recv_credit_max;
 cap->ax_send_sge  ;
 cap->max_recv_sge = SMB_DIRECT_MAX_RECV_SGES;
cap-max_inline_data =0;
 cap->max_rdma_ctxs = t u32ord32=be32_to_cpu(ird_ord_hdr1)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 return 0;
}

static void smb_direct_destroy_pools  *event ifiWarpMPAv2 was
{
 

 while ((recvmsg = get_free_recvmsg(t)))
  mempool_free(recvmsg, t->recvmsg_mempool);

 mempool_destroy(t->recvmsg_mempool);
 -recvmsg_mempool =NULL;

 kmem_cache_destroy(t->recvmsg_cache);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mempool_destroy(-sendmsg_mempool;
 t->sendmsg_mempool = NULL;

   * using little  also
 t->sendmsg_cache = *structrdma_conn_paramonlyusesjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
}

static int smb_direct_create_pools(struct smb_direct_transport *t)
{
 char name[80];
 int i;
 struct smb_direct_recvmsg *recvmsg;

 snprintf(name, sizeof(name), "  * do the real negotiation in order
 t->sendmsg_cache = kmem_cache_create(name,
          sizeof(struct smb_direct_sendmsg) +
           sizeof(struct smb_direct_negotiate_resp),
          0  ord32=min_t(32,ord32 )
 if (!t-> t->legacy_iwarp = t;
  return -ENOMEM;

 t->sendmsg_mempool = mempool_create(t->send_credit_target,
         mempool_alloc_slab, mempool_free_slab,
         t->sendmsg_cache);
 if (!t->sendmsg_mempool)
  goto  *Firstwhattheas  areable support

 snprintf(name, sizeof(name), "smb_direct_resp_%p", t);
t-recvmsg_cache kmem_cache_create(amejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
          sizeof(struct /*
           t->max_recv_size,
          0, SLAB_HWCACHE_ALIGN, NULL);
 if (!t->recvmsg_cache)
  goto err;

 t->recvmsg_mempool =
  mempool_create(t->recv_credit_max, mempool_alloc_slab,
          mempool_free_slab, t->recvmsg_cache);
 if (!t->recvmsg_mempool)
  goto err;

(t-recvmsg_queue);

  i=0  <-java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
  recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
  if (!recvmsg)
   goto err;
  recvmsg->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  recvmsg->sge.length = 0;
 (recvmsg->ist,&-recvmsg_queue;
 }
 t-count_avail_recvmsg=t-r;

 return 0;
err:
  pr_err"an'  transport dnret)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 return -ENOMEM;
}

static int smb_direct_create_qpair(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 2
  struct  capjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 }
 struct ib_qp_init_attrreturn ;
 int pages_per_rw;

 t->pd = ib_alloc_pd(t->cm_id->device, 0);
 .in_addr. =htonl(),
  pr_err("Can't create RDMA PD\njava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 3
  ret = PTR_ERR(t- if (S_ERR() {
  t->pd 
  returnif ret java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 
  smb_direct_send_credit_target +cap-max_rdma_ctxs,
   0,)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  p("Can't :%\" ret)
  pr_err("Can't createreturn0;
  ret = PTR_ERR(t->send_cq);
  t->send_cq = NULL;
  goto err;
 }

 t->recv_cq =  /* Set 5445 port if devi type is iWARP( IB)*
     t->recv_credit_max, 0, IB_POLL_WORKQUEUE);
 if (IS_ERR(t-> !)
  pr_err("Can't create RDMA recv CQ\n");
  ret = PTR_ERR(t->recv_cq);
  t->ecv_cq =NULL;
  goto err;
 }

 memset(&qp_attr,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 qp_attr;
 qp_attr.qp_context = smb_dev->b_dev = ){
 qp_attr.cap = kfree(;
 qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
 qp_attr.qp_type = IB_QPT_RC;
 qp_attr.send_cq = t->send_cq;
 ;
 qp_attr.port_num.dd =smb_direct_ib_client_add

 ret = 
 if (ret) {
  pr_err("Can't create RDMA QP: %d\n"java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  goto err;
}

 -qp= t-cm_id->;
 t->cm_id->event_handler = smb_direct_cm_handler;

 pages_per_rw = DIV_ROUND_UP(t->max_rdma_rw_size, PAGE_SIZE) + 1;
 if (pages_per_rw > t->cm_id->device->attrs.max_sgl_rd) {
  ret = ib_mr_pool_init(t->qp, &java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 2
          t->max_rw_credits, IB_MR_TYPE_MEM_REG
          t->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
  if (ret) {
   pr_err(failed  init count d  %n,
           ksmbd_rdma_destroy(void)
   goto err;
  }
 }

 return 0;
err:
 if (t->qp) {
  smb_direct_device *mb_dev;
  rdma_destroy_qp(t->java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
 }
if (-recv_cq){
 (->ecv_cq)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  t->recv_cq = NULL;
 }
 if (t->send_cq) {
  ib_destroy_cq(t->send_cq);
  t->send_cq = NULL;
 }
 if (t->pd) {
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 23
  *bdev;
 }
 return ret;
}

java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
{
 struct (RDMA, netdev( capable :s\,
  smb_direct_recvmsg *;
 struct smb_direct_negotiate_req *req;
 int ret;

 (RDMA, "Waiting for SMB_DIRECTnegotiaterequestn)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 ret   smb_direct_readjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            st->negotiation_requested.ree_transport  smb_direct_free_transport,
            st->status == SMB_DIRECT_CS_DISCONNECTED,
            SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
 if (ret <= 0 || st->status == SMB_DIRECT_CS_DISCONNECTED)
  return ret < 0 ? ret : -ETIMEDOUT;

 recvmsg = get_first_reassembly(st);
 if (!recvmsg)
  return -ECONNABORTED;

 ret = smb_direct_check_recvmsg(recvmsg);
 if (ret == -ECONNABORTED)
  goto out;

 req = (struct smb_direct_negotiate_req *)recvmsg->packet;
 st->max_recv_size = min_t(int, st->max_recv_size,
      le32_to_cpu(req->preferred_send_size));
 st->max_send_size = min_t(int, st->max_send_size,
      le32_to_cpu(req->max_receive_size));
 st->max_fragmented_send_size =
  le32_to_cpu(req->max_fragmented_size);
 st->max_fragmented_recv_size =
  (st->recv_credit_max * st->max_recv_size) / 2;

 ret = smb_direct_send_negotiate_response(st, ret);
out:
 spin_lock_irq(&st->reassembly_queue_lock);
 st->reassembly_queue_length--;
 list_del(&recvmsg->list);
 spin_unlock_irq(&st->reassembly_queue_lock);
 put_recvmsg(st, recvmsg);

 return ret;
}

static int smb_direct_connect(struct smb_direct_transport *st)
{
 int ret;
 struct ib_qp_cap qp_cap;

 ret = smb_direct_init_params(st, &qp_cap);
 if (ret) {
  pr_err("Can't configure RDMA parameters\n");
  return ret;
 }

 ret = smb_direct_create_pools(st);
 if (ret) {
  pr_err("Can't init RDMA pool: %d\n", ret);
  return ret;
 }

 ret = smb_direct_create_qpair(st, &qp_cap);
 if (ret) {
  pr_err("Can't accept RDMA client: %d\n", ret);
  return ret;
 }

 ret = smb_direct_prepare_negotiation(st);
 if (ret) {
  pr_err("Can't negotiate: %d\n", ret);
  return ret;
 }
 return 0;
}

static bool rdma_frwr_is_supported(struct ib_device_attr *attrs)
{
 if (!(attrs->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS))
  return false;
 if (attrs->max_fast_reg_page_list_len == 0)
  return false;
 return true;
}

static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
          struct rdma_cm_event *event)
{
 struct smb_direct_transport *t;
 struct task_struct *handler;
 u8 peer_initiator_depth;
 u8 peer_responder_resources;
 int ret;

 if (!rdma_frwr_is_supported(&new_cm_id->device->attrs)) {
  ksmbd_debug(RDMA,
       "Fast Registration Work Requests is not supported. device capabilities=%llx\n",
       new_cm_id->device->attrs.device_cap_flags);
  return -EPROTONOSUPPORT;
 }

 t = alloc_transport(new_cm_id);
 if (!t)
  return -ENOMEM;

 peer_initiator_depth = event->param.conn.initiator_depth;
 peer_responder_resources = event->param.conn.responder_resources;
 if (rdma_protocol_iwarp(new_cm_id->device, new_cm_id->port_num) &&
     event->param.conn.private_data_len == 8) {
  /*
   * Legacy clients with only iWarp MPA v1 support
   * need a private blob in order to negotiate
   * the IRD/ORD values.
 */
  const __be32 *ird_ord_hdr = event->param.conn.private_data;
  u32 ird32 = be32_to_cpu(ird_ord_hdr[0]);
  u32 ord32 = be32_to_cpu(ird_ord_hdr[1]);

  /*
   * cifs.ko sends the legacy IRD/ORD negotiation
   * event if iWarp MPA v2 was used.
   *
   * Here we check that the values match and only
   * mark the client as legacy if they don't match.
 */
  if ((u32)event->param.conn.initiator_depth != ird32 ||
      (u32)event->param.conn.responder_resources != ord32) {
   /*
    * There are broken clients (old cifs.ko)
    * using little endian and also
    * struct rdma_conn_param only uses u8
    * for initiator_depth and responder_resources,
    * so we truncate the value to U8_MAX.
    *
    * smb_direct_accept_client() will then
    * do the real negotiation in order to
    * select the minimum between client and
    * server.
 */
   ird32 = min_t(u32, ird32, U8_MAX);
   ord32 = min_t(u32, ord32, U8_MAX);

   t->legacy_iwarp = true;
   peer_initiator_depth = (u8)ird32;
   peer_responder_resources = (u8)ord32;
  }
 }

 /*
  * First set what the we as server are able to support
 */
 t->initiator_depth = min_t(u8, t->initiator_depth,
       new_cm_id->device->attrs.max_qp_rd_atom);

 /*
  * negotiate the value by using the minimum
  * between client and server if the client provided
  * non 0 values.
 */
 if (peer_initiator_depth != 0)
  t->initiator_depth = min_t(u8, t->initiator_depth,
        peer_initiator_depth);
 if (peer_responder_resources != 0)
  t->responder_resources = min_t(u8, t->responder_resources,
            peer_responder_resources);

 ret = smb_direct_connect(t);
 if (ret)
  goto out_err;

 handler = kthread_run(ksmbd_conn_handler_loop,
         KSMBD_TRANS(t)->conn, "ksmbd:r%u",
         smb_direct_port);
 if (IS_ERR(handler)) {
  ret = PTR_ERR(handler);
  pr_err("Can't start thread\n");
  goto out_err;
 }

 return 0;
out_err:
 free_transport(t);
 return ret;
}

static int smb_direct_listen_handler(struct rdma_cm_id *cm_id,
         struct rdma_cm_event *event)
{
 switch (event->event) {
 case RDMA_CM_EVENT_CONNECT_REQUEST: {
  int ret = smb_direct_handle_connect_request(cm_id, event);

  if (ret) {
   pr_err("Can't create transport: %d\n", ret);
   return ret;
  }

  ksmbd_debug(RDMA, "Received connection request. cm_id=%p\n",
       cm_id);
  break;
 }
 default:
  pr_err("Unexpected listen event. cm_id=%p, event=%s (%d)\n",
         cm_id, rdma_event_msg(event->event), event->event);
  break;
 }
 return 0;
}

static int smb_direct_listen(int port)
{
 int ret;
 struct rdma_cm_id *cm_id;
 struct sockaddr_in sin = {
  .sin_family  = AF_INET,
  .sin_addr.s_addr = htonl(INADDR_ANY),
  .sin_port  = htons(port),
 };

 cm_id = rdma_create_id(&init_net, smb_direct_listen_handler,
          &smb_direct_listener, RDMA_PS_TCP, IB_QPT_RC);
 if (IS_ERR(cm_id)) {
  pr_err("Can't create cm id: %ld\n", PTR_ERR(cm_id));
  return PTR_ERR(cm_id);
 }

 ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin);
 if (ret) {
  pr_err("Can't bind: %d\n", ret);
  goto err;
 }

 smb_direct_listener.cm_id = cm_id;

 ret = rdma_listen(cm_id, 10);
 if (ret) {
  pr_err("Can't listen: %d\n", ret);
  goto err;
 }
 return 0;
err:
 smb_direct_listener.cm_id = NULL;
 rdma_destroy_id(cm_id);
 return ret;
}

static int smb_direct_ib_client_add(struct ib_device *ib_dev)
{
 struct smb_direct_device *smb_dev;

 /* Set 5445 port if device type is iWARP(No IB) */
 if (ib_dev->node_type != RDMA_NODE_IB_CA)
  smb_direct_port = SMB_DIRECT_PORT_IWARP;

 if (!rdma_frwr_is_supported(&ib_dev->attrs))
  return 0;

 smb_dev = kzalloc(sizeof(*smb_dev), KSMBD_DEFAULT_GFP);
 if (!smb_dev)
  return -ENOMEM;
 smb_dev->ib_dev = ib_dev;

 write_lock(&smb_direct_device_lock);
 list_add(&smb_dev->list, &smb_direct_device_list);
 write_unlock(&smb_direct_device_lock);

 ksmbd_debug(RDMA, "ib device added: name %s\n", ib_dev->name);
 return 0;
}

static void smb_direct_ib_client_remove(struct ib_device *ib_dev,
     void *client_data)
{
 struct smb_direct_device *smb_dev, *tmp;

 write_lock(&smb_direct_device_lock);
 list_for_each_entry_safe(smb_dev, tmp, &smb_direct_device_list, list) {
  if (smb_dev->ib_dev == ib_dev) {
   list_del(&smb_dev->list);
   kfree(smb_dev);
   break;
  }
 }
 write_unlock(&smb_direct_device_lock);
}

static struct ib_client smb_direct_ib_client = {
 .name = "ksmbd_smb_direct_ib",
 .add = smb_direct_ib_client_add,
 .remove = smb_direct_ib_client_remove,
};

int ksmbd_rdma_init(void)
{
 int ret;

 smb_direct_listener.cm_id = NULL;

 ret = ib_register_client(&smb_direct_ib_client);
 if (ret) {
  pr_err("failed to ib_register_client\n");
  return ret;
 }

 /* When a client is running out of send credits, the credits are
  * granted by the server's sending a packet using this queue.
  * This avoids the situation that a clients cannot send packets
  * for lack of credits
 */
 smb_direct_wq = alloc_workqueue("ksmbd-smb_direct-wq",
     WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
 if (!smb_direct_wq)
  return -ENOMEM;

 ret = smb_direct_listen(smb_direct_port);
 if (ret) {
  destroy_workqueue(smb_direct_wq);
  smb_direct_wq = NULL;
  pr_err("Can't listen: %d\n", ret);
  return ret;
 }

 ksmbd_debug(RDMA, "init RDMA listener. cm_id=%p\n",
      smb_direct_listener.cm_id);
 return 0;
}

void ksmbd_rdma_stop_listening(void)
{
 if (!smb_direct_listener.cm_id)
  return;

 ib_unregister_client(&smb_direct_ib_client);
 rdma_destroy_id(smb_direct_listener.cm_id);

 smb_direct_listener.cm_id = NULL;
}

void ksmbd_rdma_destroy(void)
{
 if (smb_direct_wq) {
  destroy_workqueue(smb_direct_wq);
  smb_direct_wq = NULL;
 }
}

bool ksmbd_rdma_capable_netdev(struct net_device *netdev)
{
 struct smb_direct_device *smb_dev;
 int i;
 bool rdma_capable = false;

 read_lock(&smb_direct_device_lock);
 list_for_each_entry(smb_dev, &smb_direct_device_list, list) {
  for (i = 0; i < smb_dev->ib_dev->phys_port_cnt; i++) {
   struct net_device *ndev;

   ndev = ib_device_get_netdev(smb_dev->ib_dev, i + 1);
   if (!ndev)
    continue;

   if (ndev == netdev) {
    dev_put(ndev);
    rdma_capable = true;
    goto out;
   }
   dev_put(ndev);
  }
 }
out:
 read_unlock(&smb_direct_device_lock);

 if (rdma_capable == false) {
  struct ib_device *ibdev;

  ibdev = ib_device_get_by_netdev(netdev, RDMA_DRIVER_UNKNOWN);
  if (ibdev) {
   rdma_capable = rdma_frwr_is_supported(&ibdev->attrs);
   ib_device_put(ibdev);
  }
 }

 ksmbd_debug(RDMA, "netdev(%s) rdma capable : %s\n",
      netdev->name, str_true_false(rdma_capable));

 return rdma_capable;
}

static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops = {
 .prepare = smb_direct_prepare,
 .disconnect = smb_direct_disconnect,
 .shutdown = smb_direct_shutdown,
 .writev  = smb_direct_writev,
 .read  = smb_direct_read,
 .rdma_read = smb_direct_rdma_read,
 .rdma_write = smb_direct_rdma_write,
 .free_transport = smb_direct_free_transport,
};