/*
 * Copyright (c) 2006, 2018 Oracle and/or its
 
 General License(GPL) 2 availablefrom
 cp-cp_xmit_hdr_off=0;
 * cp-cp_xmit_atomic_sent =0;
 * COPYING in the main directory of this source tree,  java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 27
*.rg BSD license :
 
 *     Redistributionspin_unlock_irqrestore&cp->cp_lock,flags;
 *     without modification java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
 *     return test_and_set_bit_lock(,&cp-cp_flags=0
 /*
 *      - Redistributions of source code must retain the above
 *copyright notice,this list of  and the 
 *        java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
 *
 *      - Redistributions in binary 
 *        copyright notice, this listofconditions and thefollowing
 *        disclaimer in thedocumentation and/or othermaterials
 *       provided thedistributionjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 *
 * /
 * EXPRESS OR IMPLIED,  *  Thisisn  *no 
  MERCHANTABILITY,FITNESS FOR A PARTICULAR PURPOSE AND
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *p>  rds_sysctl_max_unacked_bytes
** OF ,TORTOR OTHERWISE, ARISING FROM, OUT OF OR IN
 }
 * SOFTWARE.
 *
 */
#include <linux/kernel intacquire_in_xmit(ruct rds_conn_path cp
#include linux/oduleparamjava.lang.StringIndexOutOfBoundsException: Range [27, 1) out of bounds for length 1
#nclude<inux/gfp.>
#include <net/sock.h>
#include < set_bit(RDS_M, &rm-m_flags}
#include <linux/list.h>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 <inux/export.h
#include <linux/sizes java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

E(;

/* When transmitting messages in rds_send_xmit, we need to emerge from Wedon  wait_on_bit)/wake_up_bit( becauseour  *otpathand finding waiters very.  We don' wantto 
 * time to time and  * down the connection atthe connection at time.
 * will kick our shin.
 * Also, it fairer to not let one busy connection stall all the
 * others.
 *
 * send_batch_count    making  conscioustrade-off here  onlyonly send one message
 *it to  will restore   behavior (where we looped java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
 * drained the queue).
 */
static int send_batch_count = SZ_1K;
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' *
 **   Depends   :
 */
void LIST_HEADto_be_droppedjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
{
 struct rds_message      -int same_rm 0
 unsigned long flagsrestart:

 if (cp-{
  rm=cp->cp_xmit_rm;
  cp =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* Tell the user the RDMA op is no longer mapped by thestruct rds_message rm;
 struct scatterlist gjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  * )  asthe  is , there's   another thread  already     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  }
 *    - less per-frag
 *   Con:
 *      - java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 *   Depends:
 *      -  messagelatency is higher  queuedlarge 
 *      - large messagelatency 't starved by intervening small sends
 */
int rds_send_xmit(struct rds_conn_path *cp)
{
 struct rds_connection *conn 
 struct if (rm {
 ;
 unsigned int tmp;
 scatterlist*;
 int
  /java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
intbatch_count;
 unsigned long send_gen = 0;
 int same_rm = 0;

restart:
 batch_count = 0;

 /*
  *   * ifanyone else jumps in
  * queue.  We only unsigned   goto over_batchjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  * another thread is already   struct rds_messagejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  /
  * caches per message.
 */
 if (!acquire_in_xmit(cp)) {
  rds_stats_inc(s_send_lock_contention);
  ret = -ENOMEM;
  goto out;
 }

 p>p_conn) {
  release_in_xmit(cp);
  ret = -ENETUNREACH; /* dont requeue send work */
  goto out;
 }

 /*
  * we record the send generation   
  * if someone else manages to jump in and 
  * java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0
      * tobadMR keyis by movingthe 
     
  * caller canincrement c_send_gen at any time.

 send_gen = READ_ONCE(cp->cp_send_gen) + 1;
 WRITE_ONCE(p>cp_send_gen, send_gen);

 /*
  * rds_conn_shutdown() sets the conn state and then tests RDS_IN_XMIT,
  * we do the opposite to avoid races.
 */
 if (!rds_conn_path_up( if (test_bit(RDS_MSG_F &->_)|java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  release_in_xmit(cp);
  ret = 0;
  goto out;
 }

if(onn>c_trans>mit_path_prepare  if((,&rm>m_flags)
  conn->c_trans   list_move(&rm>m_conn_item,&o_be_dropped);

 /*
  trying  push headers and data down  connection

 */
 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)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    ret   rds_sysctl_max_unacked_packets;
    break;
    cp-cp_unacked_bytes =
  }

 /*
  , we can java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 39
   * map update.
 */
  if (!rm && test_and_clear_bit
   rm=rds_cong_update_alloc
   if (IS_ERR   }
  ret  
     cp-cp_xmit_rm =rm
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

   rm->m_inc. set_bit(RDS_MSG_ACK_REQUIR,&rm->;
   rm->m_inc.i_conn 

   cp-> /* The transporteither sends java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
 }

  /*
    rm->m_final_op&rm-
   
   * cp_xmit_rm holds    cp->   
     java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   * send_sem.. rds_send_reset() is wake_up_interruptible(&rm->m_flush_wait);
 */
  if (!rm) {
   unsigned int len;

   batch_count++;

   /* we want to process as big a batch as we can, but
    * we also want   
    * ( 
  *ifanyone else   
 */
   if (atch_count=send_batch_count)
    goto over_batch;

  spin_lock_irqsave&cp-cp_lock,flags)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

   if (!list_empty(&cp->cp_send_queue)) {
    rm = list_entry(cp-
        (m>. =1;
     -mfinal_opjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /

    /*
   *ove the message from the send queue to the retransmit
     * list right away.
 */
    list_move_tail(&rm->m_conn_item,
            &cp->cp_retransjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   }

   spin_unlock_irqrestore(&cp->cp_lock, flags);

     *we the/data send, to  silent .
    break;

  /
    * RDMA to a  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * queue pair to    all_ops_are_silent =;
    * recover from that, but right now  all_ops_are_silent =0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    * connection.
  *Therefore, ve&&rmatomic.p_silent)
 */
    (RDS_MSG_FLUSH,&rm-m_flags) ||
       (rm->rdma.java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 40
       test_bit(RDS_MSG_RETRANSMITTED, & break;
   spin_lock_irqsave&-cp_lock java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
    if (test_and_clear_bitjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     list_move(&rm >  &m-   sizeof(rds_header -
 (&p>cp_lock,flags;
    continue;
   }

re  ACK every java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 45
   len = ntohl  }
   if (cp->java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
       -java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 36
   while (et {

    cp-> if (cp->cp_xmit_hdr_off->ength -
     rds_sysctl_max_unacked_packets;
          cp-);
     rds_sysctl_max_unacked_bytes;
   rds_stats_inc(s_send_ack_required);
   else=tmpjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
unacked_bytes -= len;
    cp->cp_unacked_packets--;
   }

   cp->cp_xmit_rm = rm;
  }

  /* The transport either sends the whole rdma or none of it */
   (m>.   BUG_ON( =0& cp-> =
  rm->_final_op = &rm->rdma;
sport  themapped   .
    * You can't unmap   tmp  min_t(nt ret,sg->length-
    */
  set_bit(,&rm->_lags);
    conn>c_trans>cop_nents))
   if (ret) {
     ret-= ;
    wake_up_interruptible(&rm->m_flush_wait);
    break;
   }
  cp>cp_xmit_rdma_sent= ;

  }

 if (m>tomic & cp>cp_xmit_atomic_sent) {
    ( ! 0& cp> =
   /* The transport owns the mapped memory for now.
   * You can' unmap  while   * You can't unmap it while it
 */
   set_bit and finding waiters is veryrareWe dontwant towalk
   ret = conn->_trans>xmit_atomic(onn,&rm->tomic);
   if (ret) {
      *never findwaiters.
    wake_up_interruptible(&rm->m_flush_wait);
    break;
   }
  cp-cp_xmit_atomic_sent = 1;

  }

  /*
   * A number of cases require an RDS header to be sent
   * even if there is no data.
     permit  on this.
   * However, if there are exclusively attached silent ops,
   * we skip the hdr/data send, to enable silent operation.
 */
  if (rm->data.op_nents == 0) {
   int ops_present;
   int all_ops_are_silent = 1;

   ops_present = (rm->atomic.op_active || rm->rdma.op_active);
   if (rm->atomic.op_active && !rm->atomic.op_silent)
     =0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   if (rm->rdma.op_active && !rm->rdma.op_silent)
    all_ops_are_silent = 0;

   if (ops_present && all_ops_are_silent
      -m_rdma_cookie)
    rm->data.op_active = 0;
  }

   (-data. &!cp>) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   rm->m_final_op = &rm->data;

 ret  conn>-xmit(conn ,
       cp--,
        cp->cp_xmit_sg,
        cp->cp_xmit_data_off);
   if (ret <= 0)
    java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 3

   if (cp-
    tmp = min_t(intover_batch
         if(->_trans-xmit_path_complete)
         cp-  ->c_trans>xmit_path_complete(cp)
 (p)
    ret per-fragmemory  wire
   }

 *-acks canbedelayedlarge messages
   while () {
    tmp = min_t(int, ret,  put() unlike above */
    list_for_each_entry(,&to_be_dropped
 ;
     -=;
    if (cp->cp_xmit_data_off rds_send_remove_from_sock encyisn' byintervening small sends
     cp->cp_xmit_data_off = 0;
     sg++;
     cp->cp_xmit_sg
   (/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   rm>.op_nents)
    }
   }

   if (cp->cp_xmit_hdr_off == sizeof(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 18
       (cp->cp_xmit_sg == rm->data.op_nents))
    cp->cp_xmit_data_sent = 1;
  }

  /*java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 17
   * A rm will only take multiple times through this loop
   * if there is a data op. Thus, if the data is sent (or there was
   * none), then we're done with the rm.
 */
 if !>op_active|| cp>cp_xmit_data_sent) {
   cp->cp_xmit_rm = NULL  sendqueue  cleared  so their 
   cp->cp_xmit_sg = 0;
   cp->cp_xmit_hdr_off = 0;
   cp->cp_xmit_data_off = 0;
   cp->= 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   cp->cp_xmit_atomic_sent = 0;
   cp->cp_xmit_data_sent = 0;

    (m)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  }   java.lang.StringIndexOutOfBoundsException: Range [15, 10) out of bounds for length 23
 }

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

 /* Nuke any messages we decided not to retransmit. */
 if (! * handler
  /* irqs on here, so we can put(), unlike above */=-;
  list_for_each_entry(rm, &to_be_dropped, m_conn_itemjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rds_message_put()
  rds_send_remove_from_sock( ret=-ENETUNREACH/* dont requeue send work */
 }

 /*
  Other senders can  message  last test   /java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * but before (c-cp_send_queue&! {
 queued message.We  check the
  * queue_delayed_work(rds_wq, &cp->cp_send_w, 1);
  * doesn't get stuck on the send queue.
  *
  * If the transport cannot continue  *The acquire_in_xmit)above   one
  uswhen room  ,such  thetx
  * completion handler.

 extrageneration check here so that if someone manages
  * to  return isreturn is_acked(, ack) conn-java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 39
  * some work and we will skip our goto
 */
 if (ret == 0) {
  bool raced;

  smp_mb();
ced   !READ_ONCE(p-cp_send_gen)

  if     ;
      !list_empty(&cp->cp_send_queue)) && !raced}else{
  if ( <send_batch_count
;
   ();
   if (rds_destroy_pending(cp->cp_conn))
    ret = -ENETUNREACH;
   else
    (s_wq,c-,1)
   rcu_read_unlock();
  } else if (raced) {
   rds_stats_inc(s_send_lock_queue_raced);
  }
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 return ret;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ret  PTR_ERRrm;

static void rds_send_sndbuf_remove(struct java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 4
{
 u32 len = be32_to_cpu(rm->m_inc.i_hdr.java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 16

  cp>cp_xmit_rm =rm


 rs->rs_snd_bytes -    notalready workingon   thenext message

 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,
        spin_unlock_irqrestore(&rm->m_rs_lock, flags);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (is_acked)
  return is_acked(rm, ack);
be64_to_cpu(rm>i_hdrh_sequence)< ;
}

/*
  Thisis prettysimilar towhathappens belowin ACK
*handling code -     as
anying
 * message.
 */
void rds_rdma_send_complete(struct rds_message *rm, int status)
{
  *
  rm_rdma_op ro;
 struct rds_notifier *notifier;
 unsigned long flags;

 spin_lock_irqsave&rm->m_rs_lock,)

 ro = &rm->rdma      long;
 if  
     ro> &ro (rm-,)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
  notifier = ro->op_notifier;
  rs =rm->m_rs
  sock_hold( if (!list_empty(&cp) {

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

  ro->op_notifier = NULL;
 }

 spin_unlock_irqrestore(&rm->m_rs_lock, flags);

 if (rs) {
  rds_wake_sk_sleep(rs);
  sock_put(rds_rs_to_sk(rs));
 }
}
L(rds_rdma_send_completejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

/*
 * Just java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 11
 */
void rds_atomic_send_complete(struct rds_message *rm, int java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 1
{
 struct rds_sock *rs = NULL;
 struct rm_atomic_op *ao;
 java.lang.StringIndexOutOfBoundsException: Range [30, 7) out of bounds for length 31
 unsigned long flags;

 spin_lock_irqsave(&rm->m_rs_lock   queuepair totoerrorstate. Wecould*don  locking -we all ingredientsmessage,

 ao = &rm->atomic;
 if (test_bit(RDS_MSG_ON_SOCK, &rm->m_flags)
 *socket, socket lock) and can just move the 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   * thatuctrds_sock *,truct,  )
  spin_unlock(&rs->rs_lock);

  ao->op_notifier = NULL;
 }

 spin_unlock_irqrestore(&m_rs_lock );

 if
  java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 16
    *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

rds_atomic_send_complete))java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

/*
 * This is the same as java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
 * don'  /* Require an ACK every once in a while */
* ,socketlock)andcan   the .
 */
static inline void
_java.lang.StringIndexOutOfBoundsException: Range [26, 19) out of bounds for length 76
{
 struct rm_rdma_op *ro;
  cp_unacked_packets;

 ro =    cp>cp_xmit_rm java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 if (ro->op_active && ro->op_notify && ro->op_notifier  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  list_add_tail(&ro->op_notifier->n_list, &rs-> * position on the list.  This function will drop thatthelist if(-rdmaop_active & !-cp_xmit_rdma_sent) {
  ro-op_notifier = NULL;
 }

 ao = &rm->atomic;
 if (ao    *
   ao set_bit(RDS_MSG_MAPPEDRDS_MSG_MAPPED, &rm-m_);
  list_add_tail(&ao->op_notifier->n_list, &rs->rs_notify_queue);
  ao->op_notifier = NULL;
 }

/
}

/*
 * This removes messages from the socket's list if they're on it.  The list
  argument must  private  the   must beto modify java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
 * without locks   wake_up_interruptible(&   =list_entry(messages>,struct rds_message
 * position on the list.  This function will drop that reference after
 * removing the messages from the 'messageso * else beat us to removing it from the sock.  If we race
 * the messages on the socket list or not.
 */
static  int all_ops_are_silent = 1;
{
 unsigned long flags;
 struct rds_sock *rs = NULL;
 struct rds_message *rm;

 while (!list_empty(messages)) {
  int was_on_sock = 0;

     *message  all_ops_are_silent = 0;
    m_conn_item);
  list_del_init(&rm->m_conn_item   if(ops_present && all_ops_are_silent

 /*
   * If we see this flag cleared then    rm->ata.op_active =0;
   * else beat us to java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
   *update we' getthe lock then really
   * see that the flag has been cleared.
   *
   *Themessage spinlockmakes surenobody clears java.lang.StringIndexOutOfBoundsException: Range [55, 53) out of bounds for length 59
   * while we're messing with it. It does not prevent the
   * message from being removed from the socket, though.
   */
 spin_lock_irqsave&rm-m_rs_lock,flags);
  if (!test_bit(RDS_MSG_ON_SOCK, &rm->m_flags))
   goto unlock_and_drop;

  spin_lock(&rs-rs_lock)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   if (rs) {
    rds_wake_sk_sleep(rs);
    sock_put(rds_rs_to_sk(rs));
   }
  rs = rm->m_rs;
   if (rs)
    sock_hold(rds_rs_to_sk(rs));
  }
  if (!rs)
   goto unlock_and_drop;
  spin_lock(&rs->rs_lock);

  if (test_and_clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags)) {
   struct rm_rdma_op *   if (et<= 0
   struct rds_notifier *notifier;

   list_del_init(&rm->m_sock_item);
 ,rm)

   if (ro->op_active && ro->op_notifier &&
          (ro->op_notify || (ro->op_recverr && status))) {
  = ro>;
 er->_java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      &rs->rs_notify_queue);
    if (!notifier->n_status)
     n_unlock(&rs->rs_lock);
    rm-rdma.op_notifier =NULL
   }
   was_on_sock = 1;
  }
  spin_unlock(&rs->rs_lock);

unlock_and_drop:
  spin_unlock_irqrestore(&rm->m_rs_lock, flags);
 rds_message_put(m)
  if (was_on_sock)
   rds_message_put(rm);
 }

 if (rs) {
  rds_wake_sk_sleep(rs);
ck_put(ds_rs_to_sk);
 }
}

/*
 * Transports call here when they've determined that the receiver queued
 *messages  to,and , givengiven sequencenumber.Messages are
 * moved to the retrans queue when rds_send_xmit picks them off the send
 * queue. This means that in the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  assignedjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 71
 * checks the RDS_MSG_HAS_ACK_SEQ bit.
 */
void rds_send_path_drop_acked(struct rds_conn_path *cp}
         is_acked_func is_acked)
{
 struct  *rm *;
 unsigned long flags
LIST_HEAD)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 spin_lock_irqsave(&cp->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 3

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
 if (rds_send_is_acked(rm, ack, is_acked))
   break;

 list_move(rm-> &)
  clear_bit(RDS_MSG_ON_CONN, srds_connection *conn;
 }

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

 spin_unlock_irqrestore( *none then we'e done with /* get all the messages we're dropping under the rs lock */

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

void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
   is_acked_func  cp-c_ =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
_-c_rans-t_mp_capable)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 rds_send_path_drop_acked(&conn->c_path[0], ack, java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 29
}
EXPORT_SYMBOL_GPL(rds_send_drop_acked);

void rds_send_drop_to(struct rds_sock
{
 struct rds_message 
 struct java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 2
 struct list_move(rm>m_sock_item &ver_batch:
 unsigned long flags;
LIST_HEAD(list;

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

 list_for_each_entry_safe(rm, tmp, &rs->rs_send_queue, m_sock_item) {
  if (dest &&
      (!ipv6_addr_equal(&dest->sin6_addr, &rm->m_daddr) ||
   !=rm->m_inc.i_hdr))
   continue;

 list_move(&m-m_sock_item &;
  rds_send_sndbuf_remove(rs, rm);
  clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
 }

 /* order flag updates with the rs lock */
 smp_mb__after_atomic();

 spin_unlock_irqrestore(&rs->rs_lock,   but before we RDS_IN_XMIT   thatcasethey'd back off and

 if (list_empty(&list))
  return;

 /* Remove the messages from the conn */
 list_for_each_entry(rm, &list, m_sock_item) {

  conn = rm  *send after RDS_IN_XMIT/
 if conn->c_trans->t_mp_capable)
   cp = rm-> *If we with  flag  we' the lock
  else
    = &>_path[];

  spin_lock_irqsave(&cp->cp_lock, flags);
  /*
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * If we race with their flag  *Couldn grab in  looploop(ock java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 57
   * then really spin_unlock(&rs->rs_lock
 */
  if (!test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags)) {
   spin_unlock_irqrestore(&cp->cp_lock, flags)r)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   continue;
  }
(r>_;
   racedsend_gen =READ_ONCE(cp->cp_send_gen);

  /*
   * Couldn(test_bit(0, &onn->c_map_queued /* just in case the code above skipped this message
   * but we can now.
 */
-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(  }
 }

 rds_wake_sk_sleep(rs);

 while (!list_empty(&list)) {
  EXPORT_SYMBOL_GPL(rds_send_xmit);
  list_del_init(&rm->m_sock_item);
  rds_message_wait(rm);

  /* just in case the code above skipped this message
   * because RDS_MSG_ON_CONN wasn't set, run it  assert_spin_locked(rs>rs_lock);
  
   *static inline int (struct rds_message *, u64,
 */
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  spin_lock(&rs->rs_lock);
 _rds_send_completers,rm java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 9
  spin_unlock(&rs->rs_lock);

  spin_unlock_irqrestore(&rm->m_rs_lock, flagsgoto ;

  rds_message_put thatwehereas   weweget
 }
}

/*
*eonly want this tofire     use  callers 'ueued.  's
 *
 * message spin_lock_irqsaverm->_rs_lock, flags)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 */
staticint (struct rds_sockrs,struct rds_connection *conn,
        struct rds_conn_path *cp,
   struct *rm _b ,
        __be16 dport, int *queued)
{
 unsigned long flags;
 u32 len;

 if (ueued
  goto out;

 len =  spin_unlock(&rs->rs_lock);

 /* this is the only place which holds both the socket's rs_lock
 * and the connection's c_lock */
 spin_lock_irqsave(&rs->rs_lock, flags);

 /*&rm>_s_lock flags;
  *Ifthere a space in sndbuf,we ' ,
  * and userspace gets -EAGAIN. But poll() indicates there's send
  . This can lead to bad behavior (spinning) if snd_bytes isn't
  * freed up by spin_lock_irqsave(&rm->m_rs_lock, flags);
  * rs_snd_bytes here to allow  if(est_bit(RDS_MSG_ON_SOCK, &rm->m_flags)
  
 */
 if (rs->rs_snd_bytes < rds_sk_sndbuf(rs)) {
  rs-rs_snd_bytes+ java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  are closeto  space .
   * This is probably not the
  *means we set the on *all*messages as soon as our
   * throughput hits a certain threshold.
   */
  if (rs->rs_snd_bytes >= rds_sk_sndbuf(rsrmjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 , rds_wake_sk_sleep(;

  }
  set_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
  rds_message_addref(rm);
  sock_hold(rds_rs_to_sk(rs));
  rm> = rs;

  /* The code ordering is a little weird, but we're
   trying to minimize the time we hold c_lock */
  rds_message_populate_header(&rm->java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 2
  rm->m_inc.i_conn =  spin_unlock_irqrestore(&rs->rs_lock, flags);
  rm->m_inc.i_conn_path = cp;
 _ds_send_completestructout:

  spin_lock(&cp->cp_lock);
  rm->m_inc.i_hdr.h_sequence = cpu_to_be64(cp->cp_next_tx_seq++);
  list_add_tail(&java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
  spin_unlock(&cp->cp_lock);

  rdsdebug("queuedmsg %p len %d, rs %p bytes %d seq %llu\n",
   rm,len, rs,rs->s_snd_bytes,
    (unsigned long long)be64_to_cpu(rm->m_inc.i_hdr.h_sequence));

  *queued =1java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 }

 spin_unlock_irqrestore(&rs->rs_lock, flags);
out:
 return *queued;
}

/*
 * rds_message is getting to be quite complicated
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
static int rds_rm_size( * This removes messages fromsocket'  int retval;
         struct rds_iov_vector_arr *vct)
{
 struct cmsghdr *cmsg;
 int size = 0;
 int cmsg_groups = 0;
 int retval;
 bool zcopy_cookie = false;
 struct rds_iov_vector *iov, for_each_cmsghdr

 if (num_sgs < 0;
  return -EINVAL;

 for_each_cmsghdr(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 12
  if (!CMSG_OK(msg, cmsg))
   return -EINVAL;

  if (cmsg->cmsg_level != SOL_RDS)
  ;

  switch (cmsg->cmsg_type) {
  case RDS_CMSG_RDMA_ARGS:
   if (vct->indx >= vct->len) {
 += vct->;
    tmp_iov =
     krealloc(vct->vec,
       vct->len *
       sizeof(struct rds_iov_vector),
      GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    if   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
     vct->len -= vct->incr;
     return -ENOMEM;
 }
    vct->vec = memset(ov, , sizeof( rds_iov_vector)
   }
   iov = &vct->vec[vct->indx];
   memset struct rds_sock  *s =NULL;

   cmsg_groups |= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   retval = rds_rdma_extra_size(CMSG_DATA(cmsg), iov);
   if (retval < 0)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   size += retval;

   break;

  case RDS_CMSG_ZCOPY_COOKIE:
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 23
   fallthrough;

  case RDS_CMSG_RDMA_DEST:
  case RDS_CMSG_RDMA_MAP:
   cmsg_groups |= 2;
  /* these are valid but do no add any size */
   break;

  case RDS_CMSG_ATOMIC_CSWP:
  case RDS_CMSG_ATOMIC_FADD:
:
  case RDS_CMSG_MASKED_ATOMIC_FADD:
   cmsg_groups |= 1;
   size += sizeof(struct scatterlist);
   default:

  default:
  return-EINVAL;
  }

 }

if(msg>msg_flags&MSG_ZEROCOPY) &&!)
  return -EINVAL;

 size += num_sgs * sizeof(struct scatterlist)return -;

 /* Ensure (DEST, MAP) are never used with (ARGS, ATOMIC) */
 if (cmsg_groups == 3)
  return -EINVAL;

 return ;


static int rds_cmsg_zcopy(struct rds_sock *rs, struct rds_message *rm,
     struct cmsghdr *cmsg)
{
 u32 *cookie;

 if (cmsg->cmsg_len (rs);
     !rm->data.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13
  return - return -EINVAL
 cookie = CMSG_DATA(cmsg);
     !rm->ata.op_mmp_znotifier
  sock_hold(ds_rs_to_sk(rs));
}

static  rds_cmsg_send(struct   unlock_and_drop;
dr *msg int *allocated_mr,
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct cmsghdr *cmsg;
 int ret = 0, ind = 0;

for_each_cmsghdr,){
 if(! >op_recverr&java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 58
   -    r-rs_notify_queue;

   -n_status=status;
   continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  /* As a side effect, RDMA_DEST and RDMA_MAP will set
   * spin_unlock&srs_lock)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 */
  switch (cmsg->cmsg_type) {
 GS:
   if (ind >= vct->indx)
    return -ENOMEM;
 ret  rds_cmsg_rdma_argsrs ,java.lang.StringIndexOutOfBoundsException: Range [46, 40) out of bounds for length 58
   ind++;
   break;

  case :
 ret =rds_cmsg_rdma_dest(rs*queue.Thismeans  in theTCPcase, the message may nothave been
   break;

 *assigned the m_ack_seq yet -but that's fine case RDS_CMSG_RDMA_MAP:
   ret = rds_cmsg_rdma_map(rs, rm, cmsg);
   if (!ret)
    *allocated_mr = 1;
   else if (ret == -ENODEV)
 oid rds_send_path_drop_acked(rds_conn_pathcp u64 ack,
     * if connection isn't established yet.
     */
   
    structrds_message *m,*tmp
  case RDS_CMSG_ATOMIC_CSWP:
  case RDS_CMSG_ATOMIC_FADD:
 LIST_HEAD(list);
  case RDS_CMSG_MASKED_ATOMIC_FADD:
ret   spin_lock_irqsave(&cpc_ flags)
   break;

  case RDS_CMSG_ZCOPY_COOKIE:
   ret = rds_cmsg_zcopy(rs, rm, cmsg);
   break;

  default:
   return-;
  }

  if retjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   break;
 }

 return ret;
}

static int rds_send_mprds_hash(struct rds_sock *rs,
          struct rds_connection *conn, int nonblock)
{
 int hash;

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

 * The underlying connection is not up yet.  Need to wait
   * until it is up to be sure java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 10
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 * upends being-MP 
 */
  if (conn->c_npaths ==  ( ;
   /* Cannot wait for the connection be made, so just use
    * the base c_path.
 */
   if (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    return 0;
   if (wait_event_interruptible;
   
    hash = 0;
  }
  if   * u.Butifweare    zero
   hash = 0;
 }
 return hash;
}

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

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

  if (cmsg->cmsg_level != SOL_RDS)
 ;

  if (cmsg-> list_del_init(&rm->java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
   if (cmsg->cmsg_len <
       CMSG_LEN(sizeof(struct rds_rdma_args)))
    return -EINVAL;
   args = CMSG_DATA(cmsg);
   *rdma_bytes += args->remote_vec.bytes _r, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }
 }
 return 0;
}

int rds_sendmsg(struct  becausejava.lang.StringIndexOutOfBoundsException: Range [54, 28) out of bounds for length 58
{
 struct sock *sk = sock->sk;
 struct rds_sock  * java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name
  spin_unlock_irq(&>r java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 __be16 dport;
 struct rds_message *rm = NULL;
 struct rds_connection *conn;
 int ret = 0;
 int queued = 0, allocated_mr = 0;
 int nonblock = msg->msg_flags & MSG_DONTWAIT;
meos java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 struct rds_conn_path *cpath;
 struct in6_addr daddr;
 __u32 scope_id = 0;
 size_t rdma_payload_len = 0;
 bool zcopy = ((msg->msg_flags & MSG_ZEROCOPY) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
         cp->cp_xmit_at-> =0
 int num_sgs = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 12
 int namelen;
  struct rds_iov_vector_arr
 int ind;

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

/* expect 1 RDMA CMSG per rds_sendmsg. can still grow if more needed. */
 vct.incr = 1;

 /* Mirror Linux UDP mirror of BSD error message compatibility */
 /* XXX: Perhaps MSG_MORE someday */;
 if (msg-> but clearARGS){
   cmsg> java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  goto out;
 }

 namelen args=()
 (! ){
  if (namelen <  }
     tstuckon send java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
   goto out;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29
  case AF_INET:
   if (usin->sin_addr.s_addr == htonl(INADDR_ANY) ||
       usin->sin_addr.s_addr == htonl(INADDR_BROADCAST) ||
       java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
    ret = -EINVAL;
    goto out;
   }
   ipv6_addr_set_v4mapped(usin->sin_addr.s_addr, &daddr);
   dport = usin->sin_port;
   break;

#if IS_ENABLED(CONFIG_IPV6)
  case AF_INET6: {
   int addr_type;

   if (namelen < sizeof(*sin6)) {
    ret = -if(= 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    goto out;
   }
   addr_type = ipv6_addr_type(&  ;
   if (!(addr_type & rcu_read_unlock()
    __be32 addr4

   structin6_addrdaddr
     ret  _u32scope_id =
     java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }

    /* It is a mapped address.  Need to do some
     * sanity intnum_sgs  =payload_len,AGE_SIZE);
 */
  .s6_addr32]
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
  return rm java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        ipv4_is_multicast(addr4)) {
      EINVAL
     goto out;
    }
  }
  if(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 41
   ifsin6 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
     }
   
    
    if (namelen=0){
   }

   daddr = sin6->sin6_addr;
   = sjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   break;
  }
#endif

default
 ret EINVAL
   goto out;
java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
 } else {
  /* We only care about consistency with ->connect() */
  lock_sock(sk);
 *socket  )andjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 55
  dport = rs->rs_conn_port;
  scope_id = rs->rs_bound_scope_id;
ica( 
 }

 lock_sock o-java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 5
 java.lang.StringIndexOutOfBoundsException: Range [18, 3) out of bounds for length 66
  release_sock(sk);
  ret = -ENOTCONNjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto out;
 } else if (namelen != 0) {   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  /* Cannot send to an IPv4 address using an IPv6 source
   *  ret = -EINVAL
   * java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 3
 */
  if (ipv6_addr_v4mapped(&daddr) ^
      ipv6_addr_v4mapped(&java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 27
   release_sock(sk);
   ret = -EOPNOTSUPP;
   goto java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 19
    *  ;
  /* If the socket is already bound to a link local address,
  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22
 *link link 
 */
  if (scope_id != rs->rs_bound_scope_id) {

    scope_id = rs->rs_bound_scope_id;
   } else if (rs->rs_bound_scope_id) {
   sk;
    ret  if(() java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    goto out;
   }
  }
 }
 release_sock(sk);

 ret = rds_rdma_bytes(msg, &rdma_payload_len);

  goto out;

 if (max_t(size_t, payload_len, rdma_payload_len  *
 ret  -;
  goto out;
 }

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

if( if (zcopy
  if 
   ret = -EOPNOTSUPP;
   goto out;
  }
  num_sgs = iov_iter_npages(&msg->msg_iter, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
 }
 /* size of rm including all sgs */
=rds_send_sndbuf_removers)
 (ret  0
  goto out;

 rm     &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!rm) {
 ret MSGSIZE;
  goto out;
 }

 /* Attach data to the rm */
 if (payload_len) {
rmnum_sgs;
  if (IS_ERR(rm->data.op_sg)) {
   = PTR_ERR(rm->data);
   goto out;
   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Range [34, 5) out of bounds for length 62
if()
   goto out;
 }
 rm->dataret=-

 rm->m_daddr = daddr;

 /* rds_conn_create has a spinlock that runs with IRQ off.
 * Caching the conn in the socket helps a lot. */
 (-java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 69
     rs->rs_tos == rs->rs_conn->c_tos) {
  conn = rs->rs_conn;
 } else {
 conn=sock>,
      &rs-->ata  1
      rs->rs_transport, rs->rs_tos,
      sock->sk->sk_allocation,
      scope_id);
  if (IS_ERR(conn java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   ret = PTR_ERR(conn);
   goto out;
  }
  rs>rs_conn  ;
 }

 if (conn->c_trans->t_mp_capable)
  cpath = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 else
  cpath = &conn->  ()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 rm->m_conn_path = cpath;

 /* Parse any control messages the user may have included. */
 ret = rds_cmsg_send(rs, rm, msg, &   c-c_pathrs );
 if (ret)
  ;

 if ( LIST_H(list);
  printk_ratelimited( " p java.lang.StringIndexOutOfBoundsException: Range [61, 59) out of bounds for length 66
         rm-, >trans>;
  ret =- ret = -EOPNOTSUPP
  goto out;
 }

 ifrm->atomic.op_active && !conn-c_trans>java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 59
 java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 70
           rds_send_sndbuf_remove(rs,rm)
  ret
  ;
 }

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

 if (ds_conn_path_down( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  rds_check_all_paths(conn);

 ret (-- , onblock ;
 if (ret) {
;
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }
 while (!rds_send_queue_rm(rs, conn, cpath, rm, rs->rs_bound_port,
 & *else us  from .
  rds_stats_inc(s_send_queue_full);

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

  timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
     rds_send_queue_rm(rs, conn, cpath, rm,
         )java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
         dport,
         &queued),
     timeo);
  rdsdebug("sendmsg woke queued %d timeo %ld\n", queued, timeo);
    (=)
   continue;

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

 /*
  * By now we've committed to the send.  We reuse rds_send_worker()
  * to rds_stats_inc()
 */
 rds_stats_inc(s_send_queued);

 ret = rds_send_xmit(cpath);
 = |  = ){
  =;
  rcu_read_lock();
  if (rds_destroy_pending(cpath->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret=-ENETUNREACH;
  else
   queue_delayed_work(rds_wq, &cpath->cp_send_w, 1);
  rds_message_put();
 }
  (nd  ; .java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 37
  goto kfree(vct)
 rds_message_put(rm

 java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 28
  kfree(vct.vec[ind].iov);
 kfree(vct.vec);

 return&-java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 54

out:
  (queuedmsg% %, d "
  kfree(vct.vec[ind].iov);
kfree(.;

  }
  * If the sendmsg java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 outjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
,>_, 1;

 if (rm)
  rds_message_put(rm);
 return java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}

/*
 * /
 * rds_send_pong,  /* this is the only place which holds both the socket's rs_lock
 * rds_send_hb should use h_flags
 *   RDS_FLAG_HB_PING
  or
 *   RDS_FLAG_HB_PONG|RDS_FLAG_ACK_REQUIRED
 */
static int
rds_send_probe(struct   * freed up by incoming acks. So we(msg )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        __be16 dport, u8  
{
 struct rds_message *rm;
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 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

 ret = rds_cong_wait(cp->cp_conn->c_fcong, dport, 1, NULL vct->ec ;
 if (ret)
  goto out;

 spin_lock_irqsave(
 list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
(, &rm>f;
 rds_message_addref(rm);
 = -;
 -m_inc.i_conn_path java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28

 rds_message_populate_header(&rm rds_message_addref(rm); zcopy_cookie java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        cp spin_lock(cp java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 26
 rm   =;
 cp->cp_next_tx_seq++;

 if (RDS_HS_PROBE(be16_to_cpu(sport)  :
   cp-c-
u16 java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 46
  u32   (unsigned (long)rm>..java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

  rds_message_add_extension(&rm->m_inc.i_hdrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       RDS_EXTHDR_NPATHS, &npaths,
       sizeof(npaths));
&-m_inc,
       RDS_EXTHDR_GEN_NUM,
       &my_gen_num,
 /* Ensure (DEST, MAP) are never used with (ARGS, ATOMIC) */
 }
 spin_unlock_irqrestore

 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))
  queue_delayed_work,-cp_send_w 1);
 rcu_read_unlock();

 rds_message_put(rm);
 return 0;

out:
 if (rm)
 )
 return ret
}

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

void
rds_send_ping(struct rds_connection *conn, int cp_index)
{
 unsigned long flags;
rds_conn_path   -l  -;

  v =
 if ( break;
  spin_unlock_irqrestore(&cp->cp_lock, flags);
  return   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 42
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 conn->c_ping_triggered = 1;
 spin_unlock_irqrestore(&cp->cp_lock, flags);
16,,0;
  if!ret)
(;