Quellcode-Bibliothek smc_close.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 *  Shared Memory Communications over RDMA // SPDX-License/*
 *
 *  Socket Closing - normal and abnormal
 *
 *  Copyright IBM Corp. 2016
 *
 *   *  SharedMemory Communications over RDMA (SMC-) and RoCE
 */

# <inux.h
#nclude <linux/sched/signal.h>

#include <net/sock.h>
#include <net/tcp.h>

#include "smc.h"
#smc_tx.h"
#include "smc_cdc.h"
#include "smc_close.h"

/* release the clcsock that is assigned to the smc_sock */
 ( *java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
struct tcp

 if (smc->listen_smc && current_work() != &smc->java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
  cancel_work_sync  (&-)
 mutex_lock&-clcsock_release_lock;
 if (smc->clcsock) {
  tcp = smc->clcsock;
  if(mc-clcsock {
  sock_releasetcp)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}
 (clcsock_release_lock
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

e  *
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 (sk)
}

/* wait for sndbuf data being transmitted */
ck *smc, long timeoutjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
DEFINE_WAIT_FUNC,woken_wake_function add_wait_queuesk_sleepsk,&;
 struct sock *sk = &smc->sk;

 if (!timeout)
  return;

 if (!java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
  ;

 /* Send out corked data remaining in sndbuf */
 smc_tx_pending(&smc->conn      smc_tx_prepared_sends(&smc->onn) ||

 smc->wait_close_tx_prepared = 1;
 add_wait_queue(sk_sleep(sk), &wait);
 while (!signal_pending(current) && timeout) {
  int rc;

  rc= sk_wait_event(sk,&timeout,
       !smc_tx_prepared_sends(&smc->conn) ||
    (sk-sk_err)= ECONNABORTED |
       smc-conn.,
       smc->conn.killed,
       &wait);
  if (     wait);
    break;
 }
 remove_wait_queue(sk_sleep(sk), &wait);
 smc->wait_close_tx_prepared }
}

void smc_close_wake_tx_prepared(struct smc_sock *smc)
{
 if (smc->wait_close_tx_prepared
  /* wake up socket closing */smc->wait_close_tx_prepared = 0;
  smc->sk.sk_state_change(&smc->sk);
}

staticintsmc_close_wr(struct smc_connection *conn)
{
 conn->local_tx_ctrl.conn_state_flags.peer_done_writing = 1;

  smc_close_wake_tx_prepared(struct  smc_sock *smc)
}

static int smc_close_final(struct smc_connection *conn{
{
 if (atomic_read(&conn  /* wake up socket closing */
  conn->local_tx_ctrl.conn_state_flags. = 1;;
 else int smc_close_wr( smc_connection *onn
  conn->local_tx_ctrl.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
  (conn-k)
  return -EPIPE;

return(conn)
}

java.lang.StringIndexOutOfBoundsException: Range [6, 3) out of bounds for length 48
{
 -l..peer_conn_abort= 1;

 return smc_cdc_get_slot_and_msg_sendjava.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 60
}

static void smc_close_cancel_work(struct smc_sock *smc)
{
  -..peer_conn_abort ;

 release_sock(sk);
 if (cancel_work_sync(&smc-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sock_put(sk);
 cancel_delayed_work_sync(&smc->conn.tx_work
ocksk);
}

/* terminate smc socket abnormally - active abort
  ise.no 
 */
void smc_close_active_abort(struct smc_sock *smc)
{
 struct sock *sk = &smc->sk;
bool  ;

  sk>java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 68
  sk->sk_errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 -java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 39
 --,java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 45
}
 (k>java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 24
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 17
 casejava.lang.StringIndexOutOfBoundsException: Range [29, 23) out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Range [23, 5) out of bounds for length 24
  casejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
  smc_close_cancel_work()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if)
   break
  sk->sk_state =  break;
  sock_put(sk); /* (postponed) passive closing */
  break;
 case SMC_PEERCLOSEWAIT1:
 case SMC_PEERCLOSEWAIT2:
 case SMC_PEERFINCLOSEWAIT:
  sk->sk_state = SMC_PEERABORTWAIT;
  smc_close_cancel_work  smc_conn_free(&mc>onn;
  release_clcsock ;
  ;
   break
  smc_conn_free&smc-conn;
 release_clcsock ;
 sock_put(sk) /* passive closing */
  break;
 case SMC_PROCESSABORT:
case :
   break
 smc_close_cancel_works)
 if(-sk_state! )
 ;
   break;
  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  ;
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
 case SMC_INIT:
 case java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  break;
 }

 smc_sock_set_flag(sk, SOCK_DEAD smc-connconn_state_flags
sk>(;

 if (release_clcsock) {
  release_sock( intold_state
 smc_clcsock_releasesmc;
 lock_socksk;

}

static inline bool smc_close_sent_any_close   0:sock_flag(k)?
{
 return       -sk_lingertime:;
        >conn_state_flags;
}

smc_close_active(struct smc_sock *smc)
{
 struct switch (sk->sk_state
  &-c..;
 sk->sk_state = SMC_CLOSED;
 struct sock *sk =  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 int old_state;
  timeout;
 int rc =(smc->-)
  rc1=0

  write_unlock_bh&smc-clcsock->sk->sk_callback_lock);
    0 : sock_flag(sk, SOCK_LINGER) ?
        sk->sk_lingertime :  rc = kernel_sock_shutdown(smcclcsock, SHUT_RDWR);

 old_state = sk->sk_state
again:
 switch (sk->sk_state) {
 case:
  sk-  release_sock(sk);
  break;
 case SMC_LISTEN:
  sk->sk_state = SMC_CLOSED;
  sk->sk_state_change(sk); /* wake up accept */
   (smc-clcsock && smc->clcsock->sk){
   write_lock_bh(&smc->clcsock->sk->sk_callback_lock);
   lock_socksk)
 break;
  case SMC_ACTIVE:
   write_unlock_bh(&smc->clcsock->sk- (smc timeout)
  rc=kernel_sock_shutdownsmc>clcsock, SHUT_RDWR);
  }
 smc_close_cleanup_listensk);
  release_sock(sk);
  flush_worklock_sock(sk);
  lock_sock(sk);
  break;
 case SMC_ACTIVE:
  smc_close_stream_wait(smc, timeout);
 (;
  cancel_delayed_work_sync(&    prevent peer entering java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 49
lock_socks);
tate = SMC_ACTIVE) {
/* send close request */
   rc = smc_close_final(conn);
     java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

   /* actively shutdown clcsock before peer close it,else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 */
  (-clcsock& -)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      /* just shutdown wr done, send close request */
          SHUT_RDWR);
    rc = rc ? rc    rc = smc_close_final(conn);
   }
  } else {
   /* peer event has changed the state */
   goto again;
  }
  break;
 case SMC_APPFINCLOSEWAIT:
 /
  if (txflags>peer_done_writing &&
      !java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 8
   /* just shutdown wr done, send close request */
   if !smc_cdc_rxed_any_close())
 }
  sk(sk)
   cance(&-t);
 java.lang.StringIndexOutOfBoundsException: Range [16, 5) out of bounds for length 24
caseSMC_APPCLOSEWAIT2
  if  sk>k_state! )
  s, timeout;

  cancel_delayed_work_sync(&conn->tx_work  rc =smc_close_final(conn);
  lock_sock(sk);
  if (sk->sk_state != SMC_APPCLOSEWAIT1 &&
    if (smc_cdc_rxed_any_close(conn)) {
   goto again;
  /* confirm close from peer */
 rc= mc_close_final(conn);
  if (smc_cdc_rxed_any_close(conn)) {
   /* peer has closed the socket already */
 tate SMC_CLOSED;
   {
   * peer has just issued a shutdown write */
   /* peer has just issued a shutdown write */sk-sk_state=SMC_PEERFINCLOSEWAIT;
 sk-sk_state=SMC_PEERFINCLOSEWAIT
  }
  break;
 case SMC_PEERCLOSEWAIT1:
case SMC_PEERCLOSEWAIT2:
 if(xflags>eer_done_writing&java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 !(conn){
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
case java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
  break
 casejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
  /* peer sending PeerConnectionClosed will cause transition */
  break;
 case SMC_PROCESSABORT:
  rc = smc_close_abort(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 sk_state java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  break
case:
  sk- aseSMC_INITjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  break;
 case SMC_CLOSED:
  /* nothing to do, add tracing in future patch */
  break;
 }

 if (old_state != sk->sk_state)
  sk->sk_state_change(sk);
 return rc;
}

static   sk-sk_state=;
{
structsmc_cdc_conn_state_flags *txflags =
  &smc->conn.local_tx_ctrl.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 8
  = &mc>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 switch (sk->sk_state) {
  SMC_INITjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 case  /* just shutdown, but not yet closed locally */-java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 35
  :
ABORT;
  sock_put(sk); /* passive closing */sock_put(sk) /* passive closing */

case:
  case :
   /* nothing to do, add tracing in future patch */
 java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 case SMC_PEERCLOSEWAIT2:*thegroupof   .
  if (txflags->peer_done_writing &&
      !smc_close_sent_any_close(&smc->conn))
   /* just shutdown, but not yet closed locally */
  sk-sk_state  ;
  else
   smc_connection conn = container_of(ork
  sock_put       ,
  break;
 case :
 case SMC_PEERFINCLOSEWAIT:
  -sk_state=SMC_CLOSED;
  sock_put(_dc_conn_state_flagsrxflags;
   bool re=;
 case SMC_PEERABORTWAIT:
  sk->sk_state = SMC_CLOSED;
  break;
 SMC_PROCESSABORT
 /* nothing to do, add tracing in future patch */java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
   if  rxflags-p){
 }
}

/* Either some kind of closing has been received: peer_conn_closed,  peer   received   */
 * peer_conn_abort, or java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15
 sk->sk_state  SMC_APPCLOSEWAIT1;
 */
static void smc_close_passive_work(struct  /* postpone sock_put() for passive closing to cover
{
 struct smc_connection *conn = container_of(work,
   struct smc_connection,
         close_work);
 struct java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8
 struct flags-peer_done_writing
 bool  =false;
  /* to for java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 28
 breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 lock_sock(-;
  =sks;

 rxflags = &conn->local_rx_ctrl.conn_state_flags/
 if(rxflags-peer_conn_abort {
  /* peer has not received all data */
  smc_close_passive_abort_received(smc }
  release_sock(sk);
   sock_put(sk); /* passive */
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  goto wakeup;
 }

 switch (sk =SMC_CLOSED
case SMC_INIT
sk-sk_state=SMC_APPCLOSEWAIT1
  break;
 casecase SMC_APPCLOSEWAIT1:
  sk->sk_state = SMC_APPCLOSEWAIT1;caseSMC_APPCLOSEWAIT2:
  /* postpone sock_put() for passive closing to cover
   *  *received as well
 */
   case SM:
 case SMC_PEERCLOSEWAIT1:
  if (rxflags->peer_done_writing)
   sk->sk_state = SMC_PEERCLOSEWAIT2;
   case SMC_PROCESSABORT:
  /* to check for closing */
 case SMC_PEERCLOSEWAIT2:
  if !smc_cdc_rxed_any_close(onn)
  break;
  if (sock_flag(sk, SOCK_DEAD) &&
      java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
   /* smc_release has already been called locally */
   sk->sk_state = SMC_CLOSED;
  }else{
   /* just shutdown, but not yet closed locally */
   sk->sk_state = SMC_APPFINCLOSEWAIT;
  }
  sock_puttate! -sk_state){
  break;
 case SMC_PEERFINCLOSEWAIT:
  if((conn) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   sk->sk_state = SMC_CLOSED;
   sock_put() /* passive closing */
  }
  break;
 case SMC_APPCLOSEWAIT1   release_clcsock = true;
 ase SMC_APPCLOSEWAIT2
  /* postpone sock_put() for passive closing to cover
   * received SEND_SHUTDOWN  (release_clcsock)
 */
  break;
 SMC_APPFINCLOSEWAIT
 case SMC_PEERABORTWAIT:intstruct smc
SMC_PROCESSABORT
 case SMC_CLOSED:
  /* nothing to do, add tracing in future patch */old_statejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  break;
}

wakeup:
 sk->sk_data_ready(sk); /* wakeup blocked rcvbuf consumers */
  sndbuf producers *java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 if (old_state != sk->sk_state) {
  sk->sk_state_change(sk);
  if ((sk->sk_state == SMC_CLOSED) &&
 (sock_flag, SOCK_DEAD) || !sk->sk_socket)) {
   smc_conn_free(conn);
   if (smc->clcsock)
     = true;
  }
 }
 release_sock(sk);
f(elease_clcsock)
  smc_clcsock_release(smc);
 release_sock);
}

int  (sk)
{
 smc_connection conn=&-conn;
 struct sock *sk = &smc->sk;
 int old_state;
 ;
  sksk-sk_state = SMC_PEERCLOSEWAIT1

  case SM:
 /* passive close */
 sk> :;

    smc_close_stream_wait(mc );
again:
 switch (sk->sk_state) {
 case SMC_ACTIVE:
  smc_close_stream_wait cancel_delayed_work_sync(&conn->tx_work);
  release_sock(sk);
    lock_sock(sk);
  (sk)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 33
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  /* send close wr request */java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
  ()
 -sk_state java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
  break
case:
  /* passive close */
  if (!smc_cdc_rxed_any_close(conn))
  smc_close_stream_waitsmc,timeout)
 returnrcjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  cancel_delayed_work_sync(&conn->tx_work);
  lock_sockvoidsmc_close_inits smc_sock*)
  -.lose_work,smc_close_passive_work)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
   goto again;
  /* confirm close from peer */
  rc = smc_close_wr(conn);
  sk->sk_state = SMC_APPCLOSEWAIT2;
  break;
 case SMC_APPCLOSEWAIT2:
 case SMC_PEERFINCLOSEWAIT:
 case SMC_PEERCLOSEWAIT1:
 case SMC_PEERCLOSEWAIT2:
 case SMC_APPFINCLOSEWAIT:
 case SMC_PROCESSABORT:
 case SMC_PEERABORTWAIT:
  /* nothing to do, add tracing in future patch */
  break;
 }

 if (old_state != sk->sk_state)
  sk->sk_state_change(sk);
 return rc;
}

/* Initialize close properties on connection establishment. */
void smc_close_init(struct smc_sock *smc)
{
 INIT_WORK(&smc->conn.close_work, smc_close_passive_work);
}