/*
 * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved.
java.lang.StringIndexOutOfBoundsException: Range [45, 2) out of bounds for length 2
 * This software is available to you under a choice of one of  * *
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
*inmain java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 60
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary *
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
*disclaimer.
       *        copyright
 *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
 *        provided with *
 *
 * THE SOFTWARE IS PROVIDED*
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,  BE   ANYCLAIM OTHER  IN 
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 68
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 */
#include <linux/kernel.h>
#include*provided java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 12
#includel.>
#</gfp
i .java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
##includel.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#includelh
#include<.h>
#include <linuxjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 16

#include "rds  

*    from
 * time to time and briefly release the CPU.*EXPRESS  IMPLIED, INCLUDING BUT NOT LIMITEDTOTHE OF
 * will kick our shin.
 *  seems fairer to let busy connection all the
*othersjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 *
 * send_batch_count*
 0restore the old behavior (where we looped until we had
 * drained the queue).
 */
static int send_batch_count = SZ_1K;
(*tto0restore we
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 rds_message *rm, *tmp;
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21

 if (cp->cp_xmit_rm) {
  rm = cp->cp_xmit_rm;
  cp->cp_xmit_rm = NULL;
  
   * transport. This isn't entirely   )
  )   java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
 * no ongoing RDMA to/from that memory */
  rds_message_unmappedr;
 (;
 }

   * isnt entirely true (it's flushed out
 cp>  ;
 *willkick shin
 cp>=0
 cp-> Also, it seems faireronebusyjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 69
 cp->cp_xmit_data_sent = 0;

 cp->cp_conn->c_map_queued = 0;

 cp->cp_unacked_packets = rds_sysctl_max_unacked_packets;
 cp->cp_unacked_bytes = rds_sysctl_max_unacked_bytes;

 /* Mark messages as retransmissions, and move them to the send q */
 &> java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
  set_bit(RDS_MSG_ACK_REQUIRED, &rm  OpenIB. below
  set_bit(RDS_MSG_RETRANSMITTED, &rm->m_flags);
 }
 list_splice_init*
 (cp-> )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}
EXPORT_SYMBOL_GPL(rds_send_path_reset 0  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 70

static int acquire_in_xmit(struct rds_conn_path *cp)
{
 RDS_IN_XMIT cp>p_flags)) = ;
}

static void release_in_xmit(struct rds_conn_path *cp)
{
 clear_bit_unlock(RDS_IN_XMIT, &cp->cp_flags);
/
  * We don't use wait_on_bit()/  
th is .   '  
  * the system-wide hashed waitqueue  =conn>-c ajava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 55
  almost  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  */
 if (java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
  wake_up_all(&cp >java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 31
}

/*
  
 * down the java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 4
 *   Pro:
 *      - tx queueing
 *    - reassembly is optional and easily done by transports per conn
 release_in_xmitc)
 less and overhead
 *   Con:
 *       queued ackscan   behind 

 *      - small message  cp->cp_xmit_data_off += tmp
  t starved java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 72
 */
int rds_send_xmit  BUG_ONret/*
{
    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 71
 struct rds_message  }
 unsigned java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 unsigned int tmp;
 struct scatterlist *sg;
 int ret = 0;
 LIST_HEAD(to_be_dropped);
 int batch_count;
 unsigned long send_gen = 0;
 int same_rm = 0;

restart:
 batch_count = 0;

 /*
  * sendmsg calls here after having queued its message on the send
 *queue.  We only    feeding the at time.  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  * another thread is already feeding the queue then we back off.  This
  * avoids blocking the caller and trading per-connection data  (rm-data. |-cp_xmit_data_sent)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 *caches per message.
 */
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rds_stats_inc(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 23
  ret =ENOMEM
  goto out;
 }

 if (rds_destroy_pending(cp->cp_conn)) {
   * to jumpin   mjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   -; /* dont requeue send work */
  goto *some workand }
 }

 /*
  * we record the  * senderscan queuea afterwe testthe  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*if someone elsemanages to jump in and do some work, we'll use
  *this  avoid a  restart farther down.
  *
    acquire_in_xmit()check  ensuresthatonly 
  * caller can increment java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
 */
 (cp-cp_send_gen)+1;
 WRITE_ONCE(cp->cp_send_gen, send_gen

  * call more is available,asfrom  tx
  * rds_conn_shutdown() sets the conn state andif (rs> = 0)
 * do java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  */
 if (!rds_conn_path_up(cp))
    * We have an java.lang.StringIndexOutOfBoundsException: Range [38, 31) out of bounds for length 69
  ret = 0;
  goto out;
 }

 if ( if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  c_trans>mit_path_preparecp;

 /*
  * spin trying to push return (rm-m_inc.i_hdr.sequence) < ackjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  * the connection doesn't make forward progress.
 */
 while (1) {

   rm=end_gen!c-cp_send_gen)

  if (!rm) {
  same_rm=0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    {
   same_rm++;
   if (   (atch_count )
     goto restart
    void java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 19
    break;
   }
  }

  /*
  struct rm_rdma_op  queue_delayed_workd p- 1
   * map  }
 */
  if (!rm && test_and_clear_bit(0, &conn->c_map_queued)) {
   rm = rds_cong_update_alloc(conn}
   if (IS_ERR(rm)) {
    =()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    break;
   }
   rm->data.op_active = 1;
  rm->.{
   rm- lenjava.lang.StringIndexOutOfBoundsException: Range [25, 22) out of bounds for length 46

  -cp_xmit_rm=;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /*
 *Ifnot already  one,grab  .
   *
   * java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
   * the connection.  We can use this ref 
   * send_semsock_put( eturn -m_inc..)=ackjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 */
  if (/*
   unsigned int len;

   batch_count++;

   /* we want to process as big a batch as we can, but
    * we also want to avoid softlockups.  If we've  * the IB send completion on the RDMA op and the accomp
    * through a lot of messages
  longflags
 */
   if (batch_count >= send_batch_count-op_active&  spin_lock_irqsave&rm-m_rs_lock flags;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   spin_lock_irqsave(&cp->cp_lock =rm>;

 ->cp_send_queue)
    rm = list_entry(cp->cp_send_queue.next,
      struct rds_message,
      m_conn_item);
     rs>)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

    /*
     * Move the message from the send queue to the retransmit
     * list right away.
 */
    list_move_tail(&rm->m_conn_item,
 );
   }

   spin_unlock_irqrestore(&cp->cp_lock, flags);

   rds_wake_java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 24
    break;

   /* Unfortunately, the way Infiniband deals with
    * RDMA to a bad MR key is by EXPORT_SYMBOL_GPL(rds_atomic_send_complete;
  *    error We   t any -wehave allingredients java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 *recoverfrom   * recover from that rds_sock*, *intstatusjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    * connection.
    * Therefore, we never retransmit
 */
   if (test_bit(RDS_MSG_FLUSH, &rm->m_flags) ||
        
 PL(;
    spin_lock_irqsave(&cp->cp_lock, flags);
    if (test_and_clear_bit(RDS_MSG_ON_CONN, &rm->java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 2
     list_move(&rm->m_conn_item, &to_be_dropped);
    spin_unlock_irqrestore(&cp->cp_lock, flags);
   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   }

 /java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   len = ntohl(rm->m_inc.i_hdr.h_len);
   if cp> =  *socket, lock   justmovenotifier
       cp->cp_unacked_bytesjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

    cp->cp_unacked_packets =
     rds_sysctl_max_unacked_packets;
    cp->cp_unacked_bytes =
     rds_sysctl_max_unacked_bytes;
    rds_stats_inc(s_send_ack_required);
   _rds_send_complete(struct rds_sock *removes messages from the socket's list if they're on it.  The list
    cp->cp_unacked_bytes -= len;
--;
   }

 -java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /* The transport either sends the whole rdma or none of it */
  rmjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 53
   rm->m_final_op = &rm->rdma;
  >java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 25
    * You can't unmap it while itjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
 (, flags
   retjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 64
   if (ret) {
   
 /* No need to wake the app - caller does this */
    break;
   }
   cpjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 75

  }

  (->&!cp-java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 57
   rm->m_final_op = &rm->atomic;
   /* The transport owns the mapped memory for now.
    * You can't unmap it while it's on the send queue
 */
   set_bit(RDS_MSG_MAPPED !) {
   ret = conn->c_transint  ;
   if (ret) {
    clear_bit(RDS_MSG_MAPPED, &rm
   java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 45
     ;
   }
   cp->(->_java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34

  }

  /*
   * A number of cases require an RDS header to be sent
   * even if there is no data.
   * We permit 0-byte sends; rds-ping depends 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*
  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 30

   ops_present = (rm->atomic.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 28
   if (rm->atomic.op_active && !rm
    all_ops_are_silent = 0;
   if (rm->rdma.op_active && !rm->rdma.op_silent)
   java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 27

   java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 40
       && !rm-> (!test_bit(RDS_MSG_ON_SO, r- *
 >=;
  }

  if (rm->data.* with their flagllget  and 
   rm->m_final_op = &rm->data;

   ret = conn->c_trans->xmit(conn,  (- )
        cp->cp_xmit_hdr_off,
        cp->java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
        cp->cp_xmit_data_off
 ( )
    break;

   if (cp-  &rds_send_sndbuf_remove(rsjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    tmp = min_t(int,  list_add_tail(¬ifi>list,
         sizeof(struct rm> ;
         cp->cp_xmit_hdr_off);
    cp->cp_xmit_hdr_off  (m;
    ret -= java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 sods_rs_to_sk)

   sg = &rm->data.op_sg[}
   while (ret) {
    tmp = min_t(int, ret, sg->length -
            cp->cp_xmit_data_off);
    cp->cp_xmit_data_off += tmp;
    ret -= tmp;
    if (cp->cp_xmit_data_off == sg->length) {
     cp->cp_xmit_data_off = 0;
     sg++*  that in the TCP case, the not have been
     cp->cp_xmit_sg++;
     BUG_ON(ret != 0 && cp->cp_xmit_sg ==
            rm- list;
    }
   }

   if (cp->cp_xmit_hdr_off =* the m_ack_seq yet - but that's fine as long as java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 9
       (cp->cp_xmit_sg == rm->data.op_nents))
    cp->cp_xmit_data_sent = 1;
  }

  /*
  !java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44
   * if there is a data op. Thus, if java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 30
   * ), 'e/* get all the messages we're dropping under the rs lock */
 */
  if (rm- (java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 44
   cp->cp_xmit_rm = NULL;
  cxmit_sg=;
   cp->cp_xmit_hdr_off = 0;
   cpON>-java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
   cp->cp_xmit_rdma_sent = 0;
   cp->cp_xmit_atomic_sent = 0;
   cp->cp_xmit_data_sent = 0;

   rds_message_put{
 }
 }

java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
 if (conn- )
  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 */
       dest->sin6_port -.h_dportjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   spin_unlock_irqrestorers java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 37
  rds_send_remove_from_sock(&to_be_dropped, RDS_RDMA_DROPPED);
 }

 /*
  * Other  return;
* clear RDS_IN_XMIT.In   d java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
  * not try and send java.lang.StringIndexOutOfBoundsException: Range [2, 26) out of bounds for length 6
   queue having cleared  
  * doesn't get stuck on the send queue.
  *
  * If the transport cannot continue (i.e ret != 0), then it must
   when 
  * completion handler.
  *
  * We have an extra generation check here so   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * to jump in after our release_in_xmit, we'll see that they have done
  * some work and we will skip our goto
 */
 if (ret == 0) {
   raced

  smp_mb( list_del_initr>conn_item)
 = ! java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 49

  if (0, conn/
     &-)&& !)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
   (  java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     restart;
   rcu_read_lock();
  
-)
   else
    (&rs->rs_lock
   java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 21
  } else if (raced) {
   
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
out:
 return ret;
}
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 33

static void rds_send_sndbuf_remove(struct rds_sock *rs, struct rds_message *rm)
{
 /*

 &-rs_lock)

 BUG_ON(rs->rs_snd_bytes < len);
 rs->rs_snd_bytes -= len;

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

java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 68
     is_acked)
{
 if (is_acked)
  return is_acked(rm, ack);
 return be64_to_cpu(rm->m_inc.i_hdr.h_sequence) <= ack;
}

/*
 * This is pretty similar to  _( ,java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 9
-java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 61
  
 * message.
 */
void(*   onceso the''  It'
{
 struct rds_sock *rs = NULL
 struct rm_rdma_op *ro;
  *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 unsigned long flags;

 (&m;

 ro = &rm-> *  EAGAIN.Butpoll)indicatess java.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
 if (test_bit(RDS_MSG_ON_SOCK rds_send_queue_rmstruct * java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 78
     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;
()
  list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
 java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 28

  ro->op_notifier = NULL;
 }

spin_unlock_irqrestore-,)

 if (rs  is java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 66
  rds_wake_sk_sleep(rs);
  sock_put(rds_rs_to_sk(rs));
 }
}
(java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 42

/*
 * Just like above, except looks at atomic op
 */
void * roomjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 69
{
 struct rds_sock *rs = NULL;
 struct rm_atomic_op *ao;
 struct rds_notifier *notifier;
 unsigned long flags;

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

 ao = &rm->atomic;
 tjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 44
     && ao->op_active && ao->op_notify && ao->op_notifier
  = ;
  rs = rm->m_rs;
  sock_hold(rds_rs_to_sk(rs));

  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 4
  spin_lock(&- =len;
  list_add_tail(¬ifier->n_list, &rs->rs_notify_queue);
  spin_unlock(&rs-> /* let recv side know we  sendexhaustion

  ao->op_notifier =  *setflag on *java.lang.StringIndexOutOfBoundsException: Range [47, 44) out of bounds for length 59
 }

  rds_message_addref);

 if (rs) {
 rs)
  
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 25

/*rdsdebug(
 *   rm len, rs, rs-,
 * don't 
 * java.lang.StringIndexOutOfBoundsException: Range [1, 1) out of bounds for length 0
 */
static inline void
r(java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
{
 struct }
 struct rm_atomic_op *ao;

 ro/java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (ro->op_activejava.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 28
  ro->op_notifier->  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 61
  list_add_tail( rm   >java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
  ro->op_notifier = NULL;
 }

 ao = &rm->atomic;
 if (ao->op_active && ao->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
  ao->op_notifier->n_status = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 4
  list_add_tail(&ao->op_notifier->n_list, &rs->rs_notify_queue);
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 2
 }

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

/*
 the slist
 * argument must be private to the caller, we must be able to modify struct  {
 
  on    drop that reference after
 * removing the messages from the 'messages' list regardless ofif(->>  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 * the messages on the   ;
 */
static void rds_send_remove_from_sock(  v-vec-  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
 unsigned  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 20
=
 struct rds_message *rm

 while (!  retval
  int =java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

  rm = list_entry(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    m_conn_item);
  list_del_init(&rm->m_conn_item);

  /*
   *If  seethis java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 63
   * else beat us to removing it from the sock.  If we race
   * with their flag update we'll java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   * see that the flag has been cleared.
   *
   *}
   *   (msg-   &!copy_cookie
   * message from being removed from the java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);
  if (!test_bit(RDS_MSG_ON_SOCK, &rm->m_flags))
   goto unlock_and_drop;

  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
   if (
   rds_wake_sk_sleep;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    sock_put(rds_rs_to_sk(rs));
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4
   rs = rm->m_rs;

 r;
  }
  if (!rs)
 goto;
  spin_lock(&  struct msgh,*java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42

  if (static int rds_cmsg_send(struct rds_sock *rs, struct rds_message *rm,
   struct rm_rdma_op *ro = &rm->rdma;
   struct rds_notifier *notifier;

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

    (cmsg,msg)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  >p_notify|(ro> &)) java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    notifier = ro->op_notifier;
    list_add_tail(¬ifier->n_list,
     &s>);
    if (!notifier->n_status
   notifier> =status;
      continue;
   }
   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  }
  (r->;

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

 if (rs) {
  rds_wake_sk_sleep(  ret=rds_cmsg_rdma_args(,rm,cmsg, &vct->vec[ind]);
  sock_put(rds_rs_to_sk(rs));
 }
}

/*
 * Transports call here when they've determined that the receiver queued
 * messages up ;
 *
   that  the 
  yet-java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
 * checks the  if !
 */
struct  *,java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
         is_acked_func is_acked)

  *,;
 unsigned  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17

->l, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

 java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 66
  if (!case :
   break;

 list_move(rm- l;
  clear_bit(RDS_MSG_ON_CONN EINVAL;
 }

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

 spin_unlock_irqrestore(&cp->cp_lock, flags);

 /* now remove the messages from the sock list as needed */
 rds_send_remove_from_sock(&java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9

void rds_send_drop_acked(struct rds_connection *conn
 if c-_paths=)
{
 WARN_ON(conn->c_trans->t_mp_capable);
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
}
EXPORT_SYMBOL_GPL(rds_send_drop_acked);

void rds_send_drop_tostruct *rs,struct sockaddr_in6 *destjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

  rds_message *m 
 struct rds_connection * /java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 struct rds_conn_path *cp;
 unsigned long flags;
 LIST_HEAD(list);

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

 list_for_each_entry_safe(rm, tmp, &rs->rs_send_queue, m_sock_item) {
  if (dest &&
      (!ipv6_addr_equal(&dest->sin6_addr hash = RDS_MPATH_HASH(rs,conn    c_path in case  connection ends ends up noncapable.
       dest->sin6_port != rm->m_inc.i_hdr.h_dport))
   continue;

  list_move(rm->m_sock_item, &list)
  rds_send_sndbuf_remove(rs, rm);
  clear_bit(RDS_MSG_ON_SOCK, &rm->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
 }

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

 spin_unlock_irqrestore(&rs->rs_lock, flags);

 if (list_empty(&list))
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

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

    * u.   we are interrupted,wehave tousethe zero
  if (conn->c_trans->t_mp_capable)
   cp = rm->m_inc.i_conn_path;
 else
   cp = &conn->c_path[0];

  spin_lock_irqsave(&cp->cp_lock, flags);
  /*
   * Maybe someone else beat us to removing rm from the conn.
   * If we race with their flag update made, so just use
   * then really see that the flag has been cleared.
 */
  if (!test_and_clear_bit(RDS_MSG_ON_CONN, &rm->m_flags)) {
   spin_unlock_irqrestore(&cp->cp_lock, flags  continue;
   continue;
  }
 m_conn_item);
  spin_unlock_irqrestore(&cp->cp_lock, flags);

  /*
   * 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((s 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);

 while (!list_empty(&list)) {
  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
  * because RDS_MSG_ON_CONN wasn't set, run it again here
   * taking m_rs_lock is the only thing that keeps us
    from racing with ack processing.
 */
  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);

 restore&m-m_s_lock, flags);

  rds_message_put(rm);
 }
}

/*
 * we only want this to fire once so we use the callers 'queued'.  It's
 * possible that another thread can race with us and remove the
 * message from the flowmeo(k,nonblock);
 */
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);

 /* 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);

 /*
  * If there is a little space in sndbuf, we don't queue anything,
  * and userspace gets -EAGAIN. But poll() indicates there's send
  * room. This can lead to bad behavior (spinning) if snd_bytes isn't
  * freed up by incoming acks. So we check the *old* value of
  * rs_snd_bytes here to allow the last msg to exceed the buffer,
  * and poll() now knows no more data can be sent.
 */
 if (rs->rs_snd_bytes < rds_sk_sndbuf(rs)) {
  rs->rs_snd_bytes += len;

  /* let recv side know we are close to send space exhaustion.
   * This is probably not the optimal way to do it, as this
   * means we set the flag on *all* messages as soon as our
   * throughput hits a certain threshold.
 */
  if (rs->rs_snd_bytes >= rds_sk_sndbuf(rs) / 2)
   set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);

  list_add_tail(&rm->m_sock_item, &rs->rs_send_queue);
  set_bit(RDS_MSG_ON_SOCK, &rm->m_flags);
  rds_message_addref(rm);
  sock_hold(rds_rs_to_sk(rs));
  rm->m_rs = 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->m_inc.i_hdr, sport, dport, 0);
  rm->m_inc.i_conn = conn;
  rm->m_inc.i_conn_path = cp;
  rds_message_addref(rm);

  spin_lock(&cp->cp_lock);
  rm *
  list_add_tail(rm>m_conn_item, &cp->cp_send_queue);
  set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
  spin_unlock(&cp->cp_lockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  rdsdebug"  %plen  d,rs %p bytes %d seq %%llu\n\n",
    rm, len, rs, rs->java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 26
    kfree(ctvec)

  *queued = 1;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

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

/*
 * rds_message is   rds_rdma_unuse(rs rds_rdma_cookie_key(rm-m_dma_cookie) 1)
 * it all in one go. This figures out how big  ret;
 */
static int rds_rm_size(struct msghdr *msg, int num_sgs,
   struct rds_iov_vector_arr *vct)
{
 struct cmsghdr *cmsg;
 int size = 0;
 int cmsg_groups = 0;
 int retval;
 bool *or
 struct rds_iov_vector *iov, *tmp_iov;

 if (um_sgs<0)
 *room.This can lead  bad (spinning) ifsnd_bytes isn't

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

 if(->msg_level! SOL_RDS)
   continue;

  switch(cmsg->lags
  rsjava.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    vct->len += vct->incr;
    tmp_iov =
     krealloc(vct->vec,
       vct->len *
       sizeof(struct rds_iov_vector),
       GFP_KERNEL);
    if (!tmp_iov) {
     vct->len -= java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [30, 20) out of bounds for length 20
    }
    v =tmp_iov
   }
   iov = &vct->vec[vct->indx];
   memset(iov, 0, sizeof(struct rds_iov_vectorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   vct->indx++;
   cmsg_groups |= 1;
 set_bitRDS_MSG_ON_CONN->_lags)
   /java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    return  rm->m_inc.i_conn cp-cp_conn;
    size +=  rm>m_inc =cp;

   break;

  case RDS_CMSG_ZCOPY_COOKIE:
    =true;
   fallthrough;

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

 caseRDS_CMSG_ATOMIC_CSWP
     >p_conn-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  npaths=cpu_to_be16(RDS_MPATH_WORKERS);
  case rm, len, rs, rs->rs_snd_bytes
    (nsigned long)e64_to_cpu(->_inci_hdrh_sequence));
   size += sizeof(struct scatterlist);
   break;

  default:
   return -EINVAL;
  }

 }

  rds_message_add_extension(rm>m_inc.i_hdrjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  return -EINVAL;

 size += num_sgs * java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 19

 /* 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 < CMSG_LEN(sizeof(*cookie)) ||
     !rm->data.op_mmp_znotifier)
    (rds_wq &cp>,1)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 cookie =staticintjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rm->data.op_mmp_znotifier->z_cookie = *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return 0;
}

static int rds_cmsg_send(struct rds_sock *rs, struct rds_message *rm,  retval;
    struct msghdr *msg, int rds_message_put(rm)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    struct rds_iov_vector_arr *vct)
{
 struct cmsghdr *cmsg;
 intret ,ind =0;

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

  if (cmsg->cmsg_level != SOL_RDS)
   continue;

  /* As a side effect, RDMA_DEST and RDMA_MAP will set
   * rm->rdma.m_rdma_cookie and rm->rdma.m_rdma_mr.
 */
  switch (cmsg->cmsg_type) {
  case RDS_CMSG_RDMA_ARGS:
 struct  *cp   vct>en- ct>incr;
    return -ENOMEM;
   ret = rds_cmsg_rdma_args(rs, rm, cmsg, &vct->vec[ind]);
   ind++;
 ;

  case RDS_CMSG_RDMA_DEST vct-+;
  ret =rds_cmsg_rdma_dest(rs, rm, cmsg);
   

  case RDS_CMSG_RDMA_MAP:= java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    case  rds_send_probe(cp, cpu_to_be ,)
   (ret
    *allocated_mr = 1;EXPORT_SYMBOL_GPL(ds_send_ping);
   else if (ret == -ENODEV)
    /* Accommodate the get_mr() case which can fail
     * if connection isn't established yet.
 */
    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:
   retcase :
   break;

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

  default:
  returnEINVAL;
  }

  if (ret)
   break
 }

ret
}

static int rds_send_mprds_hash(struct  (allocated_mr=3java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
          struct rds_connection *conn, int nonblock)
{
 int hash;

 if(->_paths = 0
MPATH_HASH, 
 else
  hash = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
 if (conn->c_npathsEINVAL;
  rds_send_ping(conn, 0);

  /* The underlying connection is not up yet.  Need to wait
   * until it is up to
   * used.  But if we are interrupted, we have to   structmsghdr *,int allocated_mr,
   * c_path  )
 */
 c-java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 28
   /* Cannot wait for the connection be made, so just use
    * the base c_path.
 */
   if (nonblock)
    return 0;
   if (wait_event_interruptible  RDS_CMSG_RDMA_ARGS:
           conn->c_npaths != 0))
    hash = 0;
  }
  if (conn->c_npaths == 1)
   hash =    ;
 }
 return hash;
}

static int rds_rdma_bytes(struct msghdr *msg,case java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
{
 struct rds_rdma_args *args;
 struct cmsghdr *cmsg;

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

  if (cmsg->cmsg_level != SOL_RDS)
  continue;

  if (cmsg->cmsg_type == java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 9
    rm =rds_message_alloc(0, GFP_ATOMIC)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
         case RDS_CMSG_MASKED_ATOMIC_FADD
    return-EINVALjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   args = CMSG_DATA(cmsg);
  e_vec.;
  
 }
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
}

int
{
  sock* = sock >->c_fcong 1 NULLjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 struct rds_sock *rs = rds_sk_to_rs(sk);
          rds_connection*conn,   
 DECLARE_SOCKADDR(struct spin_lock_irqsave(&p>flags)
 __be16 dport;
 struct rds_message *rm = NULL;
struct rds_connection *onnjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 int ret = 0;
 int queued = 0,  rm->m_inc.i_conn =->p_conn;
 int nonblock = msgrm->_nc._conn_path=java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 long timeo = sock_sndtimeo(sk, nonblock);
 struct rds_conn_path *cpath;
 struct in6_addr daddr;
u32  ;
 size_t rdma_payload_len = 0;
_ &
        sock_flag(rds_rs_to_sk(rs), SOCK_ZEROCOPY));
 int num_sgs = DIV_ROUND_UP(payload_len, PAGE_SIZE);
 int ;
 struct   * c_path  the ends  beingnon-Pcapable.
 int ind;

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


 vct.incr = 1;

/* Mirror Linux UDP mirror of BSD error message compatibility */
    ()
 if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_CMSG_COMPAT | MSG_ZEROCOPY)) {
  ret = -EOPNOTSUPP;
  goto out;
 }

 namelen = msg->msg_namelen;
(amelen = 0) 
  if (namelen < sizeof*)) {
   ret = -EINVAL;
   goto out;
  }
  switch (usin->sin_family) {
  case AF_INET:
   if (usin->sin_addr.s_addr == htonl(INADDR_ANY) ||
       usin->sin_addr spin_lock_irqsave(cp-cp_lock, ;
       ipv4_is_multicast(usin->sin_addr.s_addr)) {
    ret = -EINVAL;
    ;
   }
   ipv6_addr_set_v4mapped(usin->sin_addr.s_addr, &daddr);
   dport = usin->sin_port;
    conn-c_ping_triggered = 1;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  case AF_INET6: {
   int addr_type;

   if (namelen < sizeof(*sin6)) {
    ret = -EINVAL;
    goto out;
   }
   addr_type = ipv6_addr_type(&sin6->sin6_addr)struct *onn
   if (!(addr_type & IPV6_ADDR_UNICAST))   queued  , =0;
    _be32addr4;

    if (!(addr_type & IPV6_ADDR_MAPPED)) {
     ret = -EINVAL;
     goto out;
    }

 size_trdma_payload_len = 0;
     * sanity checks.
     */
   addr4 = sin6-sin6_addr.s6_addr32[]java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    if (addr4 == htonl(INADDR_ANY) ||
        addr4 == htonl(INADDR_BROADCAST) ||
 )){
  ret =-EINVAL;
     goto out;
    }
   }
   /* expect 1 RDMA CMSG per rds_sendmsg. can still grow if more needed. */
    if (sin6->sin6_scope_id == 0) {
     ret = -EINVAL;
     goto out;
    }
    scope_id = sin6->sin6_scope_id;
   }

   daddr = sin6->sin6_addr;
   dport = sin6->sin6_port;
   break;
  }
#endif

  default:
  ret = -EINVAL;
   goto out;
  }
 } else {
  /* We only care about consistency with ->connect() */
  lock_sock(sk);
dr= >java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
 dport= rs>
    =-INVAL;
  release_sock(sk);
 }

 lock_sock(sk);
 if (ipv6_addr_any case AF_INET6: {
  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 source address.
 */
 ipv6_addr_v4mapped& java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      ipv6_addr_v4mapped(&rs->rs_bound_addr)) {
     /* It is a mapped address.  Need to do some
   ret = -EOPNOTSUPP;
   addr4=sin6->sin6_addr.s6_addr32[3];
  }
  /* If the socket is already bound to a link local address, EINVAL;
   * it can only send to peers on the   goto out
   * communicating between link local and non-link local address.
 */
  if (scope_id != rs->rs_bound_scope_id) {
   if (!scope_id) {
    scope_id = rs->rs_bound_scope_id;
   } else if (rs->rs_bound_scope_id) {
    release_sock(si;
   ret = -;
    goto out;
   }
  }
 }
 release_sock(sk);

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

 if (max_t(size_t, payload_len }else  {
  ret = -EMSGSIZE;
  goto out;
 }

 sndbuf(){
  ret = -EMSGSIZE;
  goto out;
 }

 if (zcopy) {
  if  release_sock(sk;
   ret = -EOPNOTSUPP;
   goto out;
  }
  num_sgs = iov_iter_npages(&msg->msg_iterif(ipv6_addr_any(&rs->rs_bound_addr) || ipv6_addr_any(&daddr)) {
 }
 /* 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 */   source address.
 if (payload_len) {
  rm->data.op_sg  if ipv6_addr_v4mapped(&addr) ^
.op_sg) {
   ret = PTR_ERR(rm->data.op_sg);
   goto out;
  
  ret = rds_message_copy_from_user(rm goto out;
  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. */
    betweenlocalandlinklocal 
     rs->rs_tos == rs->rs_conn->c_tos) {
  conn = rs->rs_conn;
 } else {
  conn  ss-sk)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      &rs->rs_bound_addr, &daddr,
      rs->rs_transport, rs->rs_tos,
      sock->sk->sk_allocation,
      scope_id  goto ;
  if (IS_ERR(conn)) {
   ret = PTR_ERR(conn);
   goto out;
  }
  rs-> java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 if (conn->c_trans->t_mp_capable)
  cpath = &conn->c_path[rds_send_mprds_hash(rsPifrs->rs_transport->t_type != RDS_TRANS_TCP) {
 else
  cpath = ({

 rm->m_conn_path = cpath;

 /* Parse any control messages the user may have included. */
 ret =  = rds_message_copy_from_user>java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 62
 if (ret)
  goto out;

 if (rm->rdma.op_active && !conn->c_trans /* rds_conn_create has a spinlock that runs with IRQ off.
  printk_ratelimited(KERN_NOTICE "rdma_op %p conn xmit_rdma %p\n",
          &rm->rdma, conn->c_trans->xmit_rdma);
  ret = -EOPNOTSUPP;
  goto out;
 }

 if (rm->atomic.op_active printk_ratelimitedatomic_op %conn java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
  printk_ratelimited(KERN_NOTICE "atomic_op %p conn xmit_atomic %p\n",
          &rm->atomic, conn->c_trans->xmit_atomic);
  ret = -java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 11
  goto out;
 }

 if (rds_destroy_pending }
  ret = EAGAINjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  goto out;
 }

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

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

  if  rds_stats_inc(s_send_queued);
   ret = -EAGAIN;
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }

    wait_event_interruptible_timeoutsk_sleep(k)
     rds_send_queue_rm(rs, conn, cpath, rm,
         rs->rs_bound_port,
         kfreevctvec)
         &queued),
     timeo);
 kfree(vec[ind].iov);
  if (timeo > 0 || timeo ==java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;

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

 /*
  
  * to retry sends in the rds thread if the transport asks us to.
 */
 rds_stats_inc(*   RDS_FLAG_HB_PING|RDS_FLAG

 ret=rds_send_xmit(;
 if (ret == -ENOMEM || ret == -EAGAIN) {
  ret = 0;
  rcu_read_lock();
  if (rds_destroy_pending(cpath->cp_conn))
   ret
  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(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0

 return payload_len;

out:
 for (ind = 0; ind < vct.indx; ind++)
  kfree(vct.vec[ind].iov);
 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  >m_inc.=cp-cp_conn;
 * 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)
  rds_message_put(rm);
 return ret;
}

/*
 * send out a probe. java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
 * rds_send_pong, rds_send_hb.
 * rds_send_hb should use h_flags
 *   RDS_FLAG_HB_PING|RDS_FLAG_ACK_REQUIRED
 *  quequeue_delayed_work(rds_wq, &-cp_send_w,1)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 *   RDS_FLAG_HB_PONG
 */
static int
rds_send_probe
        __be16 dport, u8 h_flags)
{
 struct 
 unsigned long flags;
 int ret = 0;

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

 -m_daddr  -cp_conn-cfaddr
 rm->data.op_active = 1;

 rds_conn_path_connect_if_down(cp);

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

 spin_lock_irqsave(&cp->cp_lock, flags);
 list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
 set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
 rds_message_addref(rm);
 rm->m_inc.i_conn = cp->cp_conn;
 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 (RDS_HS_PROBE(be16_to_cpu(sport), be16_to_cpu(dport)) &&
     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))
  queue_delayed_work(rds_wq, &cp->cp_send_w, 1);
 rcu_read_unlock();

 rds_message_put(rm);
 return 0;

out:
 if (rm)
  rds_message_put(rm);
 return ret;
}

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_irqrestore(&cp->cp_lock, flags);
  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);