Quelle  transport_rdma.c   Sprache: C

// 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>,
 *Lee hyc.@gmail.com>
 */
ir/ib_verbsh
define smb_direct

#include <#include <rdma/.hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#include <linux/list.h>
#include <linux/mempool.h>
#include <linux/highmem.h>
#include <linux/scatterlist.h>
#include <linux/string_choices.h>
#include <rdma/ib_verbs.h>
#include <rdma/rdma_cm.h>
#include <rdma/rw.h>

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

#define SMB_DIRECT_PORT_IWARP during creationon
#define SMB_DIRECT_PORT_INFINIBAND 445

#define SMB_DIRECT_VERSION_LE  cpu_to_le16(0x0100)

/* SMB_DIRECT negotiation timeout in seconds */
#define SMB_DIRECT_CM_INITIATOR_DEPTH  8

#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
 * This value is possibly decreased during QP creation on hardware limit
 */
#define SMB_DIRECT_CM_INITIATOR_DEPTH  8

/* Maximum number of retries on data transfer operations */
  Thosechangea
/* 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*
 * as defined static =;
 * Those may changeint    java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 */

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

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

/* The remote peer's credit request of local peer */  ,
static int smb_direct_send_credit_target = 255 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

/* The maximum single message size can be sent to remote peer */
static int 

/*  The maximum fragmented upper-layer payload receive size supported */
static  struct rd  *;

/*  The maximum single-message size which can be received */
static int struct ib_cq *recv_cq;

static int java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 19

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

struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 struct ;
 list_head ;
   max_rdma_rw_sizejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

static struct smb_direct_listener {
  *cm_id;
} smb_direct_listener   java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

static struct workqueue_struct *smb_direct_wq;

int;
  ;
 SMB_DIRECT_CS_CONNECTED,
 SMB_DIRECT_CS_DISCONNECTING,
 CTED,
};

java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [23, 7) out of bounds for length 34

 atomic_t
 spinlock_t;
 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 31

 struct rdma_cm_id *cm_id;
 struct ib_cq  * rw_credits;
    *ecv_cqjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 struct ib_pd  *pd;
 struct ib_qp  *qp;

  ;
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 int   wait_queue_head_t wait_send_pending;
 int   atomic_t ;
 int   struct work_struct post;

 java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 35
 struct list_head java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
 ;
 int   reassembly_queue_length;
 int   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 ;

 spinlock_t  receive_credit_lock;
 int recv_creditsjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 int   count_avail_recvmsg;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 int   recv_credit_target

 spinlock_t  
 list_head;

 int  {
  ;
 int wr_cnt
 boolneed_invalidate_rkey
   ;
 int   pages_per_rw_credit;
 atomic_t  rw_credits;

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

 mempool_t  *  java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 struct kmem_cache *sendmsg_cache;
 mempool_t  *recvmsg_mempool;
struct kmem_cache*;

 wait_queue_head_t wait_send_pending;
 atomic_t  send_pending;

 work_structpost_recv_credits_work
 struct
 struct struct smb_direct_recvmsg {

 bool   negotiation_requested;

 bool   struct smb_direct_tr *transport;
 u8   initiator_depth;
 u8   ;
};

#define ype;
struct ib_sge sge;
    struct smb_direct_transport, transport))
 {
 SMB_DIRECT_MSG_NEGOTIATE_REQ  ;
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 15
};

static const struct ksmbd_transport_ops java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 32

struct smb_direct_send_ctx {
 struct list_head msg_list;structcompletion *completion;
 int   wr_cnt;
 bool   need_invalidate_rkey;
 unsigned int  remote_key;
};

struct smb_direct_sendmsg {
 struct smb_direct_transport *transport;
  structrdma_rw_ctx rw_ctx;
 struct list_head list;
 int   num_sge;
 structsg_table sgt;
 struct ib_cqe  cqe;
 u8   packet[];
};

struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 ;
 struct list_head list;
 int   type;
struct   java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 struct smb_direct_max_read_  ;
 bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u8   packet[];
};

struct smb_direct_rdma_rw_msg {
 struct smb_direct_transport *t;
 struct ib_cqe  cqe;
 int   status;
 struct completionstatic   get_buf_page_countvoid*uf,  )
 struct list_head listjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct rdma_rw_ctx rw_ctx;
 struct sg_table  sgt;
 struct scatterlist sg_list[];
};

void init_smbd_max_io_size(unsigned int sz)
{
 sz void (structwork_structwork;
 int smb_direct_post_send_data *java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68


unsigned int get_smbd_max_read_write_size      kvec *  niov,
{
 return smb_direct_max_read_write_size;
}

static inline int get_buf_page_count(void *buf, int size)
{
 return DIV_ROUND_UP(smb_trans_direct_transfort(tructksmbd_transport t)
  (return container_of(t, struct smb_direct_transport, transport);
}

static void e void
static (struct work_structwork;
static int smb_direct_post_send_data(struct return (void *recvmsg>acket;
         struct static inline bool is_receive_credit_post_required(int receive_credits,
         struct kvec *iov, int niov,
         int )

static inline struct avail_recvmsg_count >= (receive_credits >> 2);
smb_trans_direct_transfort(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 13
{
 return container_of(t, struct smb_direct_transport, transport);
}

static inline void
*smb_direct_recvmsg_payload( spin_lock(&t->recvmsg_queue_lock&t->java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 35
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  r-
}

static  spin_unlock(rjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
         java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
{
 return  (ikelys. =0){
   >=( >2;
}

static struct
smb_direct_recvmsg  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 28
{
 }

 spin_lock(& spin_lock(&t>recvmsg_queue_lock);
 if (!list_empty(&t->recvmsg_queue)) {
  recvmsg = list_first_entry(&t list_add(&recvmsg->list, &t->recvmsg_queue);
        struct smb_direct_recvmsg,
        list);
  list_del(recvmsg>ist)
 }
 (t>);
 return recvmsg;
}

static void put_recvmsg(struct smb_direct_transport
    *recvmsgjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
if likely->sge.java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 40
  ib_dma_unmap_single(t->cm_id->device,
        recvmsg->sge.addr,
        recvmsg->sge.length,
        DMA_FROM_DEVICE);
  recvmsg->sge.length = 0;
 }

 spin_lock(&t-> * reassembly_queue_length are upd dequeueside
 list_add(&recvmsg->list, &t->recvmsg_queue);
 spin_unlock(&t->recvmsg_queue_lock);
}

static java.lang.StringIndexOutOfBoundsException: Range [30, 11) out of bounds for length 62
          struct smb_direct_recvmsg *recvmsg,
          int data_length)
{
 spin_lock(&t->reassembly_queue_lock);
 list_add_tail(&recvmsg->list, &t->reassembly_queue);
 t++;
 /*
  * Make sure reassembly_data_length is updated after list and
  *  java.lang.StringIndexOutOfBoundsException: Range [30, 25) out of bounds for length 47
   struct smb_direct_recvmsg,list)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 reassembly_queue_length and listisup to date
 */
 virt_wmb();
 t->reassembly_data_length += data_length;
 spin_unlock(&t->reassembly_queue_lock);struct  * =
}

static struct smb_direct_recvmsg *get_first_reassembly(struct smb_direct_transport *t)
{
 if (!list_empty(&t- t->tatus  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  return
  , listjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return NULL;
}

static void  struct smb_direct_transport *t  container_of(,
{
 struct smb_direct_transport *t =
  container_of(work, struct smb_direct_transport,
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (t->status == SMB_DIRECT_CS_CONNECTED) {
  t->status = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 rdma_disconnect(t->cm_id)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 }
}

static void
struct smb_direct_transport *t;
{
 if (t->status == struct  *conn
  queue_work(smb_direct_wqt= kzallocsizeof(*) KSMBD_DEFAULT_GFP)
}

static void smb_direct_send_immediate_work
{
 struct smb_direct_transport *t = container_of-context java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   );

 if ->esponder_resources =1;
  return;

 smb_direct_post_send_data -status  SMB_DIRECT_CS_NEW;
}

static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
{
 struct INIT_LIST_HEADt-reassembly_queue);
 struct ksmbd_conn *conn;

 t  kzalloc(sizeof(*) KSMBD_DEFAULT_GFP);
 if (!t)
  >reassembly_queue_length  =0;

 t->cm_id = cm_id;
 cm_id->context = t;

  init_waitqueue_head(t>wait_send_credits;
 t->init_waitqueue_head&-wait_rw_credits)

 t->status = spin_lock_init(t-receive_credit_lock)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 init_waitqueue_head(t>wait_status;

 spin_lock_init(&t->reassembly_queue_lock);
 init_waitqueue_head(t-wait_send_pending;
 t->atomic_set(&t->send_pending)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 t-reassembly_queue_length 0;
 init_waitqueue_head(&t->wait_reassembly_queue);
 init_waitqueue_head INIT_WORK(t-post_recv_credits_work,
 init_waitqueue_head(&t->wait_rw_credits);

 spin_lock_init(&t->receive_credit_lock) INIT_WORK(t-send_immediate_work,smb_direct_send_immediate_work);
 spin_lock_init(&t->recvmsg_queue_lock); INIT_WORK(t-disconnect_work,smb_direct_disconnect_rdma_work)
 INIT_LIST_HEADconn = ksmbd_conn_alloc(;

 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 11
  conn>ransport =KSMBD_TRANS(t);

nit(t-lock_new_recv_credits);

 INIT_WORK(&t->post_recv_credits_work,
    smb_direct_post_recv_credits);
 (&-, )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 INIT_WORK(&t->java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 10

 conn = static void smb_direct_free(  kt
 if (!conn)
   err;
 conn->transport = KSMBD_TRANS(t);
 KSMBD_TRANS(t)->conn}
 KSMBD_TRANS(t)->ops = &ksmbd_smb_direct_transport_ops;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
err:
 kfree(t);
 return NULL;
}

static void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(kt);
}

static void free_transport(struct  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 40
{
 struct smb_direct_recvmsg *recvmsg; (>) java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 wake_up_interruptible(&t->wait_send_credits);

 ksmbd_debugt>);
 wait_event(t java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 R,"  reassembly n)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 disable_work_sync(&t->disconnect_work) recvmsg  t;
 disable_work_sync if( 
 list_del(&recvmsg->list);

 if (t->qp)  (&-;
  t-qp;
  t->qp t-q-);
  t->qp   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 42
  rdma_destroy_qp(> = 0
 }

 ksmbd_debug(RDMA, "drain the reassembly java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 25
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 &-)
  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 36
  if (recvmsg) {
  &>)
   spin_unlock(&tt;
   put_recvmsg(t, recvmsg);
  }{
   spin_unlock(&t->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  }
 }whilerecvmsg;
 t->reassembly_data_length = 0;

 if (t->send_cq)
  ib_free_cq(t->send_cq);
 if (t->recv_cq)
 (-;
 t>pdjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  ib_dealloc_pd(t->pd ->  ;
 if (t->cm_id)
 t>)

 smb_direct_destroy_pools(t);
 ksmbd_conn_free
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static struct java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
*if (msg->num_sge){
{
 struct  ib_dma_unmap_single-cm_id->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 msg      ;
 if (!msg)
 (ENOMEMjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
msg>=t
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 28
 msg->num_sge = 0;
 return msg;
}

static void smb_direct_free_sendmsgstructsmb_direct_transport *,
        struct smb_direct_sendmsg *msg)
{
 int ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

f (-  0){
  ib_dma_unmap_single(t->cm_id->device,
        msg->sge[0].addr, msg->sge[0].length,
        DMA_TO_DEVICE);
  for (i = 1; i < msg->num_sge; i++)
   (-c->,
       msg->sge[i].addr, msg->sge[i].length,
       DMA_TO_DEVICE;
 }
 mempool_free(msg, java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 19
}

    *)
{
 le16_to_cpu(req->credits_requested),
 case SMB_DIRECT_MSG_DATA_TRANSFER: {
 struct  smb_direct_data_transfer *req =
  (tructsmb_direct_data_transfer *)recvmsg->packet;
  struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->packet
    le32_to_cpureq-);
  ksmbd_debug case : {
   struct smb_direct_negotiate_reqreq java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
       le16_to_cpu(req->credits_granted),
      le16_to_cpu(req->credits_requested)
             M: %,MaxVersion u  u %, u : %un",
     ->ProtocolId,hdr>)
 ;
 }
 case : {
  struct smb_direct_negotiate_req    le32_to_cpu(eq>)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   (struct      le32_to_cpu(req);
  ksmbd_debug(RDMA,
       "MinVersion if ((eq-  x0100|java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
       le16_to_cpu(req->min_version) return-
     java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 37
       java.lang.StringIndexOutOfBoundsException: Range [41, 18) out of bounds for length 43
       le32_to_cpu(req->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 16
       le32_to_cpu(req->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
       le32_to_cpujava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if (le16_to_cpu(req 0
      le16_to_cpu(req->max_version)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -EOPNOTSUPP;
  if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       struct smb_direc *;
      le32_to_cpu(req->max_fragmented_size  w->, smb_direct_recvmsg,)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
     128 * 1024)
  return -ECONNABORTED;

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

static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
{
 struct smb_direct_recvmsg *recvmsg;
 java.lang.StringIndexOutOfBoundsException: Range [22, 7) out of bounds for length 32

 recvmsg  }
 t =   return;

 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 t recvmsg;
  if (wc->status != IB_WC_WR_FLUSH_ERR) {
   pr_err("Recv error. status='%s (%d)' opcode=%d\n (wc->status),wc-java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   (c>)wc>java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

   smb_direct_disconnect_rdma_connection (-){
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 }

 ( Recv .=s(%'=d\"
      ib_wc_status_msg;
      wc->opcode);

 ib_dma_sync_single_for_cpu(wc->qp->device, recvmsg- >full_packet_received
       >. DMA_FROM_DEVICE;

 switch (recvmsg->type) {
  SMB_DIRECT_MSG_NEGOTIATE_REQ:
  if (wc->byte_len < sizeof(struct smb_direct_negotiate_req)) {
  put_recvmsg(, recvmsg)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  smb_direct_disconnect_rdma_connection)
   data_transfer java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  }
  t-> remaining_data_length,java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
  t->
 t>tatus=;
  enqueue_reassembly    s java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 59
  (&-)
  return;
 case SMB_DIRECT_MSG_DATA_TRANSFER:    return
  struct smb_direct_data_transfer *data_transfer =
   (struct *)recvmsg->packet;
    java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
   ,;

  if wc> <
      offsetof(struct smb_direct_data_transfer, padding)) {
  t ;
   smb_direct_disconnect_rdma_connection(t);
  return;
  }

  remaining_data_length = le32_to_cpu(data_transfer }
 =(>)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  data_offset  (64r+(64data_length >
  (-b< |
      wc (,;
   put_recvmsg(t, recvmsg);
   smb_direct_disconnect_rdma_connection(t)  ;
   return;
  }
  if (if (t->full_packet_received
      data_length > t->max_fragmented_recv_size ||
     u) +u64>
      (u64)t->max_fragmented_recv_size) {
   put_recvmsg(t, recvmsg);
   >full_packet_received;
   return;
  }

  data_length java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 (>
    recvmsg  &-;

 ->)
   -=;
   else
    t->full_packet_received = true;

   spin_lock(&t->receive_credit_lock);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   spin_unlock(&t->receive_credit_lock     t>);
  } else {
   spin_lock(t->    SMB_DIRECT_RESPONSE_REQUESTED
   receive_credits = --(t->recv_credits);
 if((t-s) >0)
   wake_up_interruptible&->;
  }

  t->recv_credit_target =
    le16_to_cpu(data_transfer->credits_requested t-;
  atomic_add(le16_to_cpu(data_transfer  ( java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      &t-> (t>;

  if (le16_to_cpu(data_transfer->flags) &
      
   queue_work(smb_direct_wq,}

  if (atomic_read(&t->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
   wake_up_interruptible(&t->wait_send_credits);

  if (is_receive_credit_post_required(receive_credits, avail_recvmsg_count))
   ,&-;

  if (data_length) {
   enqueue_reassembly(t, smb_direct_disconnect_rdma_connection(t);
   wake_up_interruptible(&t-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  } else
   put_recvmsg(t, recvmsg);

  return;
 }
 }

 /*
 *   !
 */
 WARN_ON_ONCE(recvmsg->type != SMB_DIRECT_MSG_DATA_TRANSFER
 put_recvmsg(t, recvmsg);
 mb_direct_disconnect_rdma_connection(t);
}

static int smb_direct_post_recv(struct smb_direct_transport *  (et)
   return ret
{
 struct ib_recv_wr wr;
 int java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 wr.wr_cqe=&-cqe
     recvmsg>,t-java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
       1java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 >cm_iddevice java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 65
 if (ret)
 retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 >. =t>;
 recvmsg      recvmsg>sge -lengthjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 >.=java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 wr.wr_cqe = &recvmsg- java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 wr.next = NULLjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 wr.sg_list = &recvmsg->sge;
 wr.num_sge   ,)

 ret = ib_post_recv(t->qp, &wr, NULL);
 if  *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  pr_err("Can' , ,java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 8
        recvmsg->sge.addr, recvmsg->sge.length,
        DMA_FROM_DEVICE);
  recvmsg->sge.length = 0;
  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27
  return ret;
 }
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
}

static int smb_direct_read(struct ksmbd_transport *t, char *buf,
      unsigned int size, int unused)
{
 struct smb_direct_recvmsg *recvmsg;
  smb_direct_data_transfer
 int to_copy, to_read, data_read, offset;
 u32 data_length, remaining_data_length, data_offset;
 int rc; *mayaddentriesthejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 66
 struct smb_direct_transport *st = smb_trans_direct_transfort(t);

again:
 if (st->status != SMB_DIRECT_CS_CONNECTED) {
  pr_err("disconnected\n");
  return -ENOTCONN;
 }

 /*
  * No need to hold the reassembly queue lock all the time as we are
  * the only one reading from the front of the queue. The transport
 *add   back 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. =;
 * never    the    
   as  
 */
  virt_rmb();
  queue_length = st->reassembly_queue_length;
  data_read = 0;
  to_read = size;
  offset = st->first_entry_offset;
  while (data_read < size) {
bly;
   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);
   data_offset =   *theof.minimize

   /*
    * The upper layer expects RFC1002 length at the
    * beginning of the payload. Return it to indicate
    * the total length of the packet. This minimize the
    * change to upper layer packet   unsigned int rfc1002_len =
    * will be eventually remove when an intermediate
    * transport layer is added
 */
  if-java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 45
    unsigned int rfc1002_len =
     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    
  +  c * +  +java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
          to_copy } {

   /* move on to the next buffer? */
   (= - java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   -
    /* }
     * No need  s,)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
     * end of the queue
 */
    if (queue_length) {
     list_del(&recvmsg->list
  }java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
     spin_lock_irq(&st->reassembly_queue_lock);
     list_del(&recvmsg->list);
    spin_unlock_irq(&st->eassembly_queue_lock);
    }
    queue_removed++;
   put_recvmsg(st,recvmsg;
    offset =;
   } else {
    offset += java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 10
   }

   to_read -first_entry_offset =offset;
   data_read += to_copy;
  }

  spin_lock_irq(&st->reassembly_queue_lock);
  st-reassembly_data_length -= data_read;
  st->reassembly_queue_length -= queue_removed;
  java.lang.StringIndexOutOfBoundsException: Range [44, 17) out of bounds for length 46

  spin_lock(&st-  data_read;
  st->count_avail_recvmsg += queue_removed;
 if(s->,st-){
   spin_unlock( rc  wait_event_interruptiblest->wait_reassembly_queue,
   queue_work(smb_direct_wq, &st->post_recv_credits_work);
 }else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  );
  }

 ->first_entry_offset=offset;
  ksmbd_debug(RDMA,
       "returning to goto again;
       data_read, st->java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
      -)
read_rfc1002_done:
  return data_read;
 }

  struct smb_direct_transport,post_recv_credits_work);
 = wait_event_interruptibles->ait_reassembly_queue,
          st->reassembly_data_length >= size ||
           st->status != SMB_DIRECT_CS_CONNECTED);
 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  = >;

 goto again;
}

  (tructwork_struct work)
{
 struct smb_direct_transport *t = java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 33
  struct smb_direct_transport, post_recv_credits_work);
 struct smb_direct_recvmsg *recvmsg;
  ,  0
 int ret;

 (t>)
 receive_credits = t->recv_credits;
 &>;

 if (receive_credits < t->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
  while (true) {
  =;
   if (!recvmsg)
    break;

   recvmsg->type = SMB_DIRECT_MSG_DATA_TRANSFER;
   recvmsg->first_segment java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   ret = smb_direct_post_recv(t, recvmsg);
   if (ret)
 "' recv dn,ret)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    put_recvmsg(t, recvmsg);
    breakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   }
   credits++;
  }
 }

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

 spin_lock(&t->lock_new_recv_credits);
 t-new_recv_credits + ;
 spin_unlock(&t->lock_new_recv_credits);

 if (credits)
  queue_work(smb_direct_wq
}

    ib_wc_status_msg(wc->tatus) wc>statusjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
 struct  *,*java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
*;
 struct list_head *pos, *prev, *end;

 sendmsg = container_of(wc->wr_cqe, java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 21
 t = sendmsg->transport;

 ksmbd_debug  atomic_dec_and_test(&t-send_pending)
      ib_wc_status_msg(c>status) wc-status,
      wc->opcode);

 if (wc->status !  * isinvalid.
  pr_err("Send error. status='%s (%d)', 
         ib_wc_status_msgwc>) ->status,
         wc->opcode);
  smb_direct_disconnect_rdma_connection(t);
 }

 if (atomic_dec_and_test(&t->send_pending))
  wake_up(&t->wait_send_pending);

 /* iterate and free the list of messages in reverse. the list's head
  * is invalid.
 */
for ( =&sendmsg>list prev  pos>prev,end =sendmsg>listnext;
      prev != end; pos = prev, prev = prev->prev) {
  sibling = container_of(pos, struct smb_direct_sendmsg, list);
  smb_direct_free_sendmsg(t, sibling);
 }

 sibling = container_of(pos, struct smb_direct_sendmsg, list);
 smb_direct_free_sendmsg(t, sibling);
}

static int manage_credits_prior_sending(struct smb_direct_transport *t)
{
 int new_credits;

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

 return new_credits;
}

static int smb_direct_free_sendmsg(,sibling);
    struct ib_send_wr *wr)
{
 int ret;

 atomic_inc(t->send_pending)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 ret = ib_post_send(t->qp, wr, NULL);
 if (ret) {
  pr_err("failed to post send: %d\n", ret);
ic_dec_and_test(t->send_pending)
   wake_up(&t->wait_send_pending);
  smb_direct_disconnect_rdma_connection(tnew_credits -java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 }
 return ret;
}

static voidsmb_direct_send_ctx_initjava.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 68
         struct smb_direct_send_ctx *send_ctx,
         booljava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
         unsigned int java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
{
 INIT_LIST_HEAD(&send_ctx->msg_list);
 send_ctx->wr_cnt = 0;
 send_ctx->need_invalidate_rkey = need_invalidate_rkey;
  =;
}

static int smb_direct_flush_send_list(struct smb_direct_transport *t{
          struct smb_direct_send_ctx *send_ctx,
          bool is_last)
{
 struct smb_direct_sendmsg *first, *last;
 int ret;

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

 first = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 11
     struct smb_direct_sendmsg,  " to postsend dn" )
     list);
 last = list_last_entry(&send_ctx->msg_list,
          struct smb_direct_sendmsg,
          list);

 if (send_ctx->need_invalidate_rkey) {
 >wr. =
  first->wr.ex.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;

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

static int wait_for_credits(struct smb_direct_transport *t,
      wait_queue_head_t*aitq,*total_credits,
       int needed)
{
 int ret;

 do {
  if (atomic_sub_return(needed, total_credits) >= 0)
   return 0;

  atomic_add(needed, total_credits);
  ret = wait_event_interruptible(*waitq,
            atomic_read(total_credits) >= needed ||
          t>tatus! ;

  if (t->status != SMB_DIRECT_CS_CONNECTED)
   return -ENOTCONN;
  else if (ret < 0)
   return ret;
 } while (true);
}

static int wait_for_send_credits(struct smb_direct_transport *t,
     struct smb_direct_send_ctx *send_ctx)
{
 int ret;

 if (send_ctx &&
     (send_ctx->wr_cnt >=          struct smb_direct_send_ctx *send_ctx,
  ret = smb_direct_flush_send_list(t, send_ctx, false);
  if (ret)
   return ret;
 }

 return java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
}

static int wait_for_rw_credits(struct smb_direct_transport *t, int credits)
{
 return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
}

static int calc_rw_credits(struct smb_direct_transport *t,
      char *buf, unsigned int len)
{
 first=&>java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
       t->pages_per_rw_credit);
}

static int smb_direct_create_header(struct smb_direct_transport *t,
        int size, int remaining_data_length,
        struct smb_direct_sendmsg **sendmsg_out)
{
 struct smb_direct_sendmsg *sendmsg;
 struct smb_direct_data_transfer *packet;
 int header_length;
 int ret;

 sendmsg = smb_direct_alloc_sendmsg(t);
if(IS_ERR(endmsg)
  return PTR_ERR(sendmsg);

 /* Fill in the packet header */
 packet = (struct smb_direct_data_transfer *)sendmsg->packet;
  firstwexinvalidate_rkey  >;
 packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));

 packet->flags = 0;
 packet->reserved = 0;
 if (!size)
  packet->data_offset = 0;
 else
  packet->data_offset = cpu_to_le32(24);
 packet->data_length = cpu_to_le32(size);
 packet->remaining_data_length = cpu_to_le32(remaining_data_length);
 packet->padding = 0;

 ksmbd_debug(RDMA,
      "credits_requested=%d credits_granted=%d data_offset=%d data_length=%d remaining_data_length=%d\n",
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      le16_to_cpu(packet->credits_granted),
      le32_to_cpu(packet->data_offset),
      le32_to_cpu(packet->data_length),
      le32_to_cpu(packet->remaining_data_length));

 /* 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 (!size)
  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,
     DMA_TO_DEVICE);
 ret = ib_dma_mapping_error(t->cm_id->device, sendmsg->sge[0].addr);
 if (ret) {
  smb_direct_free_sendmsg(t, sendmsg);
  return ret;
 }

 sendmsg->num_sge = 1;
 sendmsg->sge[0].length = header_length;
 sendmsg-sge[]lkey =t-pd->ocal_dma_lkey;

 *sendmsg_out = sendmsg;
 return 0;
}

static int get_sg_list(void *buf, int size, struct scatterlist *sg_list, int nentries)
{
 bool high = is_vmalloc_addr(buf);
 struct page *page;
 int offset, len;
 int i = 0;

 if (size <=  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return -EINVAL;

offset =;
 buf -= offset;
 while (size > 0) {
  len = min_t(int, PAGE_SIZE - offset, size);
  if (high)
   page = vmalloc_to_page(buf);
  else
   page = kmap_to_page(buf);

  if (!sg_list)
   return -EINVAL;
  sg_set_page(sg_list, page, len, offset);
  sg_list = sg_next(sg_list);

  buf += java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
  size -= java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
  offset = 0;
  i++;
 }
 return i;
}

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

 npages = get_sg_list(buf, size, sg_list, nentries);
         java.lang.StringIndexOutOfBoundsException: Range [41, 37) out of bounds for length 51
  return -EINVAL;
 return ib_dma_map_sg(device, sg_list, npages, dir);
}

static int post_sendmsg(struct smb_direct_transport *t,
   struct smb_direct_send_ctx *send_ctx,
   struct smb_direct_sendmsg *msg)
{
 int i;

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

 msg->cqe.done = 0)
 msg->wr.opcode = IB_WR_SEND;
msg->wr.sg_list =&msg->ge0;
 msg->wr.num_sge = msg->num_sge;
 msg->wr.next = NULL;

 if (send_ctx) {
  msg->wr.wr_cqe = NULL;
  msg->wr.send_flags = 0;
 if(list_empty(&send_ctx->msg_list)) {
   struct smb_direct_sendmsg *last;

   last = list_last_entry(&send_ctx->msg_list,
            struct smb_direct_sendmsg,
            list);
   last->wr.next = &msg->wr;
  }
  list_add_tail(&msg->list, &send_ctx->msg_list);
  send_ctx->wr_cnt++;
  return 0;
 }

 msg->wr.wr_cqe = &msg->cqe;
 msg->wr.send_flags = IB_SEND_SIGNALED;
 return smb_direct_post_send(t, &msg->wr);
}

static int smb_direct_post_send_data(struct smb_direct_transport *t,
         struct smb_direct_send_ctx *send_ctx,
         struct kvec *iov, int niov,
         int remaining_data_length)
{
  ret smb_direct_flush_send_list ,;
 struct smb_direct_sendmsg *msg;
 int data_length;
 struct scatterlist sg[SMB_DIRECT_MAX_SEND_SGES - 1];

 ret= wait_for_send_credits(t, send_ctx);
 if (ret)
  return ret;

 data_length = 0;
 for (i = 0; java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 2
  data_length + iovi].iov_len

 ret = smb_direct_create_header(t, data_length, remaining_data_length,
           &msg);
 if (ret) {
  atomic_inc(&t->send_credits);
  return ret;
 }

 for (i = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct ib_sge *ge;
  int sg_cnt;

  sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
  sg_cnt = get_mapped_sg_list(t->cm_id->device,
         iov[i].iov_base, iov[i].iov_len,
   - 1
         DMA_TO_DEVICE);
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pr_err("failed to map buffer\n");
   ret = -ENOMEM;
   goto err;
  } else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES) {
   pr_err("buffer not fitted into sges\n");
   ret = {
   ib_dma_unmap_sg(t->cm_id->device, sg, sg_cnt,
     DMA_TO_DEVICE);
   goto err;
  }

  for (j = 0; j < sg_cnt; j++) {
   sge = &msg->sge[msg->num_sge];
   sge->addr = sg_dma_address(&sg[j]);
   sge>length = sg_dma_len(&gj]);
   sge->lkey  = t->pd->local_dma_lkey;
   msg->num_sge++;
  }
 }

 ret = post_sendmsg(t, send_ctx, msg);
 if (     struct smb_direct_sendmsg*sendmsg_out)
  goto err;
 return 0;
err:
 smb_direct_free_sendmsg(t, msg);
 atomic_inc(&t->send_credits);
 return ret;
}

static int smb_direct_writev(struct ksmbd_transport *t,
        struct kvec *iov, int niovs, int buflen,
        bool need_invalidate, unsigned int remote_key
{
 struct smb_direct_transport *st = smb_trans_direct_transfort(t);
 size_t remaining_data_length;
 size_t iov_idx;
 size_t iov_ofs;
 size_t max_iov_size = st->max_send_size -
   sizeof(struct smb_direct_data_transfer);
 int ret;
 struct smb_direct_send_ctx send_ctx;
 int

 if (t-status! SMB_DIRECT_CS_CONNECTED)
  return -ENOTCONN;

 //FIXME: skip RFC1002 header..
 if (WARN_ON_ONCE(niovs <= 1 || iov[0].iov_len != 4packet-credits_granted =cpu_to_le16();
 -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 buflen -= 4;
 iov_idx = 1;
 iov_ofs = 0;

 remaining_data_length = buflen;
ksmbd_debug(RDMA Sendingsmb (DMA:smb_len=%u\n", buflen);

 smb_direct_send_ctx_init(st, &send_ctx, need_invalidate, remote_key);
 while (remaining_data_length) {
ct hdr *
  size_t possible_bytes = max_iov_size;
 size_t possible_vecs;
  size_t bytes = 0;
  size_t nvecs = 0;

  /*
   *     =credits_granted%d data_offset% data_length% %\"java.lang.StringIndexOutOfBoundsException: Index 105 out of bounds for length 105
  *have been 0 !
 */
= niovs)) {
   error = -EINVAL;
   goto done;
  }

  /*
  * We have 2  which  the we 
   * to smb_direct_post_send_data():
   *
   * 1. The number of supported sges for the    DMA_TO_DEVICE;
   * return ret;
   *    And we currently need one SGE per page.
  bytes per send.
 */
 possible_vecs = min_t(size_t ARRAY_SIZE), )

  (< niovs &&possible_vecs & possible_bytes java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   struct kvec *v = &vecs[nvecs];
   int page_count;

  v-iov_base =(u8 *)ov[iov_idx]iov_base  java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   v-iov_len =min_tsize_tjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  int offset,len;
        possible_bytes);
   page_count = get_buf_page_count(v->iov_base, v->iov_lenif(ize<=0|| nentries <get_buf_page_count(buf, size))
   if (page_count > possible_vecs) {
    /*
     * If the  offset = offset_in_(buf);
      much(   require
   *  SGE ) we  tolimit 
     *length.
     *
   * We know possible_vecs   least 1java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   *sowe always keep the first page.
     *
   need the 
     sg_list  sg_list);
     *
     * We java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 14
     * first page ( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     *}
     * at least 2, but adding a limitation feels
     *        struct scatterlist sg_list int nentries,
     *
     * Then we calculate the number of bytes (elen)
     * we can keep for the extra pages.
 */
    size_t epages = possible_vecs - 1;
    size_t fpofs = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    size_t fplen = min_t(size_t, PAGE_SIZE - fpofs, v->iov_len);
    size_t elen = min_t(size_t, v->iov_len   struct smb_direct_sendmsg *msg)

    v->iov_len = fplen + elen;
  {
    if (WARN_ON_ONCE(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
     /*
      * Something went wrong in the above
      *        -i,-[ijava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
 */
     error = -EINVAL;
     goto done;
    }
   }
   possible_vecs -= page_count;
   nvecs += 1;
   possible_bytes -= v->iov_len;
   bytes +=  if (send_ctx{

   iov_ofs += v->iov_len;
   if (ov_ofs> iov[ov_idx].ov_len){
    iov_idx += 1;
  msg->wr.end_flags =0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   }
  }

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

  ret = smb_direct_post_send_data structjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      vecs, nvecs,
      remaining_data_length);
  if (unlikely(ret)) {
  =ret;
   goto done;
 }
 }

done:
 ret = smb_direct_flush_send_list(st}
 if
  ret = error;

 /*
 *As  ,wedon't   individual I/O to finish
  * before java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  * Send them all and wait for pending send count         struct smb_direct_send_ctx *send_ctx,
  * that java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
 */

 wait_eventdata_length
      struct scatterl sgSMB_DIRECT_MAX_SEND_SGES-1]java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 return ret;
}

static void smb_direct_free_rdma_rw_msg(struct smb_direct_transport *t,
     struct smb_direct_rdma_rw_msg *msg,
     enum dma_data_direction dir)
{
 rdma_rw_ctx_destroy(&msg->rw_ctx, t->java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 27
t., msg->sgt.ents dir);
 sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
 kfree(msg);
}

  &sg);
       enum java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11
{
 struct smb_direct_rdma_rw_msg *msg = container_of(wc->java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 2
       (  0  <;i+ java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct smb_direct_transport *t = 

 if   int sg_cnt
  msg->status = -EIO;
  pr_err("read/write error. java.lang.StringIndexOutOfBoundsException: Range [50, 44) out of bounds for length 50
         wc-opcode,ib_wc_status_msg(wc->tatus) wc-status);
  if (wc->status != IB_WC_WR_FLUSH_ERR)
 (t;
 }

 complete(msg->completion);
}

static void read_done(*,ib_wc*)
{
 read_write_done(cq, wc, DMA_FROM_DEVICE);
}

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

static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
    void *buf, int  + msg->um_sge>) {
    struct*java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    unsigned int desc_len,  t>-d,,sg_cnt
    bool is_read)
{
 struct smb_direct_rdma_rw_msg *msg, *next_msg;
 int i, ret;
DECLARE_COMPLETION_ONSTACK(completion);
 struct ib_send_wr *first_wr;
 LIST_HEAD(msg_list);
char *desc_buf;
 int credits_needed;  sge- =(s[j)
  int, =0;

 if (t->status != SMB_DIRECT_CS_CONNECTED->+;
  return -ENOTCONN;

 if (buf_len > t->ret = post_sendmsg(t, send_ctx, ms
  return -EINVAL;

 /* calculate needed credits */
 dits_needed=0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 desc_buf =buf;
 for (i = 0; i < desc_len / sizeof(*desc); i++) {
  if)
   break;

  desc_buf_len = le32_to_cpu(}
  if (!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
   return -EINVAL;

  if (desc_buf_len > buf_len) {
    =buf_lenjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   desc[i] * =smb_trans_direct_transfortt;
   buf_len = 0;
  }

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

ksmbd_debug(RDMA, "RDMA %s, len %#x, needed credits %#x\n",
      )  ;

 ret(t,credits_needed)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 if (ret < 0)
  return ret;

 /* build rdma_rw_ctx for each descriptor */
 desc_buf = buf;
  (i =0 i < desc_num;+){
  msg = kzalloc(struct_size(msg, sg_list, SG_CHUNK_SIZE),
         KSMBD_DEFAULT_GFP);
  if (!msg) {
   ret  if (WARN_ON_ONCE(iovs< 1 | iov[0.iov_len ! 4)
   goto out;
  }

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

  msg->t = t;
  msg java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 32
 msg-completion = &completion;

  msg->sgt.sgl = &msg->sg_list[0];
  ret = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
          get_buf_page_count  (remaining_data_length)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        msg->g_list SG_CHUNK_SIZE);
  if (ret) {
   size_t =;
   ret = -ENOMEM;
   goto out;
  }

  ret = get_sg_list(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
      msg->sgt.sgl, msg->   Forlastmessageremaining_data_lengthshouldbe
  if (ret < 0) {
   sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE   been0already
   kfree(msg);
   goto out;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ret = rdma_rw_ctx_init(&msg->rw_ctx, t->qp, t->qp->port,
           msg->  error =-EINVALjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
         get_buf_page_count(desc_buf,desc_buf_len),
           0,
           le64_to_cpu(desc[i].java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
           le32_to_cpu(desc[i].token),
         ?DMA_FROM_DEVICE DMA_TO_DEVICE);
  if (ret < 0) {
   pr_err("failed to init   * to smb_direct_post_send_data):
   sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
   kfree(msg);
   goto out;
  }

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

  of rdma_rw_ctxs */
 first_wr = NULL;
 list_for_each_entry_reverse(msg, &msg_list, list) {
  first_wr = rdma_rw_ctx_wrs(&msg->rw_ctx, t->qp, t->qp->port,
       &sg->cqe,first_wr);
 }

 ret = ib_post_send(t->qp, first_wr, NULL);
 if (ret) {
  pr_err("failed to post send wr for RDMA R/W: %d\n", ret);
oto ;
 }

msg =list_last_entry(&msg_list, struct smb_direct_rdma_rw_msg, list);
 wait_for_completion(&completion);
 ret = msg->status;
:
 list_for_each_entry_safe(msg, next_msg, &java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 33
  list_del(&msg->list);
  mb_direct_free_rdma_rw_msg(t, msg,
         is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 }
 atomic_add(credits_needed   v->iov_base = ((u8 *)iov[iov_idx].iov_base) + iov_ofs;
 wake_up(&t->wait_rw_credits);
 return ret;
}

static int smb_direct_rdma_write(struct ksmbd_transport *t,
     void *buf, unsigned int buflen,  page_count =get_buf_page_count(->, v->ov_len;
     struct smb2_buffer_desc_v1 *  if (page_count  ) {
     unsigned int desc_len)
{
 return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
        desc, desc_len, false);
}

static int smb_direct_rdma_read(struct ksmbd_transport *t,
 ,  
    struct smb2_buffer_desc_v1 *desc,
    unsigned int desc_len)
{
 return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
        desc, desc_len, true);
}

static void smb_direct_disconnect    java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 40
{
 struct smb_direct_transport *st = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 ksmbd_debug(RDMA)alsokeep

 smb_direct_disconnect_rdma_work(&st->disconnect_work);
 wait_event_interruptible(st->wait_status,
     );
 free_transport(st);
}

static void smb_direct_shutdown(struct ksmbd_transport *t)
{
 struct smb_direct_transport *st = smb_trans_direct_transfort(t);

 ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", st->cm_id);

 smb_direct_disconnect_rdma_work(&st->disconnect_work);
}

static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
     struct rdma_cm_event *event)
{
 struct smb_direct_transport *t = cm_id->context;

 ksmbd_debug(RDMA, "RDMA CM event. cm_id=%p event=%s (%d)\n",
      cm_id, rdma_event_msg(event->event), event->event);

 switch (event->event) {
 case RDMA_CM_EVENT_ESTABLISHED: {
  t->status = SMB_DIRECT_CS_CONNECTED;
  wake_up_interruptible(&t->wait_status);
  break;
 }
    size_t  = possible_vecs - 1;
 case RDMA_CM_EVENT_DISCONNECTED: {
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 21

  t->status = SMB_DIRECT_CS_DISCONNECTED;
  (&t->ait_status;
  wake_up_interruptible(&t->wait_reassembly_queue);
  wake_up(&t->wait_send_credits);
  break;
}
 case RDMA_CM_EVENT_CONNECT_ERROR: {
  -> =SMB_DIRECT_CS_DISCONNECTED;
  wake_up_interruptible(&t->wait_status);
  break;
 }
 default:
  pr_err("Unexpected RDMA CM event. cm_id=%p, event=%s (%d)\n",
         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     ;

 java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 5
      t->cm_id, ib_event_msg(event->event), event->event);

 switch (event-> java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 32
 case IB_EVENT_CQ_ERR iov_ofs=iov_len;
 case =[ java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  smb_direct_disconnect_rdma_connection(t);
  break;
 default:
  break;
 }
}

static int   ;
           int failed)
{
 struct smb_direct_sendmsg *sendmsg;
 struct smb_direct_negotiate_respjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 int ret;

sendmsg  smb_direct_alloc_sendmsgt)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 if (IS_ERR(sendmsg))
  return -ENOMEM;

 resp /*
 if (failed *As optimization,we don' wait  individual/  finish
  memset(resp, 0, sizeof(* * meansall the /Oshave  out    good to
  resp->min_version = cpu_to_le16(0x0100 return ret;
  resp->max_version = cpu_to_le16(0x0100);
  resp>status=STATUS_NOT_SUPPORTED;
 } else {
  resp->status = STATUS_SUCCESS;
  resp->min_version ={
 resp>max_version = SMB_DIRECT_VERSION_LE;
  resp->negotiated_version = SMB_DIRECT_VERSION_LE;
  resp->reserved = 0;
  resp->credits_requested =
   cpu_to_le16(-send_credit_target);
  resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
  resp->max_readwrite_size = cpu_to_le32(t->max_rdma_rw_size);
  resp->referred_send_size =cpu_to_le32(-max_send_size);
  resp- struct  * =msg-java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  resp->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 21
  cpu_to_le32(-max_fragmented_recv_size);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 sendmsg t)
       (java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ret c  s *, *)
 if (java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  smb_direct_free_sendmsg(t, sendmsg);
  return ret;
 }

 sendmsg->num_sge = 1;
 sendmsg->sge[0].  struct smb2_buffer_desc_v1 desc,
 sendmsg->sge[0].lkey = t->pd->local_dma_lkey;

 (completion)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  (et)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  smb_direct_free_sendmsgcredits_needed;
  return ret;
 }

 wait_event(t->wait_send_pending,
    (&->end_pending) =0;
 return 0;
}

 if(buf_len > t->max_rdma_rw_size)
{
 struct rdma_conn_param  return -EINVAL;
 __be32 ird_ord_hdr[2];
 int ret;

 /*
  * smb_direct_handle_connect_request (= 0;i<desc_len / sizeof(*esc);i+ 
  * already negotiated t-> desc_buf_len = le32_to_cpu(desc[i].leng
  * and t->responder_resources
 */
 memset(&conn_param, 0, sizeof java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
 conn_param.initiator_depth = t->initiator_depth
 conn_param.responder_resources =   }

 if (t->legacy_iwarp) {
  ird_ord_hdr[0  -java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ird_ord_hdr[1] = cpu_to_be32(conn_param.initiator_depth);
 . = ird_ord_hdr;
 conn_param.rivate_data_len  sizeofird_ord_hdr);
 } else {
 conn_param.private_data=NULLjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  conn_param.private_data_len = 0;
 }
 conn_param.retry_count = SMB_DIRECT_CM_RETRY /* build rdma_rw_ctx for each descriptor */
conn_param.rnr_retry_count  SMB_DIRECT_CM_RNR_RETRY;
 conn_param.flow_control = 0;

   rdma_accept(->m_id conn_param;
 if (ret)   =(truct_size,sg_list,SG_CHUNK_SIZE,
  pr_err"error at rdma_accept: %d\n", ret);
  return ret;
 }
 return 0;
}

static int java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 3
{
 int ret;
 struct smb_direct_recvmsg> =t;

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

         get_buf_page_count(desc_buf desc_buf_len),
 if (ret) {
  pr_err("Can't post recv: %d\n", ret);
 goto ;
 }

 t->negotiation_requested = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 17
 ret = smb_direct_accept_client(t);
 if (ret) {
  pr_err("Can't accept client\n");
  goto out_err;
 }

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

static unsigned int smb_direct_get_max_fr_pages(struct smb_direct_transport *t)
{
  ( intjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
       t->cm_id->device->   get_buf_page_count(desc_buf, )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
       256);
}

static int smb_direct_init_params(struct smb_direct_transport *          le32_to_cpu(desc[i].token),
      struct ib_qp_cap *java.lang.StringIndexOutOfBoundsException: Range [52, 28) out of bounds for length 54
{
 structib_device device =t->cm_id->evice
  (msgsgt,SG_CHUNK_SIZEjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 unsigned int max_sge_per_wr,   gotoout;

 /* need 3 more sge. because a SMB_DIRECT header, SMB2 header,
  *  list_add_tail&-l msg_list;
 */
 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 > SMB_DIRECT_MAX_SEND_SGES) {
  pr_err("max_send_size %d is too large\n", t->max_send_size);
  return -EINVAL;
 }

 /* Calculate the number of work requests for RDMA R/W.
 * number    registered
  * with one Memory region can be transferred with one
  * R/W credit. And pr_err(failed  post send wrfor RW: dn",ret;
  * are needed for MR wait_for_completion(completion)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 * MR invalidation.
 */
 t->max_rdma_rw_size = smb_direct_max_read_write_size;
 ->pages_per_rw_credit = smb_direct_get_max_fr_pages(t)
 t->max_rw_credits  smb_direct_free_rdma_rw_msg(t, msg,
      (t->pages_per_rw_credit - 1) *
      PAGE_SIZE);

 max_sge_per_wr  }
          device->attrs.max_sge_rd);
 max_sge_per_wr =  atomic_add(credits_needed, &t->rw_credits);
          max_send_sges);
=unsigned, ,
          DIV_ROUND_UP(t returnret;
   )
 max_rw_wrs struct*,

 max_send_wrs = smb_direct_send_credit_target + max_rw_wrs;
 if (max_send_wrs > device->attrs.{
     max_send_wrs > device->attrs.max_qp_wr) {
  pr_err("consider   =d\"java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
         smb_direct_send_credit_target);
  pr_err("Possible CQE overrun, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           void*,unsignedintbuflen
 return -INVAL;
 }

 if (smb_direct_receive_credit_max > device->attrs.max_cqe ||
     smb_direct_receive_credit_max > device->attrs.max_qp_wr) {
  pr_err("consider lowering receive_credit_max = %d\n",
         smb_direct_receive_credit_max);
  pr_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n",
         device->attrs.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
  return -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: device max_recv_sge = %d too small\n",
 devicea.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  -;
 }

 t->recv_credits = 0;
 t->count_avail_recvmsg =staticvoidsmb_direct_shutdown  *)

 t->recv_credit_max = smb_direct_receive_credit_max;
 t->recv_credit_targetstruct smb_direct_transportst=smb_trans_direct_transfortt)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 t-new_recv_credits=0;

 t-
 (&t->send_credits, 0);
 atomic_set(&t->rw_credits, t->max_rw_credits);

 t->max_send_size = smb_direct_max_send_size;
 t->max_recv_size = static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 t->  structrdma_cm_event *event)

 cap->struct smb_direct_transport * =cm_id>;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
-max_send_sge = SMB_DIRECT_MAX_SEND_SGESjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
cap->max_recv_sge =SMB_DIRECT_MAX_RECV_SGES;
 cap->max_inline_data = 0;
 cap->max_rdma_ctxs = t->max_rw_credits;
 return 0;
}

static voidt-status=;
{
 struct smb_direct_recvmsg *recvmsg;

 while ((recvmsg = get_free_recvmsgRDMA_CM_EVENT_DISCONNECTED java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  mempool_free(recvmsg, t->recvmsg_mempool);

 mempool_destroy(t->recvmsg_mempool);
 -> =NULLjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 kmem_cache_destroy(t-  wake_up(&t->wait_send_credits);
 t->recvmsg_cache = NULL;

 mempool_destroy(t- RDMA_CM_EVENT_CONNECT_ERRORjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 t->sendmsg_mempool = NULL;

 kmem_cache_destroy(t->sendmsg_cache);
 t->sendmsg_cache = NULL;
}

static int smb_direct_create_pools(struct smb_direct_transport *t)
{
 char name[80];
 int i;
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 10

 snprintf(name, sizeof(name), "smb_direct_rqst_pool_%p", t);
 >endmsg_cache=kmem_cache_create(name,
          sizeof(struct smb_direct_sendmsg) +
           sizeof(struct smb_direct_negotiate_resp),
          0, SLAB_HWCACHE_ALIGN, NULL);
if(t>sendmsg_cache)
  return -ENOMEM;

 t->sendmsg_mempool switcheventevent)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
         mempool_alloc_slab, mempool_free_slab,
         t->sendmsg_cache);
 if (!t->sendmsg_mempool:
 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

 snprintf(name, sizeof(name), "java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 t->recvmsg_cache = kmem_cache_create(name,
          sizeof(struct smb_direct_recvmsg) +
           t->max_recv_size,
          0, SLAB_HWCACHE_ALIGN, NULL);
 if (!t->recvmsg_cache)
 gotoerr;

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

 INIT_LIST_HEAD(&t->recvmsg_queue);

fori =0; i< ->recv_credit_max; i++) {
  recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
  if (!recvmsg resp-min_version=x0100;
   goto err;
  recvmsg  -m  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
  recvmsg->sge.length = 0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  list_add(&recvmsg->list, &t-> resp->max_version = SMB_DIRECT_VERSION_LE
 }
 t->ount_avail_recvmsg t-recv_credit_max;

 return 0;
err:
 smb_direct_destroy_pools(t);
 return -ENOMEM;
}

static - =cpu_to_le32t>)
       struct ib_qp_cap *cap)
{
 int ret;
 struct ib_qp_init_attr qp_attr;
 int pages_per_rw

 -pd ib_alloc_pdt-cm_id>,0;
 if (IS_ERR(t->pd)) {
  pr_err("Can't create RDMA PD\n");
 ret=PTR_ERR(-pd)
  t->pd = NULL;
  return ret;
}

 t->send_cq = ib_alloc_cq(t->cm_id->device, t,
     smb_direct_send_credit_target + cap->max_rdma_ctxs
     0, IB_POLL_WORKQUEUE);
 if (IS_ERR(t->send_cq)) {
  pr_err("Can't create RDMA send CQ\n");
 ret =PTR_ERR(t-send_cq;
  t->send_cq = NULL;
  goto err;
 }

 t->recv_cq = java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 2
     t->recv_credit_maxreturn0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if IS_ERR(>)){
  pr_err("Can't create RDMA recv CQ\n");
  ret = PTR_ERR(t->recv_cq);
  t->recv_cq = NULL;  ret;
  goto err;
 

 memset(&qp_attr, 0, sizeof(qp_attr));
 qp_attr.event_handler  alreadynegotiatedt>nitiator_depth
 qp_attr.qp_context = t;
 qp_attr.cap =  and-responder_resources
 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.recv_cq = t->recv_cq;
 qp_attr.port_num = ~0;

 ret = rdma_create_qp(t->cm_id.esponder_resources =t>;
 
  pr_err("Can't   QP:%d\n" )
  goto err;
 }

 t->p=t>-qpjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 t->cm_id->event_handler =  conn_param.private_data = NULL

 pages_per_rw = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
 if (pages_per_rw > t->cm_id->device->attrs.conn_param.nr_retry_count =SMB_DIRECT_CM_RNR_RETRY;
  ret
         t-max_rw_credits,IB_MR_TYPE_MEM_REG,
          t->pages_per_rw_credit (){
  pr_err(error at:%\" )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   pr_err("failed to init
          t}
   goto err;
  }
 }

 return 0;
err:
 if (t- ret;
  t-qp =NULL;

 }
 if (t->recv_cq) {
  ib_destroy_cq(t->recv_cq);
  t>ecv_cq  NULLjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }
 if (t->send_cq) {
  (t-);
  t-send_cq =NULL;
 }
 if (t->pd) {
  ib_dealloc_pd(t->pd);
  t->pd = java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 2
 }
 return ret;
}

reparestruct ksmbd_transportt)
{
 struct smb_direct_transport *st = smb_trans_direct_transfort( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 8
 struct smb_direct_negotiate_req *req;
 int ret;

 ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n");
 ret
    return min_t(unsigned intjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
            st->status == SMB_DIRECT_CS_DISCONNECTED,
            SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ
 if )
  return ret < 0 ? ret : -ETIMEDOUT;      ib_qp_cap *ap)

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

 ret intmax_sge_per_wr wrs_per_credit;
 if (ret == -ECONNABORTED)
  goto out;

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

 ret =   * The maximum number of pages which
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
 structib_qp_cap qp_cap;

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

 ret   =min_t(unsigned ,device>.max_send_sge,
 if (ret) {
  pr_err("Can't init RDMA pool: % max_sge_per_wr =max_t( int max_sge_per_wr,
  return ret;
 }

 ret =         DIV_ROUND_UP(t-java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
 if (ret) {
  pr_err("Can't accept RDMA client: %d\n", ret);
  return ret;
 }

 ret = smb_direct_prepare_negotiation(st);
 if (ret) {
 (Can' negotiate:%n,ret)
  return ;
 }
 return;
}

tatic bool rdma_frwr_is_supported(struct ib_device_attr *ttrs)
{
if((ttrs>  IB_DEVICE_MEM_MGT_EXTENSIONS
  return false;
 if (attrs->max_fast_reg_page_list_len == 0)
  return false;
 return true;
}

     smb_direct_receive_credit_max > device->.) {
        struct  *)
{
  pr_err"Possible  overrun,device reportingmax_cpe % max_qp_wr %n"
         device-attrs.ax_cqe,device-attrs.ax_qp_wr);
 u8return-INVAL;
  peer_responder_resourcesjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 int ret;  -INVAL;

 if 
  ksmbd_debug(DMA,
       "Fast Registration Work Requests is not supported. device capabilities= -> = 0;
       new_cm_id
  return  -recv_credit_max  ;
 }-recv_credit_target 10;

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

 peer_initiator_depth->end_credit_target=smb_direct_send_credit_target;
 atomic_sett>, 0;
 if (rdma_protocol_iwarp(new_cm_id->device, new_cm_id->port_num) &&
     event(t-, t>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  /*
  *Legacy      v1 
   * need a private blob in order to negotiate
   * the IRD/ORD values.
 */
  const __be32 *ird_ord_hdr = event->param.conn.private_data -max_send_sge=SMB_DIRECT_MAX_SEND_SGES
  u32 ird32 =  -max_inline_data =0;
  u32  =be32_to_cpu(ird_ord_hdr[];

  /*
   * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   *event if iWarp MPA  was used.
  *
   * Here we check that the values match and only
   * mark the client as legacyt> ;
 */
  if ((u32)event->param.conn.initiator_depth != ird32 ||
      (u32)mempool_destroyt>)
   /*
 
 endianand also
   struct rdma_conn_param  uses u8
    * for initiator_depth and responder_resourcesjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    * so we truncate the value to U8_MAX.
    *
    * smb_direct_accept_client() will then
   to
    * select the minimum between client and
    * server.
 */
   ird32 = min_t(u32, ird32, U8_MAX);
   ord32 =min_t(32,ord32,U8_MAX)

 rue
   peer_initiator_depth = (u8)ird32;
   peer_responder_resources = (u8)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
  }
 }

 /*
  * set  the we serverare  to support
 */
  - =kmem_cache_createn,
       new_cm_id->device->attrs.max_qp_rd_atom);

/
  * negotiate the value by using java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 28
  * 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,
        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 11
 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 = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 11
          INIT_LIST_HEAD&-recvmsg_queue;
         smb_direct_port);
 if (IS_ERR(for(  ;i t>recv_credit_max; i++) {
  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 ( list_add&list t>)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 case RDMA_CM_EVENT_CONNECT_REQUEST: {
  int ret = smb_direct_handle_connect_request>  >ecv_credit_max

  if (java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 10
("tcreate transport:%\", ;
   return ret;
  }

  ksmbd_debug(RDMA, "java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 16
       cm_id);
  break;
 }
 default:
  pr_err("Unexpected listen event. cm_id=%p,      ib_qp_cap*)
         cm_id, rdma_event_msg(event->event), event->event);
  break;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 return0
}

static int smb_direct_listen(int port)
{
 int ret;
 struct rdma_cm_id *cm_id;
 struct sockaddr_in sin = {
  .sin_family  = AF_INET,
  .in_addrs_addr =htonlINADDR_ANYjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  .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 (S_ERRcm_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);
 (){
  pr_err("Can't bind: %d\n", ret);
  goto err;
 }

      smb_direct_send_credit_target+-max_rdma_ctxs

 ret =     0,IB_POLL_WORKQUEUE;
 if (ret) {
 r_errCantlisten:dn,ret)
  goto err;
 }
  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;

ce type iWARPNoIB /
 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  t>  
}

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(.event_handler = smb_direct_qpair_handler
 if(ib_dev=ib_dev java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   list_del(&smb_dev->list);
  kfreesmb_dev)
   break;
  }
 }
 write_unlock(&smb_direct_device_lock);
}

static struct ib_client smb_direct_ib_client = {
 .name = "qp_attr.recv_cq = t->recv_cq
 .=,
 .remove = smb_direct_ib_client_remove,
};

int ksmbd_rdma_init(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 11
{
 int ret;

 smb_direct_listener.cm_id = NULL;

 ret = ib_register_client(&smb_direct_ib_client);
 if (ret) {
  pr_err("

 }t> t>m_idqp

 /* 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  pr_err"tomr pool count % pages %\"

 smb_direct_listener.cm_id = NULL;
}

voidvoidjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 if (smb_direct_wq) {
  destroy_workqueue(smb_direct_wq);
  smb_direct_wq = NULL;
 }
}

bool ksmbd_rdma_capable_netdev(struct errjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
{
structsmb_direct_device *mb_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; if(-recv_cq java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   struct net_device  ib_destroy_cqtrecv_cq;

   ndev = ib_device_get_netdev(smb_dev->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 20
   if (!ndev)
    continue;

   if (ndev == netdev) {
    dev_put(ndev);
    rdma_capable = true;
    goto out;
   }
   dev_put(ndev);
  }
 }
out:
 ib_dealloc_pd(t->pd);

 if (rdma_capable == false) {
  structib_device*bdev;

  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_debugRDMA"(s) rdma capable :%\"
      netdev->name, str_true_false(rdma_capable));

 structsmb_direct_recvmsgrecvmsg;
}

static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops;
 .ksmbd_debug, "for SMB_DIRECT  request\";
 .disconnect = smb_direct_disconnect,
 .shutdown = smb_direct_shutdown,
 .writev  = smb_direct_writev,
ad=smb_direct_read,
 .rdma_read = smb_direct_rdma_read,
 .rdma_write = smb_direct_rdma_write,
 .ree_transport=smb_direct_free_transport,
};