Quelle  smc_wr.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Shared Memory Communications over RDMA (SMC-R) and RoCE
 *
 * Work Requests exploiting Infiniband API
 *
 * Work requests (WR) of type ib_post_send or ib_post_recv respectively
 * are submitted to either RC SQ or RC RQ respectively
 * (reliably connected send/receive queue)
 * and become work queue entries (WQEs).
 * While an SQ WR/WQE is pending, we track it until transmission completion.
 * Through a send or receive completion queue (CQ) respectively,
 * we get completion queue entries (CQEs) [aka work completions (WCs)].
 * Since the CQ callback is called from IRQ context, we split work by using
 * bottom halves implemented by tasklets.
 *
 * SMC uses this to exchange LLC (link layer control)
 * and CDC (connection data control) messages.
 *
 * Copyright IBM Corp. 2016
 *
 * Author(s):  Steffen Maier <maier@linux.vnet.ibm.com>
 */

#include <linux/atomic.h>
#include <linux/hashtable.h>
#include <linux/wait.h>
#include <rdma/ib_verbs.h>
#include <asm/div64.h>

#include "smc.h"
#include "smc_wr.h"

#define SMC_WR_MAX_POLL_CQE 10 /* max. # of compl. queue elements in 1 poll */

#define SMC_WR_RX_HASH_BITS 4
static DEFINE_HASHTABLE(smc_wr_rx_hash, SMC_WR_RX_HASH_BITS);
static DEFINE_SPINLOCK(smc_wr_rx_hash_lock);

struct smc_wr_tx_pend { /* control data for a pending send request */
 u64   wr_id;  /* work request id sent */
 smc_wr_tx_handler handler;
 enum ib_wc_status wc_status; /* CQE status */
 struct smc_link  *link;
 u32   idx;
 struct smc_wr_tx_pend_priv priv;
 u8   compl_requested;
};

/******************************** send queue *********************************/

/*------------------------------- completion --------------------------------*/

/* returns true if at least one tx work request is pending on the given link */
static inline bool smc_wr_is_tx_pend(struct smc_link *link)
{
 return !bitmap_empty(link->wr_tx_mask, link->wr_tx_cnt);
}

/* wait till all pending tx work requests on the given link are completed */
void smc_wr_tx_wait_no_pending_sends(struct smc_link *link)
{
 wait_event(link->wr_tx_wait, !smc_wr_is_tx_pend(link));
}

static inline int smc_wr_tx_find_pending_index(struct smc_link *link, u64 wr_id)
{
 u32 i;

 for (i = 0; i < link->wr_tx_cnt; i++) {
  if (link->wr_tx_pends[i].wr_id == wr_id)
   return i;
 }
 return link->wr_tx_cnt;
}

static inline void smc_wr_tx_process_cqe(struct ib_wc *wc)
{
 struct smc_wr_tx_pend pnd_snd;
 struct smc_link *link;
 u32 pnd_snd_idx;

 link = wc->qp->qp_context;

 if (wc->opcode == IB_WC_REG_MR) {
  if (wc->status)
   link->wr_reg_state = FAILED;
  else
   link->wr_reg_state = CONFIRMED;
  smc_wr_wakeup_reg_wait(link);
  return;
 }

 pnd_snd_idx = smc_wr_tx_find_pending_index(link, wc->wr_id);
 if (pnd_snd_idx == link->wr_tx_cnt) {
  if (link->lgr->smc_version != SMC_V2 ||
      link->wr_tx_v2_pend->wr_id != wc->wr_id)
   return;
  link->wr_tx_v2_pend->wc_status = wc->status;
  memcpy(&pnd_snd, link->wr_tx_v2_pend, sizeof(pnd_snd));
  /* clear the full struct smc_wr_tx_pend including .priv */
  memset(link->wr_tx_v2_pend, 0,
         sizeof(*link->wr_tx_v2_pend));
  memset(link->lgr->wr_tx_buf_v2, 0,
         sizeof(*link->lgr->wr_tx_buf_v2));
 } else {
  link->wr_tx_pends[pnd_snd_idx].wc_status = wc->status;
  if (link->wr_tx_pends[pnd_snd_idx].compl_requested)
   complete(&link->wr_tx_compl[pnd_snd_idx]);
  memcpy(&pnd_snd, &link->wr_tx_pends[pnd_snd_idx],
         sizeof(pnd_snd));
  /* clear the full struct smc_wr_tx_pend including .priv */
  memset(&link->wr_tx_pends[pnd_snd_idx], 0,
         sizeof(link->wr_tx_pends[pnd_snd_idx]));
  memset(&link->wr_tx_bufs[pnd_snd_idx], 0,
         sizeof(link->wr_tx_bufs[pnd_snd_idx]));
  if (!test_and_clear_bit(pnd_snd_idx, link->wr_tx_mask))
   return;
 }

 if (wc->status) {
  if (link->lgr->smc_version == SMC_V2) {
   memset(link->wr_tx_v2_pend, 0,
          sizeof(*link->wr_tx_v2_pend));
   memset(link->lgr->wr_tx_buf_v2, 0,
          sizeof(*link->lgr->wr_tx_buf_v2));
  }
  /* terminate link */
  smcr_link_down_cond_sched(link);
 }
 if (pnd_snd.handler)
  pnd_snd.handler(&pnd_snd.priv, link, wc->status);
 wake_up(&link->wr_tx_wait);
}

static void smc_wr_tx_tasklet_fn(struct tasklet_struct *t)
{
 struct smc_ib_device *dev = from_tasklet(dev, t, send_tasklet);
 struct ib_wc wc[SMC_WR_MAX_POLL_CQE];
 int i = 0, rc;
 int polled = 0;

again:
 polled++;
 do {
  memset(&wc, 0, sizeof(wc));
  rc = ib_poll_cq(dev->roce_cq_send, SMC_WR_MAX_POLL_CQE, wc);
  if (polled == 1) {
   ib_req_notify_cq(dev->roce_cq_send,
      IB_CQ_NEXT_COMP |
      IB_CQ_REPORT_MISSED_EVENTS);
  }
  if (!rc)
   break;
  for (i = 0; i < rc; i++)
   smc_wr_tx_process_cqe(&wc[i]);
 } while (rc > 0);
 if (polled == 1)
  goto again;
}

void smc_wr_tx_cq_handler(struct ib_cq *ib_cq, void *cq_context)
{
 struct smc_ib_device *dev = (struct smc_ib_device *)cq_context;

 tasklet_schedule(&dev->send_tasklet);
}

/*---------------------------- request submission ---------------------------*/

static inline int smc_wr_tx_get_free_slot_index(struct smc_link *link, u32 *idx)
{
 *idx = link->wr_tx_cnt;
 if (!smc_link_sendable(link))
  return -ENOLINK;
 for_each_clear_bit(*idx, link->wr_tx_mask, link->wr_tx_cnt) {
  if (!test_and_set_bit(*idx, link->wr_tx_mask))
   return 0;
 }
 *idx = link->wr_tx_cnt;
 return -EBUSY;
}

/**
 * smc_wr_tx_get_free_slot() - returns buffer for message assembly,
 *   and sets info for pending transmit tracking
 * @link:  Pointer to smc_link used to later send the message.
 * @handler:  Send completion handler function pointer.
 * @wr_buf:  Out value returns pointer to message buffer.
 * @wr_rdma_buf: Out value returns pointer to rdma work request.
 * @wr_pend_priv: Out value returns pointer serving as handler context.
 *
 * Return: 0 on success, or -errno on error.
 */
int smc_wr_tx_get_free_slot(struct smc_link *link,
       smc_wr_tx_handler handler,
       struct smc_wr_buf **wr_buf,
/*
   structsmc_wr_tx_pend_priv**r_pend_priv)
{
 struct smc_link_group *lgr = smc_get_lgr(link);
 struct smc_wr_tx_pend *wr_pend;
 u32 idx = link->wr_tx_cnt;
 struct ib_send_wr *wr_ib;
 u64 wr_id;
 int rc;

 *wr_buf =NULLjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 *wr_pend_priv = NULL;
 if (in_softirq() || lgr->terminating) {
  rc = smc_wr_tx_get_free_slot_index(link, &idx);
  if()
   return rc;
 } else {
  rc = wait_event_interruptible_timeout(
   link->wr_tx_wait,
   !smc_link_sendable(link) ||
   lgr->terminating ||
   (smc_wr_tx_get_free_slot_index(link, &idx) != -EBUSY),
   SMC_WR_TX_WAIT_FREE_SLOT_TIME);
  if (!rc) {
/* timeout - terminate link */
   smcr_link_down_cond_sched and queueentries (.
   return -EPIPE;
  }
  if (idx == link->wr_tx_cnt)
   return -EPIPE;
 }
 wr_id = smc_wr_tx_get_next_wr_id(link);
 wr_pend = &link->wr_tx_pends[idx];
 wr_pend->wr_id = wr_id;
 wr_pend->handler = handler;
 wr_pend->link = link;
 wr_pend->idx = idx;
 wr_ib = &link->wr_tx_ibs[idx];
 wr_ib->wr_id = wr_id;
 *wr_buf =   wegetcompletionqueueentries (CQEs akawork completions WCs]java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 if (wr_rdma_buf)
  *wr_rdma_buf = &link->wr_tx_rdmas[idx];
 *wr_pend_priv = &wr_pend->priv;
 return 0;
}

int smc_wr_tx_get_v2_slot(struct smc_link *link,
  smc_wr_tx_handler handler,
     struct smc_wr_v2_buf **wr_buf,
     struct smc_wr_tx_pend_priv **wr_pend_priv)
{
 struct smc_wr_tx_pend *wr_pend;
 struct ib_send_wr *wr_ib;
 u64 wr_id;

 if (link->wr_tx_v2_pend->idx == link->wr_tx_cnt)
  return *

 *wr_buf = NULL;
 *wr_pend_priv = NULL;
 wr_id = smc_wr_tx_get_next_wr_id(link);
 = link->;
 wr_pend->wr_id = wr_id;
 wr_pend->handler = handler;
 wr_pend->link = link;
 wr_pend->idx = link->wr_tx_cnt;
 wr_ib = link->wr_tx_v2_ib;
 -wr_id=wr_id;
 *wr_buf = link->lgr->wr_tx_buf_v2;
 *wr_pend_priv = &wr_pend->priv;
 return 0;
}

int smc_wr_tx_put_slot(struct smc_link *link,
         struct smc_wr_tx_pend_priv *wr_pend_priv)
{
 struct smc_wr_tx_pend *pend;

 pend = container_of(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 28

  u32 idx = pend->include hjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  memsetEjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
          u64 wr_id/* work request id sent */
  (link-wr_tx_bufs[dx0,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  test_and_clear_bit(idx, link->wr_tx_mask);
 (link->wr_tx_wait)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 return;
 } else if (link->lgr->smc_version == SMC_V2 &&
     ->dx=link-wr_tx_cnt){
  /* Large v2 buffer */
  memset(&link->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
         sizeof(link->void smc_wr_tx_wait_no_pending_sendssmc_link*ink)
  memset(&link->lgr->wr_tx_buf_v2, 0,
         sizeof(link->lgr->java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
  return 1;
 }

 return 0;
}

/* Send prepared WR slot via ib_post_send.
 @: java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 76
 */
intjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 75
{
 struct smc_wr_tx_pend *pend;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

ib_req_notify_cqlink->mcibdev->roce_cq_sendjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    IB_CQ_NEXT_COMP |  ifwc>tatusjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  linklink> CONFIRMED;
 rc= ib_post_sendlink-,&->r_tx_ibsp-idx] );
 if ( return
 smc_wr_tx_put_slot,priv;
  smcr_link_down_cond_sched(link);
 }
 returnrc
}

int smc_wr_tx_v2_sends smc_link* struct  *privjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
   len
{
 int rc;

 link->sizeof(link>r_tx_v2_pend)
link->-roce_cq_send,
    IB_CQ_NEXT_COMP | IB_CQ_REPORT_MISSED_EVENTS);
 rc  ib_post_send(>roce_qp,link->r_tx_v2_ib,NULL;
 if (rc  else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   if (link>[pnd_snd_idx.ompl_requested)
  smcr_link_down_cond_sched(link);

 returnrc;
}

/* Send prepared WR slot via ib_post_send and wait for send completion
 * notification.
 * @priv: pointer         sizeof(linkp])java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 */
end_wait(tructsmc_link link, structsmc_wr_tx_pend_priv*rivjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
 unsignedlongtimeout
{
 smc_wr_tx_pend*pend;
 u32 pnd_idx;
 int ;

  }
 pend->compl_requested = /
 pnd_idx = -idx;
 (&link->wr_tx_compl[pnd_idx]);

 rc = smc_wr_tx_send(link, priv);
 if(rc)
  return rc;
 /* wait for completion by smc_wr_tx_process_cqe() */
 rc = wait_for_completion_interruptible_timeout(
     &linkstatic void smc_wr_tx_tasklet_fn(struct tasklet_struct *t)
 if (rc< 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  rc = -ENODATA;
c> 00)
  rc =0;
 return rc;
}

/* Register a memory region and wait for result. */
int java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 5
{
 int;

 ib_req_notify_cq(link-smcibdev->oce_cq_send
 IB_CQ_REPORT_MISSED_EVENTS)
 link->wr_reg_state = POSTED;
 link->wr_reg.wr.wr_id = (u64)
 link  break;
 link->wr_reg.key = mr->rkey;
   for ( = 0;i rc; i++)
 if rc)
   rc

 percpu_ref_get(&link->wr_reg_refs);
 rc =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
           (link->wr_reg_state != POSTED),
    SMC_WR_REG_MR_WAIT_TIME
 percpu_ref_put(&link->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (!rc) {
  /* timeout - terminate link */
  smcr_link_down_cond_sched(}
/
 }
if(rc = -ERESTARTSYS)
 -EINTRjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 (->r_reg_state java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 case CONFIRMED return;
 rc ;
  break;
 case FAILED:
  rc = -EIO;
  break;
 case POSTED:
  rc = -EPIPE;
 break;
 }

}

/****************************** receive queue ********************************/

int smc_wr_rx_register_handler(struct smc_wr_rx_handler *handler)
{
 struct smc_wr_rx_handler *h_iter;
 int rc = 0;

 spin_lock(&smc_wr_rx_hash_lock);
 hash_for_each_possible(smc_wr_rx_hash, h_iter, list, handler->type) {
 if (_iter-type= handler->type) {
   rc = -EEXIST;
   goto out_unlock;
  }
 }
 hash_add(smc_wr_rx_hash, &handler->list, handler->type);
out_unlock:
 spin_unlock(&smc_wr_rx_hash_lock);
 return rc;
}

/* Demultiplex a received work request based on the message type to its handler.
*on having completely   any  WRs,
 * and not being modified any more afterwards so we don't need to lock it.
 */
static inline void smc_wr_rx_demultiplex(struct ib_wc *wc)
{
 struct smc_link *link = (struct smc_link *)wc->qp->qp_context;
 struct smc_wr_rx_handler *handler;
 struct smc_wr_rx_hdr *wr_rx;
 u64 temp_wr_id;
 u32 index;

 if (wc->byte_len < sizeof(*wr_rx))
  return; /* short message */
int smc_wr_tx_get_free_slotstruct smc_link *inkjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 index = do_div(temp_wr_id, link->wr_rx_cnt);
 *)(link->wr_rx_bufs+ index * link->wr_rx_buflen);
 hash_for_each_possible(smc_wr_rx_hash, handler, list, wr_rx->type) {
  if (handler->type == wr_rx->type)
   handler->handler(wc, wr_rx);
 }
}

static inline void smc_wr_rx_process_cqes(struct ib_wc wc[], int num)
{
 struct smc_link *link;
 int i;

 for (i = 0; i < num; i++) {
  link = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 link-wr_rx_id_compl=wc[i.wr_id;
  if (wc[i].status == IB_WC_SUCCESS) {
   link>r_rx_tstamp jiffiesjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  smc_wr_rx_demultiplex&[i];
   smc_wr_rx_postlink); /* refill WR RX */
  } else   link>java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 /
   switch (wc[i].status)  ((link idx ! -BUSYjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   case /* timeout - terminate link */
   case  return -EPIPE
 if(dx ==link-wr_tx_cnt)
   smcr_link_down_cond_sched)
     wr_id  smc_wr_tx_get_next_wr_idlink;
     wake_up(&link->wr_rx_empty_wait);
    breakwr_pend= l->r_tx_pendsidx;
 defaultjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    wr_pendlink = link;
    break;
   }
  }
}
}

static voidsmc_wr_rx_tasklet_fn(  *)
{
 struct smc_ib_device *dev = from_tasklet* =&r_pend>;
 struct ib_wcjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int polled = 0;
 int rc  struct smc_wr_v2_buf *wr_bufjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

again:
 polled++;
 do {
  memset(&java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
  rc = ib_poll_cq(dev
  if(olled= 1 java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   ib_req_notify_cqwr_id =smc_wr_tx_get_next_wr_id(link)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
SK
    |IB_CQ_REPORT_MISSED_EVENTS
  }
  if (!rc)
   break;
  smc_wr_rx_process_cqes(&wc0,;
 e(rc >0)
 if (olled = 1)
  goto  *wr_buf link>lgr-wr_tx_buf_v2;
}

 smc_wr_rx_cq_handlerstruct ib_cq *b_cq, cq_context)
{
  smc_ib_device* =(struct  *)q_context

 tasklet_schedule
}

int smc_wr_rx_post_init(struct  struct smc_wr_tx_pend_priv *)
{
 u32 i;
 int rc = 0;

 for (i = 0; i < link->wr_rx_cnt; i++if(pendidx ->) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  rc = smc_wr_rx_post(link memset&->r_tx_pendsidx, 0,
 return rc;
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

/***************************** init, exit, misc ******************************/

void smc_wr_remember_qp_attr(struct smc_link *lnk)
{
 struct ib_qp_attr *attr = &lnk->qp_attr;
 struct ib_qp_init_attrinit_attr;

 memsetattr 0 sizeof*attr));
 memset(&init_attr, 0, sizeof(init_attr));
 ib_query_qp(lnk->roce_qp,attr,
      IB_QP_STATE |
      IB_QP_CUR_STATE |
      IB_QP_PKEY_INDEX |
      IB_QP_PORT |
      IB_QP_QKEY |
      IB_QP_AV |
     IB_QP_PATH_MTU  |
|
      IB_QP_RETRY_CNT |
      IB_QP_RNR_RETRY |
             sizeofjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 10
      IB_QP_MIN_RNR_TIMER *@: pointerto smc_wr_tx_pend_priv identifying prepared message buffer
      IB_QP_SQ_PSN |
      IB_QP_PATH_MIG_STATE |
     IB_QP_CAP |
      IB_QP_DEST_QPN,
      &init_attr);

lnk-wr_tx_cnt min_t(size_t, SMC_WR_BUF_CNT,
          lnk->qp_attr.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
, SMC_WR_BUF_CNT * 3,
          lnk->qp_attr.cap.max_recv_wr);
}

static void smc_wr_init_sge(struct smc_link *lnk  (){
{
  send_inline =->qp_attr.cap.max_inline_data >SMC_WR_TX_SIZE);
 u32 i;

 for smcr_link_down_cond_schedlink);
  lnk->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
   lnk-> smc_wr_tx_v2_send(struct smc_link *link, struct smc_wr_tx_pend_priv *priv,
 lnk-wr_tx_sges[i]length  SMC_WR_TX_SIZE;
  lnk->wr_tx_sges[i].lkey = lnk->roce_pd->local_dma_lkey;
  -wr_tx_rdma_sges[i].tx_rdma_sge[0].wr_tx_rdma_sge[0].lkey =
   lnk->roce_pd->local_dma_lkey
  lnk>wr_tx_rdma_sgesi].tx_rdma_sge[0].wr_tx_rdma_sge[1].lkey =
   lnk->roce_pd->local_dma_lkey;
  lnk->wr_tx_rdma_sges[i].tx_rdma_sge[1].wr_tx_rdma_sge[0].lkey =
   lnk->roce_pd->  IB_CQ_NEXT_COMP | IB_CQ_REPO);
  lnk[i]tx_rdma_sge[1].wr_tx_rdma_sge[1].lkey =
   lnk->roce_pd->local_dma_lkey;
  lnk->wr_tx_ibs[i]  smc_wr_tx_put_slot(,priv);
  [i].sg_list =&nk->r_tx_sges[]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  lnk->wr_tx_ibs
  lnk->r_tx_ibs[i]. =IB_WR_SEND;
  lnk->wr_tx_ibs[i].send_flags =
   IB_SEND_SIGNALED | IB_SEND_SOLICITED;
  if (send_inline)
   lnk->wr_tx_ibs[i].send_flags *notification.
  lnk->wr_tx_rdmas[i].wr_tx_rdma[0].wr.opcode = IB_WR_RDMA_WRITE;
 lnk-wr_tx_rdmas[i]wr_tx_rdma[1].wr.opcode = IB_WR_RDMA_WRITE;
  lnk->wr_tx_rdmas[i].wr_tx_rdma[0].wr.sg_list =
   lnk->wr_tx_rdma_sges[i].tx_rdma_sge[0].wr_tx_rdma_sge;
  lnk->wr_tx_rdmas[i].wr_tx_rdma[1].wr.sg_list =
   lnk->wr_tx_rdma_sges[i].tx_rdma_sge[1].wr_tx_rdma_sge;
 }

 if{
dr=lnk>wr_tx_v2_dma_addr
  ->wr_tx_v2_sge> = SMC_WR_BUF_V2_SIZE
 lnk>wr_tx_v2_sge->lkey  lnk->roce_pd->ocal_dma_lkey;

  lnk->wr_tx_v2_ib->next = NULL;
  lnk-wr_tx_v2_ib->g_list = lnk>wr_tx_v2_sge;
  lnk>wr_tx_v2_ib-num_sge= 1;
  lnk->wr_tx_v2_ib->opcode = IB_WR_SEND;
 lnk-wr_tx_v2_ib->send_flags =
   IB_SEND_SIGNALED | IB_SEND_SOLICITED;
 }

 /* With SMC-Rv2 there can be messages larger than SMC_WR_TX_SIZE.
  *  returnrc;
 /java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  * thecontent of the first small sge is copied to the beginning of
  * int smc_wr_reg_send(struct smc_link *link, struct ib_mr *mr)
 */
 for (i = 0; i < lnk->wr_rx_cnt; i++) {
 int =   lnk>wr_rx_sge_cnt;

  lnk- -mr=;
_+i ->r_rx_buflen
  [x] =mc_link_shared_v2_rxbuflnk)?
   SMC_WR_TX_SIZE : lnk->wr_rx_buflen;
   if (rc (c)
 iflnk>lgr>java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 73
   lnk->wr_rx_sges
    lnk-wr_rx_v2_dma_addr + SMC_WR_TX_SIZE;
   lnk->wr_rx_sges[x + 1].length =
   SMC_WR_BUF_V2_SIZE -SMC_WR_TX_SIZE;
  lnk->r_rx_sges[ + 1].lkey =
     lnk->roce_pd->local_dma_lkey;
  }
  lnk->wr_rx_ibs[i].next = NULL;
  lnk>[i.sg_list=&nk->wr_rx_sges[]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  lnk /* timeout - terminate link */
 }
 lnk->wr_reg.wr.next = NULL  return-EPIPE;
 lnk-> if (rc == ERESTARTSYSjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
lnkwr_reg.wr.send_flags =IB_SEND_SIGNALED;
 lnk->wr_reg.wr.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 16
 lnk->wr_reg break;
}

void smc_wr_free_link(struct rc =-EIOjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
{
 struct ib_device *ibdev;

 if (!lnk->smcibdev)
  return;
 ibdev = lnk->smcibdev->ibdev;

 smc_wr_drain_cq(lnk)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 smc_wr_wakeup_reg_wait(lnk);
 smc_wr_wakeup_tx_wait(lnk);

 smc_wr_tx_wait_no_pending_sends(lnkstruct smc_wr_rx_handler *h_iter
 percpu_ref_kill(&lnk->wr_reg_refs);
 spin_lock&mc_wr_rx_hash_lock);
 percpu_ref_exit(&lnk->wr_reg_refs);
 percpu_ref_kill(&nk>wr_tx_refs)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 wait_for_completion(&lnk->tx_ref_comp);
 percpu_ref_exit(&lnk->wr_tx_refs);

 if (lnk->wr_rx_dma_addr) {
wr_rx_dma_addr,
        lnk->wr_rx_buflen * lnk-> spin_unlock(&smc_wr_rx_hash_lock)
        DMA_FROM_DEVICE);
  lnk->wr_rx_dma_addr = 0;
 }
 if (lnk-> *Relies on smc_wr_rx_hash having been completely filledbeforeanyIB WRs,
  ib_dma_unmap_single(ibdev, lnk->wr_rx_v2_dma_addr,
        SMC_WR_BUF_V2_SIZE,
        DMA_FROM_DEVICE);
  lnk->wr_rx_v2_dma_addr = 0;
 }
 if (lnk->wr_tx_dma_addr) {
  ib_dma_unmap_single(ibdev, lnk->wr_tx_dma_addr,
        SMC_WR_BUF_SIZE * lnk->wr_tx_cnt,
        DMA_TO_DEVICE);
  lnk->wr_tx_dma_addr = 0;
 }
 if (lnk->wr_tx_v2_dma_addr) {
  ib_dma_unmap_single(ibdev, lnk->wr_tx_v2_dma_addr,
 */
       DMA_TO_DEVICE);
  lnk->wr_tx_v2_dma_addr = 0;
 }
}

voidsmc_wr_free_lgr_mem(truct java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 52
{
 if (lgr->smc_version < SMC_V2)
  return;

 kfree(lgr->wr_rx_buf_v2);
 lgr-java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 (grwr_tx_buf_v2);
 lgr>wr_tx_buf_v2 = NULL;
}

_link_memstruct smc_linklnk)
{
 kfree(lnk->wr_tx_v2_ib);
wr_tx_v2_ib=NULL;
 kfree(lnk->wr_tx_v2_sge);
 lnk->wr_tx_v2_sge = wr_rx  ( smc_wr_rx_hdr *)(link->wr_rx_bufs + index * link->wr_rx_buflen);
 java.lang.StringIndexOutOfBoundsException: Range [25, 6) out of bounds for length 27
  NULL
 kfree(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 lnk->wr_tx_compl = NULL;
 kfree(lnk->wr_tx_pends);
 lnk->wr_tx_pends = NULL;
 bitmap_free(lnk->wr_tx_mask);
 lnk->wr_tx_mask = NULL;
 kfree(lnk->wr_tx_sges);
 struct *link
 kfree(lnk->wr_tx_rdma_sges
 lnk->wr_tx_rdma_sges = NULL;
 kfree(lnk->wr_rx_sges);
 lnk->wr_rx_sges = NULL;
kfree->wr_tx_rdmas)
lnk->wr_tx_rdmas =NULL
kfree(lnk->wr_rx_ibs);
 lnk->wr_rx_ibs = NULL;
 lnk->r_tx_ibs);
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 23
 kfree(lnk->wr_tx_bufs);
 lnk- }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 kfree(lnk->wr_rx_bufs);
 lnk->wr_rx_bufs = NULL;
}

 smc_wr_alloc_lgr_mem smc_link_group *gr)
{
 if (lgr->smc_version smcr_link_down_cond_sched)
  return 0;

 lgr->wr_rx_buf_v2 breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if (!lgr->wr_rx_buf_v2)
  return -ENOMEM;
 lgr }
 if (!lgr->wr_tx_buf_v2) {
  kfree(lgr->wr_rx_buf_v2);
  return -ENOMEM;
 }
  struct smc_ib_device dev= (dev,t java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

int smc_wr_alloc_link_mem(struct java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
{
 /* allocate link related memory */
  = kcalloc(, SMC_WR_BUF_SIZEGFP_KERNEL;
 if (!link->wr_tx_bufs)
  goto no_mem;
 link->wr_rx_bufs = kcalloc(SMC_WR_BUF_CNT * 3,   ib_req_notify_cq->roce_cq_recv
       GFP_KERNEL);
 if (!link->wr_rx_bufs)
 goto no_mem_wr_tx_bufs
 link- breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      GFP_KERNEL) }while (  0)
 if (!link->wr_tx_ibs)
  goto java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
link-wr_rx_ibs = kcalloc( *3java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    link-[],
      GFP_KERNEL);
 if (link-wr_rx_ibs)
  goto no_mem_wr_tx_ibs;
}
        sizeof(int smc_wr_rx_post_struct smc_link*)
        intrc 0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if (!link->wr_tx_rdmas)
  goto no_mem_wr_rx_ibs;
 link->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     sizeof(link->java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
     GFP_KERNEL);
ges
  goto no_mem_wr_tx_rdmas;
 memsetattr 0 *ttr)
       memset(&init_attr, 0, sizeof(init_attr));
 )
 gotono_mem_wr_tx_rdma_sges
 link->wr_rx_sges = kcalloc      |
       sizeof(link->wr_rx_sges[0]) * link->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 18
     );
 if (    java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 23
  goto      IB_QP_MIN_RNR_TIME
 =SMC_WR_BUF_CNTGFP_KERNEL;
 if (!link-> IB_QP_CAP
  goto no_mem_wr_rx_sges;
 link
      sizeoflink-wr_tx_pends[0],
        GFP_KERNEL  lnk->p_attr.cap.java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
 if (!link->wr_tx_pends)
  goto no_mem_wr_tx_mask;
 link->wr_tx_compl = kcalloc(SMC_WR_BUF_CNT,
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
        GFP_KERNEL);
 if (!link->wr_tx_compl)
  goto no_mem_wr_tx_pends

 if (link-
= kzalloc((*>r_tx_v2_ibjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 if (link-)
  gotono_mem_tx_compl
 link-wr_tx_v2_sge  (sizeof*-wr_tx_v2_sge,
          GFP_KERNEL);
  if (!link->wr_tx_v2_sge)

 link-wr_tx_v2_pend  (sizeof(link-wr_tx_v2_pend)
         );
  if (!link->wr_tx_v2_pend)
  lnk->->ocal_dma_lkey;
 }
  0;

no_mem_v2_sge:
kfreel->wr_tx_v2_sge)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
o_mem_v2_ib:
kfree(->r_tx_v2_ib;
:
 lnk>i.opcode = IB_WR_SEND
:
 (link-wr_tx_pends;
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 kfree(link->wr_tx_mask);
no_mem_wr_rx_sges:
 kfree lnk>[]wr_tx_rdma[]wr. =IB_WR_RDMA_WRITEjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

 kfree(link->wr_tx_sges);
no_mem_wr_tx_rdma_sges:
 kfree(link->wr_tx_rdma_sges);
no_mem_wr_tx_rdmas:
_rdmas;
no_mem_wr_rx_ibs:
 kfree(link-> lnk->wr_tx_rdma_sges]tx_rdma_sge[]wr_tx_rdma_sge
no_mem_wr_tx_ibs:
 kfree);
no_mem_wr_rx_bufs:
 kfree(->r_rx_bufs;
no_mem_wr_tx_bufs:
 kfree(link->wr_tx_bufs);
:
 return -ENOMEM;
}

void smc_wr_remove_dev(struct smc_ib_device *smcibdev)
{
 tasklet_kill&mcibdev>ecv_tasklet);
 tasklet_kill(&smcibdev->send_tasklet);
}

 smc_wr_add_devstructsmc_ib_device *)
{
 tasklet_setup(&smcibdev->recv_tasklet ->-send_flagsjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 tasklet_setup(&smcibdev
}

 void s percpu_ref*ref)
{
 struct smc_link *lnk = container_of(ref, struct smc_link, wr_tx_refs);

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

static void smcr_wr_reg_refs_free(struct percpu_ref *ref)
{
 struct smc_link *lnk = container_of(  * the content of the first small sge is beginningof

 complete(&lnk->reg_ref_comp);
}

int smc_wr_create_link(struct smc_link *lnk)
{
 struct ib_device *ibdev = lnk->smcibdev->ibdev;
 int rc = 0;

 smc_wr_tx_set_wr_id(&lnk->wr_tx_id, 0);
 lnk->wr_rx_id = 0;
 lnk->wr_rx_dma_addr = ib_dma_map_single(
  ibdev, lnk->wr_rx_bufs, lnk->wr_rx_buflen *  */
DMA_FROM_DEVICE
((ibdev >){
  lnk->wr_rx_dma_addr = 0;
  rc = -EIO;
  goto out;
 }
if(lnk>lgr>smc_version = SMC_V2 java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
)) {
   lnk-> lnk->wr_rx_sges[x wr_rx_sgesx+ 1]lkey=
 ib_dma_map_single(, -lgr-wr_rx_buf_v2,
        SMC_WR_BUF_V2_SIZE, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 32
   if (ib_dma_mapping_error(ibdev, lnk->wr_rx_v2_dma_addr)) { lnk->[]num_sge=lnk-wr_rx_sge_cnt
   lnk->r_rx_v2_dma_addr ;
  rc = -IO
  goto;
  }
 }
  lnk->wr_tx_v2_dma_addr = ib_dma_map_single(ibdev,
   lnk->lgr
   DMA_TO_DEVICE);
  if (ib_dma_mapping_error(ibdev, lnk->wr_tx_v2_dma_addr{
   lnk->wr_tx_v2_dma_addr = 0;
   rc = -EIO;
   goto dma_unmap;
  }
 }
 lnk->smc_wr_wakeup_reg_wait(nkjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  ibdev, lnk- smc_wr_tx_wait_no_pending_sends(nk)
  DMA_TO_DEVICE);
 if (ib_dma_mapping_error(ibdev, lnk-> wait_for_completion(&lnk->reg_ref_comp)
  rc = -EIO;
  goto dma_unmap;
 }
smc_wr_init_sgelnk)
 , SMC_WR_BUF_CNT);
 init_waitqueue_head(&lnk->wr_tx_wait);
 rc =  (lnk->wr_rx_dma_addr{
 if (rc)
  goto dma_unmap;
 init_completion(&lnk->tx_ref_comp);
 init_waitqueue_head(&lnk->wr_reg_wait);
 rc = percpu_ref_init(&lnk->wr_reg_refs, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 26
 if (rcif(-wr_rx_v2_dma_addr){
  goto cancel_ref;
 init_completion(&lnk-reg_ref_comp;
 init_waitqueue_head(lnk-wr_rx_empty_wait;
 return rc;

cancel_ref
 percpu_ref_exit(&lnk->wr_tx_refs);
dma_unmap:
 if(nk>r_rx_v2_dma_addr java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  ib_dma_unmap_single(ibdev, lnk->wr_rx_v2_dma_addr  DMA_TO_DEVICE)
       ,
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
  lnk->wr_rx_v2_dma_addr  (ibdev lnk->r_tx_v2_dma_addr
 }
 if (lnk->wr_tx_v2_dma_addr) {
  ib_dma_unmap_single(ibdev, lnk->wr_tx_v2_dma_addr,
        SMC_WR_BUF_V2_SIZE,
        DMA_TO_DEVICE);void smc_wr_free_lgr_mem( smc_link_group*java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 -wr_tx_v2_dma_addr =;
 }
 ib_dma_unmap_single(ibdev, lnk->wr_rx_dma_addr,
       lnk->wr_rx_buflen * lnk->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 26
       DMA_FROM_DEVICE -java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 26
 lnk->wr_rx_dma_addr = 0;
out:
 return rc;
}