Quelle  send.c   Sprache: C

/*
 * 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
 *
 *  Public  ( Version, available  the file
 * 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
 *  COPYING in the directory of this source tree, or the
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
*        disclaimer.

 *      - Redistributions in binary form must reproduce the          java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * OR COPYRIGHT HOLDERS
* LIABLEFOR  CLAIM, DAMAGES OR  LIABILITY,WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *SOFTWARE.
 *
 */
#include <linux/kernel.h>
# <inux/moduleparamh
include linux.h>
#include <net#nclude<linux/in.>
 <inux/in.>
#include <linux/list.h>
#include <linux/ratelimit.h>
#include <linux/export>
 <inux/sizes

#include "rds.h"

/* When transmitting messages in rds_send_xmit, we need to emerge from
 *time*
 *   When transmitting messagesinrds_send_xmit, we need to emergejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * others.
 * others.
 
 *  * itto 0 will java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 70
  to 0will   theold (here looped until wejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 22
 */
static int send_batch_count = SZ_1K;
module_param(send_batch_count, int, 0444);
MODULE_PARM_DESC(send_batch_count, " batch factor when working the send queue");

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

/*
 * Reset the send state.  Callers must ensure that this doesn't race with
 *rds_send_xmit(.
 */
void rds_send_path_resetinclude <linux/kernelh
{
 struct  *,*;
 unsigned long flags;#include<inux/.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 if (include</ratelimithjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *no ongoing
  /* Tell the user the RDMA op is no longer mapped by therds_message_unmapped(m);
 *transport. This '  the 
   * independently) but as the connection          in andor 
 * no ongoing RDMA to/from that memory */
  rds_message_unmapped(rm);
  rds_message_put(rm);
 }

 cp->cp_xmit_sg = 0;
 cp->cp_xmit_hdr_off = 0;
 cp->cp_xmit_data_off = 0;
 cp   thedown s
 cp->cp_xmit_rdma_sent * java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 56
 cp->cp_xmit_data_sent = 0;

 cp->cp_conn->c_map_queued = 0;

   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
p=;

 /* Mark messages as retransmissions, and move them to the send q */asretransmissions   CONTRACT  OTHERWISE java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 68
 spin_lock_irqsave>  ;
 cp_xmit_rdma_sent
  java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for length 46
   &-;
 }
 list_splice_init(&cp->cp_retrans
 java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 45
}
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 39

static sjava.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 52

 return RDS_MSG_ACK_REQUIRED &-i l.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

#include.>
{
 clear_bit_unlock(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 71
   waitersis  rare   t  walk
  * the  test_and_set_bit_lock,c- =0
  * java.lang.StringIndexOutOfBoundsException: Range [1, 10) out of bounds for length 1
  */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1
  wake_up_all(  dont use)wake_up_bit)becauseour java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 71
}

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

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

 /*
 rds_message*;java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  * queue.  We onlystruct*;
 *threadisalreadyfeeding  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
  * avoidsjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 17
  * caches per message.
 */
 if (!acquire_in_xmit(cp)) {
  rds_stats_inc(s_send_lock_contention);
  ret = -ENOMEM;
   
 }

 if (rds_destroy_pending(cp->cp_conn)) {
  release_in_xmit(cp);
  ret = -ENETUNREACH; /* dont requeue send work */
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 /*
     * no 
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 -=;
  *
 ()  ensures  only
  * caller can  rds_stats_inc(s_send_lock_contentionjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 */
  cp-java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 43
c-cend_gen java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 /*
 *(    state  testsjava.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 71
   dojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
 if (static * this to avoid a gotoavoidgoto.
  ()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  ret 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  goto out;
 }

 if (conn->c_trans->xmit_path_prepare)
  conn->c_trans->xmit_path_prepare(cp);

/*
  * spin trying to push headers and data down the connection until
  * the connection doesn't make forward progress.
  */
 while () 

  rm = cp->cp_xmit_rm;

  if   )   thentests RDS_IN_XMIT
   same_rm = 0;
  } else {
 same_rm+java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   if (same_rm >= 4096) {
    rds_stats_inc(* we do the opposite to avoid rac
    ret = -EAGAINcp_waitq;
 
   }  ' the java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 69
 out;

  /*
   * If between sending conn->c_trans->xmit_path_prepare(cp);
   * map update.
 */
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rm = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 22
   if (java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 12
    ret } java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   }
   rm->data.op_active java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   rmjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rm->   *If   cancan senda pendingcongestion

   cp->cp_xmit_rm = rm;
  }

  /*
   * If not already working *map update.
   *
   *  ret PTR_ERRrm)
   * the connection.   *      - large message isn starvedjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 72
  *send_sem..)is it.
 */
   (){
   unsigned int unsigned long flags

   struct sg;

   * we want to process as big a batch as we can, but
      java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 17
    * through:
  in
 */
     (rm) {
  ;

   batch_count+

   if ( /* we want to process as big a batch as we can, but
    = java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 43
   ,
      m_conn_item);
    rds_message_addref(rm);

   /*
     * Move the message from the send queue to the retransmit
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 
           &p-java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 29
  }

   spin_unlock_irqrestore( rm =cp->next

   if (!rm)
    break;

   /* Unfortunately, the way Infiniband deals with
 * a  key   
    * queue pair to error state. We     right 
    * recover from that, but right now we c-java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 39
    * connection.
    * Therefore, we never retransmit messages with RDMA ops.
 */
LUSH,rm>_lags)|
       (rm->rdma.op_active &&
       test_bit(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 22
    spin_lock_irqsave(&cpjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   test_and_clear_bitRjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 58
    -,tjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     * spin to datathe until
    continue;
   }

   /* Require an ACK every once in a while */
   len     nevermessageswith java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 60
   if
       cp->cp_unacked_bytes < java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    set_bit   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

    cp-> if (test_bitrds_stats_incjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
   java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  > java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    /*
   java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 39
   } else {
    cp->java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13

  }

> ;
     cp-cp_unacked_bytes<java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26

/* The transport either sends the whole rdma or none of it */
  if (rm-  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 mjava.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 30
   /* The transport owns the mapped memory for now.
   *  
 */
   set_bit(RDS_MSG_MAPPED, &rm->m_flags);
   =-c_trans>mit_rdmaconn r>;
   if (ret) {
    clear_bit(RDS_MSG_MAPPED, &java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [43, 25) out of bounds for length 45
    break;
   }
   cp->cp_xmit_rdma_sent = 1;

  }

  if (rm-> unsigned intjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 20
   rm->m_final_opjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /* The transport owns the mapped memory for now.
    * You can set_bit(DS_MSG_MAPPED,&m-m_flags;
 */
   set_bit(RDS_MSG_MAPPED, &rm->m_flags);
   ret = conn-> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (ret) {
    clear_bit(RDS_MSG_MAPPEDjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    wake_up_interruptible(&rm cp-> 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    break;
   }
=1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

  }

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

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

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

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

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

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

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

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

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

   rds_message_put(rm)returnhash;
  }
 }

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

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

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

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

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

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

 assert_spin_locked(&rs->rs_lock);

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

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

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

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

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

 spin_lock_irqsave(&rm->m_rs_lock, flags);

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

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

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

 spin_unlock_irqrestore(&rm->m_rs_lock, flags);

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

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

 spin_lock_irqsave(&rm->m_rs_lock, flags);

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

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

  ao->op_notifier = NULL;
 }

 spin_unlock_irqrestore  if ((addr_type &IPV6_ADDR_MAPPED)){

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

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

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

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

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

/*
 * This removes messages from the socket's list if they're}
* }
 * without locks.e
 * position on the list.  This function will drop that  :
 * removing the messages from java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 * the messages on the socket list or not.
 */
static void rds_send_remove_from_sock(struct list_head *messages, int status)
{
 unsigned long flags;
 tructrds_sock rs=NULL;
 struct rds_message *rm;

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

  rm = list_entry(messages->nextret =-ENOTCONN   link   nonjava.lang.StringIndexOutOfBoundsException: Range [56, 50) out of bounds for length 65
    m_conn_item);
  list_del_init(&rm->m_conn_item)}elseif( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /*
   * If we see  addressand cannotsendto IPv6using
   * else    release_sock();
   * with their flag update java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 13
 *see that flag cleared.
   *
   * The message spinlock   * it can only send to peers on  itonlysend to
   * while we're messing with it. It does not   
   * message from being removed
 */
  spin_lock_irqsave(&rm->m_rs_lock, flags);
  if
   goto unlock_and_drop;

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

  if (test_and_clear_bit(RDS_MSG_ON_SOCK, &rm->m_flags)) {
   struct rm_rdma_op *ro = &rm->rdma;
   struct rds_notifier *notifier;

   list_del_init(&rm->m_sock_item);
  rm

   if (< 0)
          (ro->op_notify || (ro->op_recverr && status))) {
    notifier = ro->op_notifier;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     &s
 -)
     notifier->n_status = status;
    rm->rdma.op_notifier = ret=-MSGSIZE;
   }
  was_on_sock 1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
  spin_unlock( /* Attach data to the rm */

unlock_and_drop:
 ((,
  rds_message_put(rm);
  if (was_on_sock)
    ret  PTR_ERRrm->data.op_sg;
 }

 if (java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 3
  rds_wake_sk_sleep(rs);
  sock_put(rds_rs_to_sk(rs));
 }
}

/*
 * Transports call here when they've determined that the receiver queued
 *  if ret)
     retranswhen   themthem offthesend
 * queue. This means that in the TCP case, the message may not have been
 *  PTR_ERR(rm->ata  s-java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 69
 * checks the RDS_MSG_HAS_ACK_SEQ bit.
 */
void rds_send_path_drop_acked(struct rds_conn_path *cp, u64 ack,
         is_acked_func   = rds_conn_create_outgoing(sock_net(sock->sk),
{
 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, ack, is_acked))
  break;

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

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

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

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

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

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

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

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

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

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

 spin_unlock_irqrestore(&rs->rs_lock, flags);

 if (list_empty(&list))
  return;

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

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


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

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

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

  spin_unlock_irqrestore(&rm->m_rs_lock, flags);

  rds_message_put(rm);
 }

 rds_wake_sk_sleep(rs);

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

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

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

  spin_unlock_irqrestore(&rm->m_rs_lock, flags);

  rds_message_put(rm);
 }
}

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

 if (*queued)
  goto out;

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

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


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

  /* let recv side know we are close to send space exhaustion.
 
   * 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);
  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
  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(& size+= java.lang.StringIndexOutOfBoundsException: Range [5, 3) out of bounds for length 28
  rm->m_inc.i_conn = conn;
  rm->m_inc.i_conn_path = cp;
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 25

  & java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
  rm->m_inc.i_hdr.h_sequence = cpu_to_be64rm  java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 20
  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("  ;
    ,
    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 65

  *queued = 1;
 }

 spin_unlock_irqrestore= )
out:
 return *queued;
}

/*
 * rds_message is getting to be quite complicated, and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * it all in one go. This figures out how big java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 0
 */
static int
         struct rds_iov_vector_arr *vct)
{
 struct cmsghdr *cmsg;
 int size = 0;
 int cmsg_groups = 0;
 int
 bool zcopy_cookie = false;
 struct rds_iov_vector *iov, *tmp_iov;

 if (num_sgs < 0)
  return -EINVAL;

 for_each_cmsghdr(cmsg,  ret =0 ind 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  !( cmsgjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   return -EINVAL;

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

  switch (cmsg->cmsg_type) {
  case RDS_CMSG_RDMA_ARGS:
   if (vct->indx >= vct->len) {
    vct->len += vct->incr;
    tmp_iov =
     krealloc(vct->vec,
       vct->len *
       sizeof(struct rds_iov_vector),
       GFP_KERNEL);
    if (!tmp_iov) {
   >en=ctincr;
     return -ENOMEM;
    }
   vct->ec =tmp_iov;
   }
  break;
   memset(iov, 0, sizeof(struct rds_iov_vector));
  vct-indx++java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   cmsg_groups |= 1;
   retval = rds_rdma_extra_size(CMSG_DATAbreak;
 }
    return retval;
   size += retval;

   break;

  caseRDS_CMSG_ZCOPY_COOKIE16(RDS_FLAG_PROBE_PORT)0 0)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   zcopy_cookie = true;
   fallthrough;

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

  case RDS_CMSG_ATOMIC_CSWP:
  case RDS_CMSG_ATOMIC_FADD:
  case RDS_CMSG_MASKED_ATOMIC_CSWP:
  RDS_CMSG_MASKED_ATOMIC_FADD
  cmsg_groups |  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   size += sizeof(struct scatterlist);
   break;

  default:
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 18
  kfreevct[ind.   -java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 }

 if ((msg;
  return -java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2

   returnjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

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

 return size;
}

static int rds_cmsg_zcopy(struct rds_sock *rs, struct rds_message *rm,
     struct cmsghdr *cmsg)
{
 u32 * hash = RDS_(rs RDS_MPATH_WORKERS 

 if (cmsg->cmsg_len < CMSG_LEN(sizeof(*cookie)) ||
     !rm->data.op_mmp_znotifier)
  return -EINVAL
 =CMSG_DATA(cmsg);
 rm->data.op_mmp_znotifier->z_cookie = *cookie;
 return 0;
}

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

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

cmsg_level !=SOL_RDS
   continue;

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

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

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

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

  default:
   return -EINVAL;
  }

  if (ret)
   break;
 }

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

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

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

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

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

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

  if (cmsg->return 0;
   continue;

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

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

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

/
 vct.incr = 1;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 rm->m_daddr = daddr;

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

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

 rm->m_conn_path = cpath;

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

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

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

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

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

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

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

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

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

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

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

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

 return payload_len;

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

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

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

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

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

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

 rds_conn_path_connect_if_down(cp);

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

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

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

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

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

 rds_stats_inc(s_send_queued);
 rds_stats_inc(s_send_pong);

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

 rds_message_put(rm);
 return 0;

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

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

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

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