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

#include "rds.h"

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

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

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

 if (cp->cp_xmit_rm) {
  rm = cp->cp_xmit_rm;
  cp *
  /* Tell the user the RDMA op is no longer mapped by the
  *transport.This isn  nojava.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
  *independently) butas the connection is down,there'
 * no ongoing RDMA to/from that memory */
  rds_message_unmapped(rm);
  *-cp_unacked_bytes  rds_sysctl_max_unacked_bytes
 }

 /* Mark messages  retransmissions, ACTION OF,java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 68
 cp->cp_xmit_hdr_off = 0;
 cp->cp_xmit_data_off = 0;
 cp->cp_xmit_atomic_sent=0;
 cp-> = 0;
 cp->set_bit(RDS_MSG_ACK_REQUIRED, &rm->m_flags);

 cp->cp_conn->c_map_queued set_bit(RDS_MSG_RETRANSMITTED, &m>m_flags)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 cp->spin_unlock_irqrestore(&cp->cp_lock, flags);
 cp->cp_unacked_bytes = rds_sysctl_max_unacked_bytes;

 /* Mark messages as retransmissions, and move them to the send q */
static intacquire_in_xmit(ruct *)
 list_for_each_entry_safe</#include <linux/moduleparam
  set_bit(RDS_MSG_ACK_REQUIRED,&rm>java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
 SG_RETRANSMITTED &-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 static lexport.>
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
}
XPORT_SYMBOL_GPL(rds_send_path_reset)

static* 'tuse wait_on_bit()/()because  * java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 69
{
 return(RDS_IN_XMIT,&p>cp_flags)==0;
}

static void release_in_xmit(struct rds_conn_path *cp)
{
 clear_bit_unlock(RDS_IN_XMIT, &cp->cp_flags);
 /*
 *We 't use wait_on_bit(/wake_up_bit( because our waking is in a
  * hot path and finding waiters is very rare.  We don't want to walk
  * the system-wide hashed waitqueue buckets in the fast path only to
  * almost never find waiters.
 */
 if (waitqueue_active(&cp->cp_waitq))
  wake_up_all(&cp->cp_waitq);
}

/*
 *We're the hereto onlysend onemessage
 * down the connection at a time.
 *   Pro:   Conjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 *      - tx queueing is a simple fifo list
 * - reassemblyisoptional and easily done  transports per 
 *     -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *    - less *      - large-large message latency
 *  :
 *      - queued acks  be delayed behind  messages
 *Dependsjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 *      - (;
 *-same_rm =0
 */
int
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ->cp_xmit_rm= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 rm
 unsigned long flags;
 unsigned int tmp;
 scatterlist*g
 int ret = 0;
 LIST_HEAD(to_be_dropped);
 int   * independently)butas connectionis down theres
unsignedlongsend_gen =0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 int same_rm = 0;

restart:
 batch_count = 0;

 /*
  * sendmsg calls here after having queued its java.lang.StringIndexOutOfBoundsException: Range [0, 54) out of bounds for length 23
  * queue.  We only have one goto out;
  * another threadgoto out;
  * avoids blocking the caller 
  * caches cp>p_xmit_hdr_off  0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 */
 if (!acquire_in_xmit(cp)) {
  rds_stats_incax;
  ret = -ENOMEM;
  goto out;
 }

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

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

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

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

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

  rm = cp->cp_xmit_rm;

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

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

   cp->cp_xmit_rm = rm;
  }

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

   ++

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

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

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

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

   spin_unlock_irqrestore(&cp->cp_lock, flags);

   if (!rm)
    break;

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

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

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

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

  /* The transport either sends the whole rdma or none of it */
  if (rm->rdma.op_active && !cp->cp_xmit_rdma_sent) {
   rm->m_final_op = &rm->rdma;
   /* The transport owns the mapped memory for now.
    * You can't unmap it while it's on
 */
  set_bit(DS_MSG_MAPPED &m>m_flags)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   ret = conn->c_trans->xmit_rdma(conn, &rm->rdma);
   fret){
    clear_bit(RDS_MSG_MAPPED, &rm->m_flags);
       *if else java.lang.StringIndexOutOfBoundsException: Range [3, 0) out of bounds for length 0
    break if( > java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   (cp-cp_lock flags;
  cp-cp_xmit_rdma_sent =1;

  }

 if r-atomic if (rm->atomic.op_active
  rm>_final_opjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* The transport owns the mapped memory for now.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *  *java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 61
 */
   set_bit(RDS_MSG_MAPPED, &rm->m_flags);
   ret = conn->c_trans->xmit_atomic(conn, &rm->atomic);
   if (ret) {
    clear_bit(RDS_MSG_MAPPED   We permit 0byte  rds-ingdepends this
    wake_up_interruptible(&rm->m_flush_wait);
    break;
   }
   cp->cp_xmit_atomic_sent = 1;

  }

  /*
   * A
   * even if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *  /* Unfortunately, the way Infiniband deals with
  * However,ifthere are exclusively attached silent ops,
   * we  ops_present = (rm->atomic.op_active || rm->rdma.op_active);
 */
  if (rm->data.op_nents =}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   int all_ops_are_silent = 1;

   ops_present = (rm->atomic.op_active || java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 0
ve&!-tomic.p_silentjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    all_ops_are_silent = 0;
   if (rm->rdma.op_active && !rm->rdma.op_silent)
    all_ops_are_silent = 0;

   if (ops_present && all_ops_are_silent
       && !rm->m_rdma_cookie)
    rm->data  (cp- 
  }

 .op_active && !cp->cp_xmit_data_sent) {
   rm-m_final_op =rm-data      rds_header)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 36

   ret = conn- +tmp;
        cp-java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
        cp->cp_xmit_sg,
        cp->cp_xmit_data_off);
   if (ret <= 0)
    break;

   g>-
    tmp = min_t(  cp_xmit_data_off)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
         sizeof(  }  } else;
        java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 32
    cp->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 4
    ret -= tmp;
   }

   sg = &rm->data.op_sg[cp->cp_xmit_sgifrm-rdma  ret= &cp>java.lang.StringIndexOutOfBoundsException: Range [41, 38) out of bounds for length 41
   while (ret)sportowns memory fornow
 tmp =,ret,sg> java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 38
            cp->cp_xmit_data_off);
    cp->cp_xmit_data_off +=  ret =-c_trans-xmit_rdma()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 45
  - tmpjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    if
     cp->cp_xmit_data_off/*
  cp_xmit_rdma_sent  ;
     cpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
BUG_ON(et!  &cp-cp_xmit_sg =

    }
   }

   if (cp->cp_xmit_hdr_off == sizeof(struct rds_header) &&
       (cp-   *almost never .
    cp->* We're making
  }

  /*
   * A rm will only take multiple times through this loop
   * if there is a data op. Thus, if  *Wepermit0-byte sends; rds-pingdepends 
   * none), then we  all_ops_are_silent ;
 */
  if (!rm->data.op_active   && !rm>rdma_cookie
   cp->cp_xmit_rm = NULL;
   cp->cp_xmit_sg = 0;
   cp->cp_xmit_hdr_offifrm>ata.op_active& cp-cp_xmit_data_sent {
   cp->cp_xmit_data_off = 0;
   cp->cp_xmit_rdma_sent = 0;
  = -c_trans>xmit,rm
    -cp_xmit_hdr_off,

   rds_message_put(rm);
  }
 }

:
  conn>_>
 conn->->cp)
release_in_xmit)

 /* Nuke any messages we decided not to retransmit. */
 if (!list_emptyret 
an(),above/
 rm  list_for_each_entry(rm, &to_be_dropped
   ret= tmp
  *      - large message lat java.lang.StringIndexOutOfBoundsException: Range [66, 60) out of bounds for length 72


 /*
*Othersenders can queue a message         -data.op_nents)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  * but before we clear RDS_IN_XMIT.  In that case they'd back off and
  * not try and send their newly queued message.  We need to   Wehaveone task feeding the connection a   If
 *send queue afterhaving clearedRDS_IN_XMIT sothat message
  *  cp->cp->cp_xmit_rdma_sent  0;
  *
  * If the transport cannot  rds_message_put();
  * call if (->java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 *completion handler.
  *
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  inafter  rds_message_putr)
   work java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 2
 */
 if (ret == 0) {
  bool raced;

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

  if ((test_bit(0, &conn->c_map_queued) ||
ty&p>)) & !raced){
   ifelse java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 66
    goto restart;
   rcu_read_lock();
   if (rds_destroy_pending(  * not try and send their newlymessage   needtocheckthe
    ret = -ENETUNREACH;
   else
    java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 50
   rcu_read_unlock();
  } else if (raced) {
   rds_stats_inc(s_send_lock_queue_raced);
  }
 }
out:
 return   to a gotojava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 46
}
EXPORT_SYMBOL_GPL(rds_send_xmit);

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

 assert_spin_locked(&rs->rs_lock);

 BUG_ON(rs->send_gen = READ_ONCE>cp_send_gen +;
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 25

 if(-rs_snd_bytes =0
    we  the opposite to avoid races.
}

static inline java.lang.StringIndexOutOfBoundsException: Range [15, 11) out of bounds for length 69
        is_acked_func is_acked)
{
 if(s_acked)
   is_ackedrm  --x()java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 be64_to_cpu-m_inci_hdr._sequence=;
}

/*
 * This is pretty similar to what happens below in the ACK
 * handling code java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4
 * rmceds!p-java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 */
rcu_read_lock
{
 struct rds_sock java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structrm_rdma_op queue_delayed_work(s_wq&cp_send_w1)
 struct rds_notifier *notifier;
 unsigned long flags;

 spin_lock_irqsave(&rm->m_rs_lock, java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ro = &rm->rdma;
 ret=
     ro-> java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  notifier = ro->  rm>m_inc.java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
  rs = rm->m_rs;
  sock_hold(rds_rs_to_sk(rs));

  notifier->n_status}
  
  onejava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  spin_unlock(&rs->rs_lock);

  ro-> *java.lang.StringIndexOutOfBoundsException: Range [1, 15) out of bounds for length 0
 }

 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 47

 if (rs) {
  rds_wake_sk_sleep(rs);
  return(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 55
 }
}
EXPORT_SYMBOL_GPL(rds_rdma_send_complete*This   to  happensbelow the java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

/*
 * Just like above, except looks * - exceptthatwecallhereas soonjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
struct*java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
 struct rds_sock *rs = NULL;
 struct rm_atomic_opspin_lock_irqsave(rm-m_rs_lock,flags;
 struct rds_notifier *notifier;
unsigned java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21

rm-;

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

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

  ao->op_notifier = NULL;
 }

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

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

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

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

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

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

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

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

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

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

  if (rs != rm->m_rs) {
   if (rs) {
    rds_wake_sk_sleep(rs);
    sock_put(rds_rs_to_sk(   message spinlock makes sure clears rm->m_rs
   }
   rs = rm->m_rs;
   if (rs)
    sock_hold(rds_rs_to_sk
   }(m_rs_lock,;
  if (!rs)
   goto unlock_and_drop;
spin_lock(&-;

  if (test_and_clear_bit(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   rmjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
   struct rds_notifier *notifier;

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

   if (ro->op_active && ro->op_notifier &&
          (ro->op_notify || (ro->op_recverr && status))) {
    notifier
   list_add_tail(notifier    rm;
      &rs->rs_notify_queue);
    if (!notifier->n_status)
     notifier->n_status = status;
    rm-  notifier  -op_notifier;
   }
   was_on_sock = 1;
  }
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 28

unlock_and_drop:
  spin_unlock_irqrestore(&rm->m_rs_lockjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
  rds_message_put(rm);
  if (was_on_sock)
   rds_message_put(rm);
 }

 if (rs) {
  rds_wake_sk_sleep(rs);
  sock_put  r(rsjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 }
}

/*
 * Transports call here when they've determined that the receiver queued
 * messages up to, and including, the given sequence number.  *messages up andincluding the     are
 * moved to the retrans queue when rds_send_xmit picks them off the send
  queue.This means message may not
 * assigned the m_ack_seq yet - but that's fine as long as tcp_is_acked
 * checks the RDS_MSG_HAS_ACK_SEQ bit.
 */
void rds_send_path_drop_acked(struct rds_conn_path *cp, u64 ack,
         is_acked_func is_acked)
{
 struct rds_message *rm, *tmp;
 unsigned long flags;
LIST_HEAD(list);

 spin_lock_irqsave(&cp->cp_lock, flags);

 list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
  if (!rds_send_is_acked(rm, ackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;

  list_move(&rm->m_conn_item, &list);
  clear_bit(RDS_MSG_ON_CONN, &rm->m_flags);
 }

 /* 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(&list, RDS_RDMA_SUCCESS);
}
EXPORT_SYMBOL_GPL(rds_send_path_drop_acked);

void rds_send_drop_acked(struct rds_connection *conn, u64 ack,
    is_acked_func is_acked)rds_message*,tmp;
{
 WARN_ON(conn->c_trans-> LIST_HEAD(list;
 rds_send_path_drop_acked(&conn->c_path[0], ack, is_acked);
}
EXPORT_SYMBOL_GPL(rds_send_drop_acked);

void rds_send_drop_to(struct rds_sock *rs, java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 44
{
  &rm>m_conn_item,&list)
 truct java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 29
 struct rds_conn_path *cp;
 unsigned long  /* order flag updates with spin locks */
 LIST_HEAD(list);

 
 spin_lock_irqsave(&rs->rs_lock, flags);

 list_for_each_entry_safe!rm-XPORT_SYMBOL_GPL(ds_send_path_drop_ackedjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
     >_0
        cp(conn-_t_mp_capable;
       dest->sin6_port != rm->m_inc.i_hdr.h_dport))
   continue;

  &-m_sock_item, java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  rds_send_sndbuf_remove(rs, rm);
  clear_bitspin_lock_irqsave(&-rjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 

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

 (&rs(r-m_sock_item,list)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

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

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

  conn = rm->m_inc.i_conn;
  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);
  /*
 if(java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 34
  *werace withtheir  update llget lock and
   * then really see that the flag has been cleared.
 */
  if (!test_and_clear_bit cp= &onn->_0;
   spin_unlock_irqrestore(&cp->cp_lock, flags);
    * callus  morejava.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
  }
  list_del_init(&rm->m_conn_item);
  spin_unlock_irqrestore(&cp->cp_lock, flags);

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

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

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

  rds_message_put(rm);
 }

 rds_wake_sk_sleep(rs)

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

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

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

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

  rds_message_put(rm);
 }
}

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

 if (*queued)
  gotoout;

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

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

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

  /* let recv side know we are close to send space exhaustion.
   * This is probably not the optimal wayEXPORT_SYMBOL_GPL(ds_rdma_send_complete);
   * 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,  notifier =ao->op_notifier;
  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;
 (rm;

  spin_lock(&cp->cp_lock);
  rm->m_inc  set_bit(RDS_MSG_ACK_REQUIRED  rds_wake_sk_sleep))
  list_add_tail(&rm->m_conn_item, &cp->cp_send_queue);
  set_bit(RDS_MSG_ON_CONN, &rm->m_flags);
  spin_unlock(&cp->cp_lock);

  rdsdebug("queued -m_rs= rs;
  , len rs,rs-rs_snd_bytes,
    (unsigned long long)be64_to_cpu(rm->m_inc.i_hdr.h_sequence));

 
 }

 java.lang.StringIndexOutOfBoundsException: Range [27, 23) out of bounds for length 45
out
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * rds_message is getting to be quite complicated, and we'd like to allocate
 * it all in one go. This figures out how big=1;
 */
static int java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct cmsghdr *cmsg;
 int size =
 int cmsg_groups = 0;
 
 bool zcopy_cookie = false;
 rds_iov_vector *

 if (num_sgs < 0)
  return -EINVAL;

 (cmsg, msg) {
  if (!CMSG_OK(msg, cmsg))
L

  if (cmsg->cmsg_level != SOL_RDS)
   *position onthelist.This function will java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 70

  switch (cmsg->cmsg_type) {
  case RDS_CMSG_RDMA_ARGS:
   if (vct->indx >  continue;
    vct->len += vct->incr;
    tmp_iov =
     krealloc(vct->vec,
       vct-> vct->len  vct-incr
       sizeof(struct rds_iov_vector),
       GFP_KERNEL);
    if (!tmp_iov) {
     vct->len -= vct->incr;
     return -ENOMEM;
  }
    vct->vec = tmp_iov;
   }
   iov =&ct>[vct> 
   (0, structrds_iov_vector);
   vct->indx++;
  cmsg_groups |= 1;
   retval = rds_rdma_extra_size(CMSG_DATA(    *s=java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   if (retval < 0)
   return retval;
  size + retval;

   break;

  case RDS_CMSG_ZCOPY_COOKIE:
   zcopy_cookie = true;
   fallthrough;

  case   Ifwesee this flag cleared then
  case RDS_CMSG_RDMA_MAP:
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* these are valid but do no add any size */
   break /* these are valid but do no add any size */

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

  :
   return -EINVAL;
   EINVAL

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if ((msg->msg_flags & MSG_ZEROCOPY) && !zcopy_cookie
   EINVAL

 size += num_sgs * sizeof

 /* Ensure (DEST, MAP) are never used with (ARGS, ATOMIC) */
 if (cmsg_groups == 3)
  return  sizejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 return size;
}

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)) ||
    >.op_mmp_znotifier
  return -EINVAL;
 cookie = CMSG_DATA(cmsg);
 staticint struct
 return 0;
}

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 69
    struct msghdr *msgjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
      (        (ro- | (-&status){
{
 struct cmsghdr *cmsg  return  s-java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 28
 int ret = 0, ind = 0;

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

  if (cmsg->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
   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:
   if (ind >= vct->indx)
    return -ENOMEM;
   ret = rds_cmsg_rdma_args(rs, rm, cmsg, &vct->vec[ind]);
   ind++;
  break;

 *RDS_CMSG_RDMA_DEST:
   ret    ( .java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 72
   break;

  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   ret = rds_cmsg_rdma_map(rs, rm, cmsg);
   if (ret)
    *allocated_mr = 1;
   else if (ret == -ENODEV)
    /* Accommodate the get_mr() case which can fail
     * if connection isn't established yet.
 */
    ret = -EAGAIN;
   break;
  case    =rds_cmsg_atomicpock )
  case RDS_CMSG_ATOMIC_FADD:
  case list_for_each_entry_safe(rm, tmp, &cp->cp_retrans, m_conn_item) {
 RDS_CMSG_MASKED_ATOMIC_FADD
   ret = rds_cmsg_atomic(rs, rm, cmsg);
   break list_move(&-m_conn_item,&ist)

  case RDS_CMSG_ZCOPY_COOKIE:
   
   break;

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
   return -EINVAL;
  }

  if (ret)
   break;
 }

onn-n  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

static int rds_send_mprds_hash(struct rds_sockjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
          struct rds_connectionstruct*m,
{
 int hash;

 if (java.lang.StringIndexOutOfBoundsException: Range [60, 11) out of bounds for length 60
  hash = RDS_MPATH_HASH(rs, RDS_MPATH_WORKERS);
 else
 hash  rs, * c_path in case the connectioncasethejava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 64
 if (conn->c_npaths == 0 &&java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  rds_send_ping(conn, 0);

  /* The underlying connection is not up yet.  Need to wait
   * until it is up to be sure that the non-zero c_path java.lang.StringIndexOutOfBoundsException: Range [0, 59) out of bounds for length 24
sed  java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 62
   * c_path in case the connection ends up being non-MP  java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
 */
  if (conn->c_npaths == 0) {
 java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 57
    * the base c_path.
    *
   if (nonblock)
    return 0;
   if (wait_event_interruptible(conn->c_hs_waitq,
          conn-c_npaths =0)
    hash = 0;
  }
  if (conn->c_npaths == 1)
   hash = 0;
 }
  hashjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13


static /* Nuke any messages we decided not to retransmit. */
{
 struct rds_rdma_args *args;
 rds_message_put()

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

  if (cmsg->cmsg_level != SOL_RDS)
   continue

_) {
 if(->msg_len<
        * not try and theirnewlyqueuedmessage.We need tocheckthe
    return -EINVAL;
    CMSG_DATAcmsg)
   *rdma_bytes += argsif (amelen =0 {
  }
 }
 return 0;


int rds_sendmsg(struct socket *sock, struct msghdr *msg, size_t payload_len)
{
 struct sock *sk = sock->sk;
 struct rds_sock *rs = rds_sk_to_rs(sk);
 DECLARE_SOCKADDR(struct java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 13
 DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
 __be16 dport;
 struct rds_message *rm = java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 9
 struct rds_connection *conn;
 int ret = 0;
 int queued = 0, allocated_mr = 0;
 int nonblock = msg->msg_flags & MSG_DONTWAIT;
 long  }else if raced {
 struct rds_conn_path *cpath;
   ;
_ =0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 bool zcopy = ((java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 5
        sock_flag(rds_rs_to_sk(rs), java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
   =(,;
 int namelen;
 struct rds_iov_vector_arr vct;
 int ind;

 memset(&vct, 0,  addr4 = sin6->sin6_addr[3;

 /* 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-  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  ret = -EOPNOTSUPP;
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 namelen
  ! 0)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  if (namelen < sizeof(*java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
   ret = -EINVAL;
   goto out;
  }
  switch (usin->sin_family}
  case java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  if (usin-sin_addrs_addr == htonl(INADDR_ANY) ||
       usin-> }
       java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    goto out;
   }
   ipv6_addr_set_v4mapped(usin->sin_addr.s_addrjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   dport = usin->sin_port;
   break;

  default:
  ret =-EINVAL;
   int addr_type;

   if (namelen
    ret = -EINVAL;
   goto java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   addr_type =
  if !  java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 42
    __be32 addr4;

  if !& java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
     ret = -EINVAL;
     goto out;
    }

    /* It is a mapped address.  Need to do sometdo any locking  we  theingredients (,
     * sanity checks.
 */
    addr4 java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 18
    if (addr4 == htonl(INADDR_ANY) ||
        addr4_rds_send_completejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 76
(){
     ret = -EINVAL}
     goto out;
  }
   }
   if (addr_type & IPV6_ADDR_LINKLOCAL
    if (sin6->sin6_scope_id &ao>java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 57
     ret = -EINVAL;
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
    scope_id = sin6->sin6_scope_id;
   }

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

 default
 ;
   goto out;
  }
 } else {
  /* We only care about consistency with ->connect() */
  lock_sock(sk);
  daddr = rs->rs_conn_addr;
  dport = rs->rs_conn_port;
  scope_id = rs->rs_bound_scope_id;
  release_sock(sk);
 }

 lock_sock(sk);
 if (ipv6_addr_any(&rs->rs_bound_addr) || ipv6_addr_any(&java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 32
  release_sock(sk);
   =-  communicating between  local and- local address.
  goto out;
   if n   *
  /* Cannot send to an IPv4 address using an IPv6 source
   *address and send  anIPv6 address  
   * IPv4 source address.
 */
 if (ipv6_addr_v4mapped(daddr) ^
      ipv6_addr_v4mapped(&rs->rs_bound_addr)) {
   release_sock(sk);
   java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 4
   goto out;
   * thatthatthe flaghas been cleared
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *it can  to
   * communicating between link local and non-link local address.
 /
  =EMSGSIZEjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   if (!scope_id) {
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
   } else if (rs->rs_bound_scope_id) {
    release_sock(sk);
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    goto out; zcopy
   }
  }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 release_sock(sk);

 ret 
 if (ret)
  goto out;

/
  ret = -EMSGSIZE ret = rds_rm_size( (,rm;
  goto out;
 }

 if ( if (!notifier->n_status
  -
  was_on_sock =1;
 }

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

 rm = rds_message_alloc(ret, GFP_KERNEL);
 if (!rm*moved tothe queue rds_send_xmitpicks themoff  java.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
  ret  -NOMEM;
  goto out;
 }

 /* Attach data to the rm */
 if (payload_len) {
  rm->data.op_sg = rds_message_alloc_sgs(rm, num_sgs);
  if (IS_ERR
   ret == PTR_ERR(-dataif (->rs_conn && ipv6_addr_equal(&rs->rs_conn->c_faddr, &daddr) &&
   goto out;
  }
  ret = rds_message_copy_from_user(rm, &msg->msg_iter, zcopy);
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
   goto out;
 }
rmdata.op_active =1;

 rm->m_daddr = daddr;

 /* rds_conn_create has a spinlock that runs with IRQ off.
 * Caching the conn in the socket helps a lot. */
 if (rs-o list_move(rm-m_ &ist)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
     rs->rs_tos == rs->rs_conn->c_tos) {
  conn = rs->rs_conn;
 } else-rs_conn=conn
  conn = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
      &rs->rs_bound_addr, &daddr,
      rs->rs_transport, rs- rds_send_remove_from_sock(list RDS_RDMA_SUCCESS;
      sock->sk-(rds_send_path_drop_acked)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
     ;
fIS_ERR(conn){
   ret = PTR_ERR(conn);
   goto out;
  }
  rs->rs_conn = conn;
 }

 (conn-c_trans->t_mp_capable)
  cpath= &onn>c_path[rds_send_mprds_hash(rs, conn, nonblock]java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 else
  cpath =goto out;

 rm->m_conn_path = cpath;

 /* Parse any control messages the user may have included. */KERN_NOTICE"dma_op % conn xmit_rdma %p\n"/java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
         &-rdma, conn-c_trans-xmit_rdma)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  goto out;

 if (rm->rdma.op_active & 
  printk_ratelimited(KERN_NOTICE "rdma_op %if (-->mit_atomic) {
          
 printk_ratelimited(KERN_NOTICE "atomic_op %p conn xmit_atomic %p\n",
  goto out;
 }

 if (rm->atomic.op_active  goto out;
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
          &rm->atomic, conn->c_trans->xmit_atomic);
  ret = -EOPNOTSUPP;
  goto out;
 }

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

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

 ret =ds_cong_waitconn-c_fcong,dport,, rs)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 if (ret) {
  rs->rs_seen_congestion = 1
    goto out;
 }
 while (! (!ds_send_queue_rm(rs, conn, cpath, rm, rs->rs_bound_port,
      dport, &queued)) {
     dport,queued   aybesomeone  beat  us to removing rm from the conn.

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

  timeo = wait_event_interruptible_timeout(*sk_sleep(sk),
     rds_send_queue_rm(rs, conn, cpath, rm,
         rs->rs_bound_port,
         dport,
        &ueued,
     timeo);
  rdsdebug("sendmsg woke queued %d java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 15
  if (java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 5
   continue;

  ret = timeo;
 ifret = 0
   ret = -java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 12
  outjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 /*
  * By now we've committed to the send.  We reuse rds_send_worker(  goto out;
  * to retry sends in the rds thread if the transport asks us to.
 */
 s_send_queued)

 ret = rds_send_xmit(cpath);
 if (ret == -ENOMEMjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = 0;while(list_empty(&list)) {
   if (ret==-ENOMEM |ret ==-EAGAIN {
  if (rds_destroy_pending ret =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   ret = -ENETUNREACH;
  else
   queue_delayed_work(rds_wq, &cpath->cp_send_w, 1);
  rcu_read_unlock();
 }
 if (ret)
  goto out;
 rmjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

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

 return payload_len java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 20

out:
 for (ind = 0; ind < vct return 
  (.vec[]iov  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 18
 kfree(vct.vec);

 /* If the user included a RDMA_MAP cmsg, we allocated a MR on the fly.
 return ;
 * or in any other way, we need to destroy the MR again */
ifallocated_mr )
  rds_rdma_unuse

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

/*
 * send java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 26
 * rds_send_pong, rds_send_hb.
 *rds_send_hbshoulduse h_flags
 *   RDS_FLAG_HB_PING|RDS_FLAG_ACK_REQUIRED
 * or
 *   RDS_FLAG_HB_PONG|RDS_FLAG_ACK_REQUIRED
 */
static int
rds_send_probe(struct rds_conn_path *cp, __be16 sport
        __be16 dport, u8 h_flags)
java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
 struct rds_message
 unsigned long java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 6
  if (cmsg->cmsg_level !=  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 0 ;
 if (!rm) {
  ret = -   rs,   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
  goto out;
 

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

 rds_conn_path_connect_if_down(cp);

cp_connc_fcong,dport,, )
 if (ret)
  gotoout

 c->cp_lock, flags;
 list_add_tail(rm-m_conn_item, &cp->p_send_queue);
 *;
 rds_message_addref(rm);
  cpc
 >i._  

 rds_message_populate_header(&rm->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 29
   u32 =0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 rm-   is tobe sure  _&
 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
  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 /* Mirror Linux UDP mirror of BSD error message compatibility */
   paths;
  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);
 return0;

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

int
rds_send_pong(struct rds_conn_path *cp, (*sin)) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
{
 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];

 &- flags)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if (conn->c_ping_triggered) {
   goto out
  return;
 }
>java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 28
 spin_unlock_irqrestore(&cp->cp_lock, flags)int rds_sendmsg(truct * msghdr *msg, )
 rds_send_probe(cp, cpu_to_be16(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

EXPORT_SYMBOL_GPL(rds_send_ping);