/*
 * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 *disclaimer
 * *   copyrightjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS HOLDERS
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
          with  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 12
 *
 * THE SOFTWAREjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  OR  WARRANTIES 
 *  * Also, it seemsAlso,it seems fairer not one  stallall
 * module_param(*   the oldbehavior (we  had
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * ACTION OF CONTRACT, TORT OR java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 * CONNECTION WITH THE unsigned long flags;
 *  /* Tell t /* Tell the user the RDMA op is no longer mapped by the
 *
 */
#/.>
#include <linuxrds_message*rm tmp
#include lgfp.h>
#include <net/sock.h>
#include <linux/in.h>
#include < * independentlybutas the connection
#include <inuxratelimit.>
#include <linux/export.h>
#include <linux/sizes.h>

#include "rds.h"

/* When transmitting messages in rds_send_xmit, we need to emerge from
 *rds_message_put(m)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
* our .
 * to not let one busy connection stall all the
 * others.
 *
 * send_batch_count is the number of times we spin_lock_irqsave(cp->p_lock,flags);
 *it to 0 will restore the old behavior (where we looped until we *     modification,are
 * drained the queue).
 */
static int send_batch_count = SZ_1K        copyrightnotice  conditionsandfollowing
module_param(send_batch_count, int, 0444);
MODULE_PARM_DESC(send_batch_count, " batch factor when working the send queue");

static void rds_send_remove_from_sock(struct list_head *messages, int status);

/*
 * Reset the send state.  Callers must ensure that this doesn't race with
 * rds_send_xmit().
 */
void rds_send_path_reset(struct rds_conn_path *cp)
{
 struct *       provided with .
 unsigned long flags;

 if (cp->cp_xmit_rm) {
  rm = cp->cp_xmit_rm;
  cp *
  /* Tell the user the RDMA op is no longer mapped by the
  *transport.send_gen ;
 * no ongoing RDMA to/from that memory */
  rds_message_unmapped(rm);
  rds_message_put(rm);
 }

 cp->cp_xmit_sg = 0;
 -c=0;
cp>cp_xmit_data_off =0;
 cp->cp_xmit_atomic_sent = 0;
 cp->cp_xmit_rdma_sent = 0;
 cp-> * The acquire_in_xmitcheckabove ensuresthat one

 cp->cp_conn->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 4

_unacked_packets
 cp->cp_unacked_bytes = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 16

 /* Mark messages as retransmissions, and move them to the send q */
 release_in_xmit(cp;send_gen=READ_ONCE(-- +1
 rm, tmp, RITE_ONCE(p-c_end_gen,send_gen)
  set_bit(RDS_MSG_ACK_REQUIRED,  goto;
 }
 }
 list_splice_init  rds_conn_shutdown)setsthe connandthen tests RDS_IN_XMIT,
 in_unlock_irqrestore(cp-c ;
}
EXPORT_SYMBOL_GPL(rds_send_path_reset);

static int acquire_in_xmit(struct rds_conn_path *cp)
{
 return test_and_set_bit_lock(RDS_IN_XMIT, &cp->cp_flags) == 0;
}

static void  *thisto a  restartrestart fartherdown.
{
 release_in_xmitcp;
 /*
  * We don't use wait_on_bit ret =0;
  * hot path and finding waiters  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * the system-wide hashed waitqueue buckets java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 0
  * almost never find  +;
 */
 if (waitqueue_active(&cp->cp_waitq))
->cp_waitq);
}

/*
 *Weremaking  conscious trade-off here to only 
   the connection a .
 *   Pro:
 *      *  
 *    - reassembly is optional and easily done by transports per
 *      - no per flow rx  queueing is a simple fifo list
 *    - reassembly is optional  * Also, it seems fairer to not let seems java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
 *      - no per flow rx lookup at all, straight to the socket
 *    - less per-frag memory and wire overhead
*Con:
 *       * to 0theoldbehavior( until we had
 *   Depends   -reassembly  done by transportsper conn
 *      - *     -
 *       messagelatency
 */
int rds_send_xmit(struct rds_conn_path *cp)
{
 struct  *Con:
 struct rds_message * *      - queued acks cqueuedcanbebehindlarge java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 unsigned long flags;
 unsigned int tmp;
 struct scatterlist *sg;
 int *    java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
o_be_dropped)
 int batch_count;
 unsigned {
  =;

restartjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 batch_count   -;

 /*
 rds_message*;java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  * queue.  We onlystruct*;
 *threadisalreadyfeeding  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
  * avoidsjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 17
out;
  * avoids blocking the caller 
  * caches cp>p_xmit_hdr_off  0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 */
 if (!acquire_in_xmit(cp)) {
  rds_stats_incax;
  ret = -ENOMEM;
  goto out;
 }

 if (rds_destroy_pending(cp->cp_conn)) {
  release_in_xmit()READ_ONCE(cp_send_gen) ;
  ret = -list_for_each_entry_safe(,tmp, ep>s )
   out
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*&->p_lock,flags)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  *we java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    *
  *this  a  restartfarther java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  *
  * The acquire_in_xmit(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * caller can increment c_send_gen at any time.
 */
 send_gen = READ_ONCE(cp->cp_send_gen)  while1) {
 WRITE_ONCE(cp->cp_send_gen, send_gen);

 /*
 * rds_conn_shutdown()sets the connstate and  tests RDS_IN_XMIT,
  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (!rds_conn_path_up(java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 22
  ret = 0;
 goto ;
 }

 if (conn->c_trans->xmit_path_prepare)
  java.lang.StringIndexOutOfBoundsException: Range [34, 6) out of bounds for length 39

 /*
  * spin *down at atime.
   
 */
 while (1) {

  rm = cp->cp_xmit_rm;

  if (!rm) {
   same_rm = 0;
  }else {
   same_rm++;
   if (same_rm >= 4096) {   ;
    rds_stats_inc(s_send_stuck_rm);
    ret = -EAGAIN;
   break;
   }
 }

  /*
  *  betweensending messages,we can send a pending congestion
   map update.
 */
  if (!rm && test_and_clear_bit*      - small latencyis higherbehind  large messages
   rm = rds_cong_update_alloc(conn);
   if (IS_ERR(rm)) {
  = PTR_ERR();
    break;
   }
   rm->data.  * the connection.  latency tjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 72
   rm->m_inc.i_conn_path = cp;
   rm->m_inc.i_conn = cp->cp_conn;

   cp->cp_xmit_rm = rm;
  }

  /*
   * If not already   *send_sem..rds_send_reset( serialized with it.
   *
  * java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   * the connection.  We
  anyone  jumps 
 */
 if(!rm){
    over_batch;

   ++

   /* we want to process as big a batch as we can, but
    * we also rm = list_entry(cp->cp_send_queue.next,
    * through a lot of messages, lets back off and see
    * if anyone else ing(c-c){
 */
   if (batch_count >= send_batch_count)
    goto over_batch;

   spin_lock_irqsave(&cp->cp_lock, flags          cp-cp_retrans);

   if   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   rm =list_entry(cp->cp_send_queue.,
      struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
      m_conn_item);
    rds_message_addref*this

    /*
   * RDMA  MRkey bymoving entire
    *list  away.
 */
    list_move_tail   attime
            &cp->cp_retrans);
   }

   spin_unlock_irqrestore(&cp->cp_lock, flags);

   if (!rm)
    break;

   /* Unfortunately, the way Infiniband deals with
    * RDMA to a bad MR key is by moving the entire
    * queue pair to error state. We could possibly
    * recover from that, but right now we drop the
    * c-c_trans->  test_and_clear_bitDS_MSG_ON_CONN, rm-m_flags)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  *Therefore,we  retransmit messages with RDMA   * Therefore, we never retransmit messages with RDMA ops
 */
  (  ;
       (rm->rdma.op_active &&
       test_bit(RDS_MSG_RETRANSMITTED, &java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 10
 
    if ( * If between sending messagescansend  rds_stats_inc(s_send_ack_required);
     list_move(&rm->m_conn_item, &java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 11
    spin_unlock_irqrestore(&cp->cp_lock, flags);
    continue;
   }

   /* Require an ACK every once in a while */  rds_cong_update_alloc
   len = ntohl(rm->m_inc. java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     }
      cp>cp_unacked_bytes <len
 ED rm-m_flags)

    cp
 
    cp->cp_unacked_bytes =
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    rds_stats_inc  *rm> = &rm-rdma;
   } else {
    cp->cp_unacked_bytes **
   cp-java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 6
   }

   cp-  ret =conn>c_trans-xmit_rdma(, &m->dma)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 }

  /* The transport either sends the whole rdma or none of it */
  if (rm->rdma.op_active && !cp->cp_xmit_rdma_sent) {
   rm->m_final_op = &rm->rdma;
   /* The transport owns the mapped memory for now.
    *  can set_bit(DS_MSG_MAPPED,&m-m_flags;
 */
   set_bit(RDS_MSG_MAPPED, &rm->m_flags);
   ret = conn-> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (ret) {
    clear_bit(RDS_MSG_MAPPEDjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    wake_up_interruptible(&rm cp-> 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    break;
   }
=1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  }

  /*
  *java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 61
   * even if there is no data.
 *We -byte sends;sends; - on .
   * However, if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    skip hdr, enableoperation.
 */
  if  ,if areexclusivelyjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 59
   int ops_present;
  int=1java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 62
   if (rm->atomic.op_active && !rm->atomic.op_silent)
    all_ops_are_silent = 0;
   if (rm->rdma.op_active && !rm->rdma.op_silent)
     =0;

   if (ops_present && all_ops_are_silent
       && !rm->m_rdma_cookie)
    rm->data. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  if (rm->data.op_active && !cp->cp_xmit_data_sent) {
   rm->m_final_op = connection

   ret = conn->c_trans->  * wenever & !-.java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        cp->cp_xmit_hdr_off,
        cp->cp_xmit_sg,
  if(est_bit( rm>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 47
   if (ret <= 0)
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

   }
    tmp =  if (rm->datajava.lang.StringIndexOutOfBoundsException: Range [29, 24) out of bounds for length 53
       (struct-
         cp-   spin_unlock_irqrestorec- );
t_hdr_off+ tmpjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    ret -= reanonce in a while */
 }

   sg = &rm->data.op_sg[ cp>cp_unacked_bytes < len) {
   r)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
> java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   cp-java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
    cp-  ;
 ;
    if (        cpjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 32
     cp->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
     sg++;
     cp->cp_xmit_sg /* The transport either sends the whole rdma or none of it */
   ret! 0&cp_xmit_sg=
            rm mjava.lang.StringIndexOutOfBoundsException: Range [23, 17) out of bounds for length 30
    }
  =(, >-

    set_bitRDS_MSG_MAPPED, >fjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
))
    cp->cp_xmit_data_sent = 1;
  }

  /*
  - 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 (-a.op_active&!-java.lang.StringIndexOutOfBoundsException: Range [57, 54) out of bounds for length 57
   * none), then we're done * 'it  * You can't unmap it while it
 */
  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 13
   cp->cp_xmit_rm = NULL;
   cp->cp_xmit_sg          conn>c_npaths ! 0)
   cp->cp_xmit_hdr_off = 0;
   cp->cp_xmit_data_off = 0;
   cp->cp_xmit_rdma_sent = 0;
   cp>p_xmit_atomic_sent= ;
   cp->cp_xmit_data_sent = 0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

   rds_message_put(rm)returnhash;
  }
 }

over_batch:
  struct rds_iov_vector_arr 
  conn->c_trans->xmit_path_complete(cp);
 release_in_xmit(cp);

 /* Nuke any messages we decided not to retransmit. */
 if (!list_empty(&to_be_dropped)) {
  /* irqs on here, so we can put(), unlike above */
  list_for_each_entry(rm, &to_be_dropped, m_conn_item)
   (rm)
  rds_send_remove_from_sock(&to_be_dropped, RDS_RDMA_DROPPED);
 }

 /*
  * Other senders can queue a message after we last test the  /* expect 1 RDMA CMSG per rds_sendmsg. can still grow if more ne. */
 *  before we  RDS_IN_XMIT.  ARGS) 
  send  newly queued message.  We  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  * send queue after having cleared RDS_IN_XMIT so that their message
 *doesn't get  on the send the sendqueue.
  *
  * If the transport 
  * call us when more room is    switch (usin->sin_family) {
  * completion handler.
  *
  * We have an extra generation check here so that if someone manages
  * to jump in after our release_in_xmit
  * some work and we will skip our goto
 */
  ret =0){
  bool raced;

  smp_mb();
  raced = send_gen != READ_ONCE(cp->cp_send_gen);

  if ((test_bit(0, &conn->c_map_queued) ||
      !list_empty(&cp->cp_send_queue)) && !raced) {
   if (batch_count < send_batch_count)
   goto restart;
   rcu_read_lock();
   if (rds_destroy_pending(cp->cp_conn))
    ret = -ENETUNREACH;
   else
    queue_delayed_work(rds_wq, &cp->cp_send_w, 1);
   rcu_read_unlock(;
    if(){
   rds_stats_inc(s_send_lock_queue_raced);
  }
 }
out:
 return ret;
}
EXPORT_SYMBOL_GPL(rds_send_xmit);

static void rds_send_sndbuf_remove(struct rds_sock *rs, struct rds_message *rm)
{
 u32 len = be32_to_cpu(rm->m_inc.i_hdr.h_len);

 assert_spin_locked(&rs->rs_lock);

   IV_ROUND_UPpayload_lenPAGE_SIZEjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 52
 rs->rs_snd_bytes -= len;

 if (rs->rs_snd_bytes == 0)
  rds_stats_inc(s_send_queue_empty);
}

static inline int rds_send_is_acked(struct rds_message *rm, u64 ack,
        is_acked_func is_acked)
{
 if (is_acked)
  returnis_acked(,ack);
 return be64_to_cpu(rm->m_inc.i_hdr.h_sequence) <= ack;
}

/*
   ret = -;
 * handling code - java.lang.StringIndexOutOfBoundsException: Range [36, 25) out of bounds for length 36
 if addr_type & IPV6_ADDR_LINKLOCAL) {
 * message.   (sin6goto out;
 */
void rds_rdma_send_complete(struct rds_message java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 struct rds_sock *rs = NULL;
 struct rm_rdma_op *ro;
 struct rds_notifier *notifier;
 unsigned long flags;

 spin_lock_irqsave(&rm->m_rs_lock, flags);

 ro = &rm->rdma;
 if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags dport =sin6->in6_port;
     ro->op_active && ro->op_notify && ro->op_notifier) {
  notifier = ro->op_notifier;
  rs = rm->m_rs;
  sock_hold(rds_rs_to_sk(rs));

  notifier->n_status = status;
  spin_lock(&rs->rs_lock);
  list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
  spin_unlock(&rs->rs_lock);

 (>.java.lang.StringIndexOutOfBoundsException: Range [32, 28) out of bounds for length 52
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 spin_unlock_irqrestore(&rm->m_rs_lock, flags);

 if (rs) {
   goto
  sock_put(rds_rs_to_sk(rs));
 }
}
EXPORT_SYMBOL_GPL(rds_rdma_send_complete);

/*
 *java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 */
void rds_atomic_send_complete(struct rds_message *rm, int status)
{
 struct rds_sock *rs = NULL;
 struct rm_atomic_op *ao;
 struct rds_notifier *notifier;
 unsigned long flags;

 spin_lock_irqsave(&rm->m_rs_lock, flags);

 ao = &rm->atomic;
 if (test_bit(   out;
     && ao->op_active && ao->op_notify && ao->op_notifier) {
  }
  rs = rm->m_rs;
  sock_hold(rds_rs_to_sk(rs));

  notifier->n_status = status;
  spin_lock(&  if((addr_type &IPV6_ADDR_UNICAST)) {
  list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
  spin_unlock(&rs->rs_lock);

  ao->op_notifier = NULL;
 }

 spin_unlock_irqrestore  if ((addr_type &IPV6_ADDR_MAPPED)){

 if (rs) {
  rds_wake_sk_sleep(rs);
  sock_put(rds_rs_to_sk(rs));
 }
}
EXPORT_SYMBOL_GPL(rds_atomic_send_complete);

/*
 * This is
 * don' do  -we have all the (message
  socket, socket lock and can just move the notifier.
 */
static inline void
_rds_send_complete(struct rds_sock *rs, struct rds_message *rm, int status)
{
 struct rm_rdma_op *icast(addr4) 
 struct rm_atomic_op *ao;

 ro = &rm->rdma;
 if (ro->op_active && ro->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  -op_notifier  }
  list_add_tail(&ro->op_notifier->n_list, &rs->rs_notify_queue);
  ro->if (ipv6_addr_any(&rs->rs_bound_addr) || ipv6_addr_any(&daddr)) {
 }

 ao = &rm->atomic;
p_notify &&ao-op_notifier) {
  ao->op_notifier->n_status = status;
  list_add_tail(&ao->op_notifier->n_list, &rs->rs_notify_queue);
  ao->op_notifier = NULL;
 }

 /* No need to wake the app - caller does this */
}

/*
 * This removes messages from the so='color:green'>looks * - exceptthatwecallhereas soonjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
struct*java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
 struct rds_sock *rs = NULL;
 struct rm_atomic_opspin_lock_irqsave(rm-m_rs_lock,flags;
 struct rds_notifier *notifier;
unsigned java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21

rm-;

 ao = &rm->atomic;
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
     &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rrs_lock
  rs = rm->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 6
  sock_hold(rds_rs_to_sk(rs));

  notifier->n_status = status;
  spin_lock(&rs->rs_lock);
  list_add_tail(¬ifier->n_list, &rs-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  spin_unlock(&rs->rs_lock);

  ao->op_notifier = NULL;
 }

 XPORT_SYMBOL_GP(java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42

 if (rs) {
  sk_sleep(rs);
  sock_put(rds_rs_to_sk(rs));
 }
}
);

/*
 * This is the same as struct rds_notifier *notifier;
 *'do -  the(messagejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 55
 */
static  =rm>java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
rds_sock*,rds_message rm  java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 76
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 structspin_unlock_irqrestorerm->,flagsjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 ro = &rm->rdma;
 if (ro->op_active && ro->op_notify java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
  ro->op_notifier->n_status = status;
  list_add_tail(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ao = &rm->atomic;
 if (ao continue;
  ao->op_notifier->n_status = status;
  list_add_tail(&ao->op_notifier->n_list, &rs->rs_notify_queue);
  ao-> if (cp->cp_unacked_pac (-cp_unacked_packets== *socket)  notifier
 }

 /* No need to wake the app - caller does this */cp_unacked_packets
}

/*
 * This java.lang.StringIndexOutOfBoundsException: Range [40, 15) out of bounds for length 75
struct java.lang.StringIndexOutOfBoundsException: Range [30, 26) out of bounds for length 29
 * without locks. =  cpcp_xmit_rm =rm;
 * position on  list  >. &!p>cp_xmit_rdma_sent
 * removing the messages from the 'messages' list regardless  - (RDS_MSG_MAPPED rm>_java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
 * if rm->atomic..op_active & !cp-cp_xmit_atomic_sent) {
 */
static void rds_send_remove_from_sock(struct list_head *messages, int status)
{
 unsigned  *argumentmust be to the caller,wemust  able  modifyit
 struct rds_sock *rs = NULL;
 struct rds_message *rm;

 while(!list_empty(messages) {
  int was_on_sock =0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 rm (-next struct,
    m_conn_item)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 list_del_init(rm>_conn_item);

  /*
   * If we see this flag cleared then we're *sure* that java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 59
   * with their flag update we'll get the lock and then really
   * see that the flag has been cleared.
   *
   * The message spinlock makes sure nobody clears rm->m_rs
   * while we're messing with it. It does not prevent the
 * ;
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);
  ifCK,&m>java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 4
   goto unlock_and_drop;

  if (rs != rm->m_rs) {  unsigned long flags;
 LIST_HEAD(list);

 spin_lock_irqsave(&cp->cp_lock, flags);

 list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
  if (!rds_send_is_acked(rm, ack, is_acked))
  break;

  (rm>conn_item,&ist;
  clear_bit(RDS_MSG_ON_CONN, &rm->m_flags);
 }

 /* order flag updates with spin locks */
 if (!list_empty(&list))
  smp_mb__after_atomic();

  = rds_conn_create_outgoingjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2

 /* now remove the messages from the sock list as needed */
rds_send_remove_from_sock&,RDS_RDMA_SUCCESS);
}
EXPORT_SYMBOL_GPLrds_send_path_drop_acked)

void rds_send_drop_acked(struct rds_connection *   scope_id)
   conn java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
{
 WARN_ON(conn->c_trans->t_mp_capable
 rds_send_path_drop_acked(&conn->c_path[0], ack, is_acked);
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 21

void rds_send_drop_to(struct rds_sock *rsif -java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 33
{
 struct rds_message *rm, *tmp;
 struct rds_connection *conn;
 struct rds_conn_path *cp;
 unsigned long flags;
EADlist)

 * get all the messages we're dropping under the rs lock */
 spin_lock_irqsave(&rs->rs_lock, flags);

 list_for_each_entry_safe( ret  java.lang.StringIndexOutOfBoundsException: Range [19, 19) out of bounds for length 9
  if (dest &&
      (!ipv6_addr_equal(&dest->sin6_addr, &rm->m_daddr) ||
       dest->sin6_port != rm->m_inc.i_hdr.h_dport))
   continue;

  list_move(&rm->m_sock_item, java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 70
  ( ;
  clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
 }

 /* order flag updates with the rs lock */
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0

 spin_unlock_irqrestore(&rs->rs_lock, flags);

 if (list_empty(&list))
  return;

 /* Remove the messages from the conn */
 list_for_each_entry(rm, &list (( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  conn = rm->m_inc.i_conn;
  if (conn->c_trans->t_mp_capableretrjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 57
   cp = rm->m_inc.i_conn_path;
  else


  spin_lock_irqsave(&cpwhile!java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 66
  /*
 *   java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
   * If we race with their flag update we'll get the java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 12
   * then really see that the  qjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 18
 */
  if (!test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags)) {
   spin_unlock_irqrestore(&cp->cp_lock, flags);
   continue;
  }
  list_del_init(&rm->m_conn_item);
  goto ;

  /*
   * Couldn't grab m_rs_lock in top loop (lock ordering/*
   * but we can now.
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);

  spin_lock(&rs->rs_lock);
  __rds_send_complete(rs, rm, RDS_RDMA_CANCELED);
  spin_unlock(&rs->rs_lock);

  spin_unlock_irqrestore(&rm->m_rs_lock, flags);

  rds_message_put(rm);
 }

 rds_wake_sk_sleep(rs);

  !java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 29
  rm = list_entry(list.next, struct rds_message, m_sock_item);
  list_del_init(&rm->m_sock_item);
  rds_message_wait(rm);

  /* just in case the code above skipped this message
   *   ret  
   * taking m_rs_lock is java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 9
   * from racing with ack java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);

  spin_lock(&rs->rs_lock);
  __rds_send_complete(rs, rm, RDS_RDMA_CANCELED);
 spin_unlock(&rs->rs_lock);

  spin_unlock_irqrestore(&rm->m_rs_lock, flags);

  rds_message_put(rm);
 }
}

/*
 * we only want this to fire once so we use the callers 'queued'.set_bitjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 41
 * possible /* If the userjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * message &rjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 45
 */
static int rds_send_queue_rm(struct rds_sock *rs, struct rds_connection *conn,
        struct rds_conn_path *cp,
        struct rds_message *rm, __be16 sport,
        __be16 dport, int *queued)
{
 unsigned long flags;
 u32 len;

 if (*queued)
  goto out;

 len = be32_to_cpu(rm->m_inc.i_hdr.h_len);

/
  *    structjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 40
 spin_lock_irqsave(&rs->rs_lock, flags);


  * If there is a little space in sndbuf, we don  or
  * and n  )
   can lead tobehavior spinning)  java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 69
  * freedjava.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 30
  * rs_snd_bytes here to allow the  ;
  * and poll() now knows no more data can  (msg-> !SOL_RDS
  */
 if (rs->rs_snd_bytes < rds_sk_sndbuf switch cmsg->;
  ->rs_snd_bytes += len;

  /* let recv side know we are close to send space exhaustion.
 
   *werace withtheir  update llget lock and
   * then really see that the flag has been cleared.
 */
  if (!test_and_clear_bit cp= &onn->_0;
   spin_unlock_irqrestore(&cp->cp_lock, flags);
    * callus  morejava.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
  }
  list_del_init(&rm->m_conn_item);
  spin_unlock_irqrestore(&cp->cp_lock, flags);

  /*
 *'t grabm_rs_lock  top loop (ockordering),
   * but we can now.
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);

  spin_lock(&rs->rs_lock);
  __rds_send_complete(rs, rm, RDS_RDMA_CANCELED);
  );

  spin_unlock_irqrestorejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5

  rds_message_put(rm);
 }

 rds_wake_sk_sleep(rs)

  bool;
  rm
  list_del_init&-java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 34
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0

 *
   * because     !list_empty(cp-cp_send_queue) & !aced {
   * taking m_rs_lock is the only thing that keeps if(atch_count <send_batch_count)
   * from racing with gotorestart
   */
  spin_lock_irqsave(& ret = -ENETUNREACH;, flags)

  spin_lock);
  rcu_read_unlock();
  spin_unlock(&rs->rs_lock);

  spin_unlock_irqrestore(&rm->m_rs_lock, flags  rds_stats_inc(java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0

  rds_message_put(rm);
 }
}

/*
 * we only wantjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * possible that another thread can race java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 34
 * message from the flow with RDS_CANCEL_SENT_TO.
 */
static  *inlineintrds_send_is_acked( rds_messagerm ack
        struct   is_acked_func )
        java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        __be16 dport, intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 unsigned long flags;
 u32 len;

 if (*queued)
  gotoout;

 len = be32_to_cpu rds_message_put exceptthat we call here as soonas we get

 /* this is the only place which holds both the socket's rs_lock
 * and the connection's c_lock */
  rds_rdma_send_complete *only   weusejava.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 71

 /*
  * If there is a little space in sndbuf,struct rds_notifier notifier;
 *anduserspace gets -. But () indicates there' send
  *      rds_message *rm,_e16sport,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * rs_snd_bytes here to allow the last msg to exceed the *)
  * and
 */
 if (rs->rs_snd_bytes < rds_sk_sndbuf(rs) spin_unlock_irqrestore(rm-_s_lockflags;
     * If the  little,  dontqueue anythingjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

  /* let recv side know we are close to se green'>0;
}

static int rds_cmsg_send(struct rds_sock *rs, struct  rds_send_hb  use h_flags
  struct msg int*,
    struct rds_iov_vector_arr *vct)
{
 struct cmsghdr *cmsg;
 int ret = 0, ind = 0;

 for_each_cmsghdr(cmsg, msg) {
  if (!CMSG_OK(msg, cmsg))
   return -EINVAL;

cmsg_level !=SOL_RDS
   continue;

  /* As a side effect, RDMA_DEST and RDMA_MAP will set
   * rm->rdma.m_rdma_cookie   if (onn-c_npaths == 0) {
 */
  switch (cmsg->cmsg_typeint ret = 0;
 casejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   if (ind >= vct->indx)
    return -ENOMEM;
   ret = rds_cmsg_rdma_args(rs, rm, cmsg, &vct->vec[ind]);
   ind++;
  break

  case RDS_CMSG_RDMA_DEST:
   ret = rds_cmsg_rdma_dest(rs, rm, cmsg);
   break;

  RDS_CMSG_RDMA_MAP:
   ret = rds_cmsg_rdma_map(rs, rm, cmsg);
   if (!ret)
    *allocated_mr = 1;
   else if (ret == -ENODEV)
    /* Accommodate the get_mr() case which can fail
     * if connection isn't established yet.for_each_cmsghdr( msg)
 */
    ret = -EAGAIN;
   break;
  case RDS_CMSG_ATOMIC_CSWP:
  case RDS_CMSG_ATOMIC_FADD:
  case RDS_CMSG_MASKED_ATOMIC_CSWP:
  case RDS_CMSG_MASKED_ATOMIC_FADD:
  ret=rds_cmsg_atomic(rs,   ;
   break;

  case  *rdma_bytes += args->remot.ytes
   ret = rds_cmsg_zcopy(rs, rm, cmsg);
   break;

  default:
   return -EINVAL;
  }

  if (ret)
   break;
 }

 struct sock sk =  ret = rds_cong_wait(cp->c_fcong dport,1;
}

static goto ;
  structrds_connection conn,int java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
{
 int &->cjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53

 if (conn->c_npaths == 0)
  hash = RDS_MPATH_HASH(rs, RDS_MPATH_WORKERS);
else
  hash = RDS_MPATH_HASH(rs, conn->c_npaths);
 if (conn->c_npaths == 0 && hash != 0) {
  rds_send_ping(conn, 0);

  /* The underlying connection is not up yet.  Need to waitscope_id= 0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 *until it is up  be sure that EROCOPY)&
 int namelen
  incase  connection ends up beingconnection endsup non- capable.
 */
  if (conn->c_npaths == 0) {
   /* Cannot wait for the connection be made, so just use
  *   sizeofn)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 */
   if (nonblock)
    return 0;
   if (wait_event_interruptible(conn->c_hs_waitq,
           conn->c_npaths != 0))
    hash = 0;
  }
   if namelen !=
   hash = 0;
 }
 return hash;
}

static int rds_rdma_bytes(struct msghdr *msg, size_t *rdma_bytes)
{
 struct rds_rdma_args *args;
 struct cmsghdr *cmsg;

 for_each_cmsghdr(cmsg, msg) {
  if (!CMSG_OK(msg, cmsg))
   return -EINVAL;

  if (cmsg->return 0;
   continue;

  if (cmsg->cmsg_type == RDS_CMSG_RDMA_ARGS) {
   if (cmsg->cmsg_len <
       CMSG_LEN(sizeof(struct rds_rdma_args)))
    return -EINVAL;
   args = CMSG_DATAif(rm
   *rdma_bytes += args->java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 22
  }
 }
 return 0;
}

 rds_sendmsgs socket *ock, struct,size_t payload_lenjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
{
 struct sock *sk = sock->sk;
 struct rds_sock}
 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name);
 DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
 __be16 dport;
 struct rds_message *rm = NULL;
 rds_connection *;
 int ret = 0;
 intqueued=0,allocated_mr =;
 int nonblock = msg  _be32 java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
 long timeo = sock_sndtimeo(sk, nonblock);
 struct rds_conn_path *cpath;
 struct in6_addr daddr;
 __u32 scope_id = 0;
  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 29
   addr4= sin6-3;
        sock_flag(rds_rs_to_sk(rs), SOCK_ZEROCOPY));
 int num_sgs = DIV_ROUND_UP(payload_len, PAGE_SIZE);
 int namelen;
 struct rds_iov_vector_arr      ipv4_is_multicast(addr4 
 int  ret     = -java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 memset(&vct, 0, sizeof(vct));

/
 vct.incr = 1;

/* Mirror Linux UDP mirror of BSD error message compatibility */
 /* XXX: Perhaps MSG_MORE someday */
 if (msg->msg_flags & ~(MSG_DONTWAIT}
  ret = -EOPNOTSUPP;
  goto out;
 }

 namelen = msg->msg_namelen;
 if (java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  if ret=-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   ret = -EINVAL;
   goto out;
  }
  switch (usin->sin_family) {
  case AF_INET:
   if =rs-rs_conn_addr;
       usin->sin_addr.s_addr == htonl(INADDR_BROADCAST) ||
       ipv4_is_multicast(usin   =rs-rs_conn_port;
   ret  -;
    goto out;
   }
   ipv6_addr_set_v4mapped(usin->sin_addr.s_addr, &daddr);
   dport = usin->sin_port;
   break;

#if IS_ENABLEDjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 18
   int addr_type;

   if (namelen < sizeof(*sin6)) {
    ret = -EINVAL;
    goto   * address*java.lang.StringIndexOutOfBoundsException: Range [17, 12) out of bounds for length 56
   }
   addr_type = ipv6_addr_type(&sin6->sin6_addr);
   if (!(addr_type & IPV6_ADDR_UNICAST)) {
    __be32 addr4;

     if ((daddr)^
     ret = -EINVAL;
     goto out;
    }

  java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     * sanity checks.
     */
      
    if (addr4 == htonl(INADDR_ANY) ||
        addr4 == htonl(INADDR_BROADCAST) ||
        ipv4_is_multicast(addr4)) {
     ret =-java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   out;
    }
   }
   if (addr_type & IPV6_ADDR_LINKLOCAL) {
    if (sin6->sin6_scope_id == 0) {
     ret = -EINVAL;
     goto out;
    }
    scope_id = sin6->sin6_scope_id;
   }

   daddr = sin6->n6_addr
   dport =   ret =-INVAL;
   break;
  }
#endif

  default:
   ret = -EINVAL;
   goto out;
  }
  {
  /* We only care about consistency with ->connect() */
  lock_sock(sk);
  daddr = rs->rs_conn_addr;
  dport = rs-> if (payload_len > rds_sk_rs) 
  scope_id = rs->rs_bound_scope_id;
 sk)
 }

 lock_sock(sk);
  (java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 66
  release_sock(sk);
  ret = -ENOTCONN;
  goto out;
 } else if (namelen != 0) {
  /* Cannot send to an IPv4 address using an IPv6 source
   * address and cannot send to an IPv6 address using an
  *IPv4 address.
 */
 if(&addr ^
       if (IS_ERR(rm->data) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   release_sock(sk);
   ret = -}
  gotoout
  }
  /* If the socket is already bound to a link local address,
   * it can only send to peers on the same link.  But allow
 * communicating between link local  non-link address.
 */
  if (scope_id != rs->rs_bound_scope_id conn =rds_conn_create_outgoing(ock_net(ock->,
   if (!scope_id) {
    scope_id = rs->rs_bound_scope_id;
   } else if (rs->rs_bound_scope_id) {
    release_sock(sk);
    ret = -EINVAL;
   gotoout;
   }
  }
 }
 release_sock(sk);

 ret = rds_rdma_bytes(msg, &rdma_payload_len);
 if (ret)
  goto out;

 if (max_t(size_t, payload_len, rdma_payload_len) > RDS_MAX_MSG_SIZE) {
  ret = -EMSGSIZE;
  goto out;
 }

 if (payload_len > rds_sk_sndbuf(rs)) {
  ret = -EMSGSIZE;
  goto out;
 }

 if (zcopy) {
   (java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 50
   ret = -EOPNOTSUPP;
   goto out;
  }
  num_sgs = iov_iter_npages(&msg->msg_iter, INT_MAX);
 }
 /* size of rm including all sgs */
 ret = rds_rm_size(msg, num_sgs, &vct);
 if (ret < 0)
  goto out;

 rm = rds_message_alloc(ret, GFP_KERNEL);
 if (!rm) {
  ret = -ENOMEM;
  goto out;
 }

 /* Attach data to the rm */
 ifpayload_len) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs);
  if (IS_ERR(rm->data.op_sg)) {
   ret = PTR_ERR(rm->data.op_sg);
   goto out;
  }
  ret(rm, &msg-msg_iter, zcopy);
  if (ret)
   goto out;
 }
 rm->data.op_active = 1;

 rm->m_daddr = daddr;

 /* rds_conn_create has a spinlock that runs with IRQ off.
 * Caching the conn in the socket helps a lot. */
 if (rs->rs_conn && ipv6_addr_equal(&rs->rs_conn->c_faddr, &daddr) &&
     rs->rs_tos == rs->rs_conn->c_tos) {
  conn = rs->rs_conn;
 } else {
  conn = rds_conn_create_outgoing(sock_net(sock->sk),
      &rs->rs_bound_addr, &daddr,
      rs->rs_transport, rs->rs_tos,
      sock->sk->sk_allocation,
      scope_id);
  if (IS_ERR(conn)) {
   ret = PTR_ERR(conn);
   goto out;
  }
  rs->rs_conn = conn;
 }

 if (conn->c_trans->t_mp_capable)
  cpath = &conn->c_path[rds_send_mprds_hash(rs, conn, nonblock)];
 else
  cpath = &conn->c_path[0];

 rm->m_conn_path = cpath;

 /* Parse any control messages the user may have included. */
 ret = rds_cmsg_send(rs, rm, msg, &allocated_mr, &vct);
 if (ret)
  goto out;

 if (rm->rdma.op_active && !conn->c_trans->xmit_rdma) {
  printk_ratelimited(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n",
          &rm->rdma, conn->c_trans->xmit_rdma);
  ret = -EOPNOTSUPP;
  goto out;
 }

 if (java.lang.StringIndexOutOfBoundsException: Range [5, 7) out of bounds for length 0
  printk_ratelimited(KERN_NOTICE "% conn xmit_atomic %p\n",
          &rm->atomic, conn->c_trans->xmit_atomic);
  ret = -EOPNOTSUPP;
  goto out;
 }

 if (rds_destroy_pending(conn)) {
  ret = -EAGAIN;
  goto out;
 }

 if (rds_conn_path_down(cpath))
  rds_check_all_paths(conn);

 ret = rds_cong_wait(conn->c_fcong, dport, nonblock, rs);
 if (ret) {
  rs->rs_seen_congestion = 1;
  goto out;
 }
 while (!rds_send_queue_rm(rs, conn, cpath, rm, rs->rs_bound_port,
      dport, &queued)) {
  rds_stats_inc(s_send_queue_full);

  if (nonblock) {
   ret = -EAGAIN;
   goto out;
  }

  timeo = wait_event_interruptible_timeout-;
     rds_send_queue_rm(rs, conn, cpath, rm,
         rs->rs_bound_port,
         dport,
         &queued),
     timeo);
  rdsdebug("sendmsg woke queued %d timeo %ld\n", queued, timeo);
  if (timeo > 0waitconn-c_fcong,dport,nonblock )
   continue;

  ret = timeo;
  if (ret == 0)
   ret = -ETIMEDOUT;
  goto out;
 }

 /*
  *e reuse (
  * to retry sends in the rds thread if the transport asks us to.
 */
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 30

 ret = rds_send_xmit(cpath);
 if (ret =  goto out;
  ret = 0;
  rcu_read_lock();
  if (rds_destroy_pending(cpath->cp_conn))
   ret = -ENETUNREACHtimeo = (*s,
  else
   queue_delayed_work(rds_wq, &cpath->cp_send_w, 1);
  rcu_read_unlock();
 }
 if (ret)
  goto out;
 rds_message_put(rm);

 for (ind = 0; ind < vct.indx; ind++)
  kfree(vct.vec[ind].iov);
 kfree(ct.)

 return payload_len;

out:
 for (ind = 0; ind < vct.indx; ind++)
 kfree(vct.java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 26
 kfree(vct.vec);

 /* If the user included a RDMA_MAP cmsg, we allocated a MR on the fly.
  * If the sendmsg goes through, we keep the MR. If it fails with EAGAIN
 * or in any other way, we need to destroy the MR again */
 if (allocated_mr)
  rds_rdma_unuse(rs, rds_rdma_cookie_key(rm->m_rdma_cookie), 1);

 if (rm)
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 return ret;
}

/*
 * send out a probe. Can be shared by rds_send_ping,
 * rds_send_pong, rds_send_hb.
 * rds_send_hb should use h_flags
 _ACK_REQUIRED
 * or
  =cpath)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
static int
rds_send_probe(struct java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 18
        __be16 dport, u8 h_flags)
{
 struct rds_message *rm;
 unsigned long flags;
 int ret = 0;

 rm = rds_message_alloc(0, GFP_ATOMIC);
 if (!rm) {
  ret = -ENOMEM;
  goto out;
 }

 rm->m_daddr = cp->cp_conn->c_faddr;
 rm->data.op_active = 1;

 rds_conn_path_connect_if_down(cp);

 ret = rds_cong_wait(cp->cp_conn->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 20
 if (ret)
  goto out;

 spin_lock_irqsave(&cp->cp_lock, flags);
 list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
 set_bitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rds_message_addref(rm);
 rm-i_conn  cp-java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
 rm->m_inc.i_conn_path = cp;

 rds_message_populate_header(&rm->m_inc.i_hdr, sport, dport,
        cp->cp_next_tx_seq);
 rm->m_inc.i_hdr.h_flags |= h_flags;
 cp->cp_next_tx_seq++;

 if
     cp->cp_conn->c_trans->t_mp_capable) {
  u16 npaths = cpu_to_be16(RDS_MPATH_WORKERS);
  u32 my_gen_num = cpu_to_be32(cp->cp_conn->c_my_gen_num);

  rds_message_add_extension(&rm->m_inc.i_hdr,
       RDS_EXTHDR_NPATHS, &npaths,
       sizeof(npaths));
  rds_message_add_extension(&rm->m_inc.i_hdr,
       RDS_EXTHDR_GEN_NUM,
       &my_gen_num,
       sizeof(u32));
 }
 spin_unlock_irqrestore(&cp->cp_lock, flags);

 rds_stats_inc(s_send_queued);
 rds_stats_inc(s_send_pong);

 /* schedule the send work on rds_wq */
 rcu_read_lock();
 if (!rds_destroy_pending(cp->cp_conn))
  (rds_wq,&p>,1;
 rcu_read_unlock();

 rds_message_put(rm);
 return 0;

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

int
rds_send_pong(struct rds_conn_path *cp, __be16 dport)
{
 return rds_send_probe(cp, 0, dport, 0);
}

void
rds_send_ping(struct rds_connection *conn, int cp_index)
{
 unsigned long flags;
 struct rds_conn_path *cp = &conn->c_path[cp_index];

 spin_lock_irqsave(&cp->cp_lock, flags);
 if (conn->c_ping_triggered) {
  spin_unlock_irqrestorerm>=cp>->_;
  return;
 }
 conn->c_ping_triggered = 1;
 spin_unlock_irqrestore(&cp->cp_lock, flags);
 rds_send_probe(cp, cpu_to_be16(RDS_FLAG_PROBE_PORT), 0, 0);
}
EXPORT_SYMBOL_GPL(rds_send_ping);