net/smc/smc_close.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Shared Memory Communications over RDMA (SMC-R) and RoCE
   4  *
   5  *  Socket Closing - normal and abnormal
   6  *
   7  *  Copyright IBM Corp. 2016
   8  *
   9  *  Author(s):  Ursula Braun <ubraun@linux.vnet.ibm.com>
  10  */
  11
  12 #include <linux/workqueue.h>
  13 #include <linux/sched/signal.h>
  14
  15 #include <net/sock.h>
  16
  17 #include "smc.h"
  18 #include "smc_tx.h"
  19 #include "smc_cdc.h"
  20 #include "smc_close.h"
  21
  22 #define SMC_CLOSE_WAIT_LISTEN_CLCSOCK_TIME      (5 * HZ)
  23
  24 static void smc_close_cleanup_listen(struct sock *parent)
  25 {
  26         struct sock *sk;
  27
  28         /* Close non-accepted connections */
  29         while ((sk = smc_accept_dequeue(parent, NULL)))
  30                 smc_close_non_accepted(sk);
  31 }
  32
  33 /* wait for sndbuf data being transmitted */
  34 static void smc_close_stream_wait(struct smc_sock *smc, long timeout)
  35 {
  36         DEFINE_WAIT_FUNC(wait, woken_wake_function);
  37         struct sock *sk = &smc->sk;
  38
  39         if (!timeout)
  40                 return;
  41
  42         if (!smc_tx_prepared_sends(&smc->conn))
  43                 return;
  44
  45         smc->wait_close_tx_prepared = 1;
  46         add_wait_queue(sk_sleep(sk), &wait);
  47         while (!signal_pending(current) && timeout) {
  48                 int rc;
  49
  50                 rc = sk_wait_event(sk, &timeout,
  51                                    !smc_tx_prepared_sends(&smc->conn) ||
  52                                    (sk->sk_err == ECONNABORTED) ||
  53                                    (sk->sk_err == ECONNRESET),
  54                                    &wait);
  55                 if (rc)
  56                         break;
  57         }
  58         remove_wait_queue(sk_sleep(sk), &wait);
  59         smc->wait_close_tx_prepared = 0;
  60 }
  61
  62 void smc_close_wake_tx_prepared(struct smc_sock *smc)
  63 {
  64         if (smc->wait_close_tx_prepared)
  65                 /* wake up socket closing */
  66                 smc->sk.sk_state_change(&smc->sk);
  67 }
  68
  69 static int smc_close_wr(struct smc_connection *conn)
  70 {
  71         conn->local_tx_ctrl.conn_state_flags.peer_done_writing = 1;
  72
  73         return smc_cdc_get_slot_and_msg_send(conn);
  74 }
  75
  76 static int smc_close_final(struct smc_connection *conn)
  77 {
  78         if (atomic_read(&conn->bytes_to_rcv))
  79                 conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
  80         else
  81                 conn->local_tx_ctrl.conn_state_flags.peer_conn_closed = 1;
  82
  83         return smc_cdc_get_slot_and_msg_send(conn);
  84 }
  85
  86 static int smc_close_abort(struct smc_connection *conn)
  87 {
  88         conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
  89
  90         return smc_cdc_get_slot_and_msg_send(conn);
  91 }
  92
  93 /* terminate smc socket abnormally - active abort
  94  * link group is terminated, i.e. RDMA communication no longer possible
  95  */
  96 static void smc_close_active_abort(struct smc_sock *smc)
  97 {
  98         struct sock *sk = &smc->sk;
  99
 100         struct smc_cdc_conn_state_flags *txflags =
 101                 &smc->conn.local_tx_ctrl.conn_state_flags;
 102
 103         if (sk->sk_state != SMC_INIT && smc->clcsock && smc->clcsock->sk) {
 104                 sk->sk_err = ECONNABORTED;
 105                 if (smc->clcsock && smc->clcsock->sk) {
 106                         smc->clcsock->sk->sk_err = ECONNABORTED;
 107                         smc->clcsock->sk->sk_state_change(smc->clcsock->sk);
 108                 }
 109         }
 110         switch (sk->sk_state) {
 111         case SMC_ACTIVE:
 112                 sk->sk_state = SMC_PEERABORTWAIT;
 113                 release_sock(sk);
 114                 cancel_delayed_work_sync(&smc->conn.tx_work);
 115                 lock_sock(sk);
 116                 sock_put(sk); /* passive closing */
 117                 break;
 118         case SMC_APPCLOSEWAIT1:
 119         case SMC_APPCLOSEWAIT2:
 120                 if (!smc_cdc_rxed_any_close(&smc->conn))
 121                         sk->sk_state = SMC_PEERABORTWAIT;
 122                 else
 123                         sk->sk_state = SMC_CLOSED;
 124                 release_sock(sk);
 125                 cancel_delayed_work_sync(&smc->conn.tx_work);
 126                 lock_sock(sk);
 127                 break;
 128         case SMC_PEERCLOSEWAIT1:
 129         case SMC_PEERCLOSEWAIT2:
 130                 if (!txflags->peer_conn_closed) {
 131                         /* just SHUTDOWN_SEND done */
 132                         sk->sk_state = SMC_PEERABORTWAIT;
 133                 } else {
 134                         sk->sk_state = SMC_CLOSED;
 135                 }
 136                 sock_put(sk); /* passive closing */
 137                 break;
 138         case SMC_PROCESSABORT:
 139         case SMC_APPFINCLOSEWAIT:
 140                 sk->sk_state = SMC_CLOSED;
 141                 break;
 142         case SMC_PEERFINCLOSEWAIT:
 143                 sock_put(sk); /* passive closing */
 144                 break;
 145         case SMC_INIT:
 146         case SMC_PEERABORTWAIT:
 147         case SMC_CLOSED:
 148                 break;
 149         }
 150
 151         sock_set_flag(sk, SOCK_DEAD);
 152         sk->sk_state_change(sk);
 153 }
 154
 155 static inline bool smc_close_sent_any_close(struct smc_connection *conn)
 156 {
 157         return conn->local_tx_ctrl.conn_state_flags.peer_conn_abort ||
 158                conn->local_tx_ctrl.conn_state_flags.peer_conn_closed;
 159 }
 160
 161 int smc_close_active(struct smc_sock *smc)
 162 {
 163         struct smc_cdc_conn_state_flags *txflags =
 164                 &smc->conn.local_tx_ctrl.conn_state_flags;
 165         struct smc_connection *conn = &smc->conn;
 166         struct sock *sk = &smc->sk;
 167         int old_state;
 168         long timeout;
 169         int rc = 0;
 170         int rc1 = 0;
 171
 172         timeout = current->flags & PF_EXITING ?
 173                   0 : sock_flag(sk, SOCK_LINGER) ?
 174                       sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
 175
 176         old_state = sk->sk_state;
 177 again:
 178         switch (sk->sk_state) {
 179         case SMC_INIT:
 180                 sk->sk_state = SMC_CLOSED;
 181                 break;
 182         case SMC_LISTEN:
 183                 sk->sk_state = SMC_CLOSED;
 184                 sk->sk_state_change(sk); /* wake up accept */
 185                 if (smc->clcsock && smc->clcsock->sk) {
 186                         rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR);
 187                         /* wake up kernel_accept of smc_tcp_listen_worker */
 188                         smc->clcsock->sk->sk_data_ready(smc->clcsock->sk);
 189                 }
 190                 smc_close_cleanup_listen(sk);
 191                 release_sock(sk);
 192                 flush_work(&smc->tcp_listen_work);
 193                 lock_sock(sk);
 194                 break;
 195         case SMC_ACTIVE:
 196                 smc_close_stream_wait(smc, timeout);
 197                 release_sock(sk);
 198                 cancel_delayed_work_sync(&conn->tx_work);
 199                 lock_sock(sk);
 200                 if (sk->sk_state == SMC_ACTIVE) {
 201                         /* send close request */
 202                         rc = smc_close_final(conn);
 203                         if (rc)
 204                                 break;
 205                         sk->sk_state = SMC_PEERCLOSEWAIT1;
 206
 207                         /* actively shutdown clcsock before peer close it,
 208                          * prevent peer from entering TIME_WAIT state.
 209                          */
 210                         if (smc->clcsock && smc->clcsock->sk) {
 211                                 rc1 = kernel_sock_shutdown(smc->clcsock,
 212                                                            SHUT_RDWR);
 213                                 rc = rc ? rc : rc1;
 214                         }
 215                 } else {
 216                         /* peer event has changed the state */
 217                         goto again;
 218                 }
 219                 break;
 220         case SMC_APPFINCLOSEWAIT:
 221                 /* socket already shutdown wr or both (active close) */
 222                 if (txflags->peer_done_writing &&
 223                     !smc_close_sent_any_close(conn)) {
 224                         /* just shutdown wr done, send close request */
 225                         rc = smc_close_final(conn);
 226                         if (rc)
 227                                 break;
 228                 }
 229                 sk->sk_state = SMC_CLOSED;
 230                 break;
 231         case SMC_APPCLOSEWAIT1:
 232         case SMC_APPCLOSEWAIT2:
 233                 if (!smc_cdc_rxed_any_close(conn))
 234                         smc_close_stream_wait(smc, timeout);
 235                 release_sock(sk);
 236                 cancel_delayed_work_sync(&conn->tx_work);
 237                 lock_sock(sk);
 238                 if (sk->sk_state != SMC_APPCLOSEWAIT1 &&
 239                     sk->sk_state != SMC_APPCLOSEWAIT2)
 240                         goto again;
 241                 /* confirm close from peer */
 242                 rc = smc_close_final(conn);
 243                 if (rc)
 244                         break;
 245                 if (smc_cdc_rxed_any_close(conn)) {
 246                         /* peer has closed the socket already */
 247                         sk->sk_state = SMC_CLOSED;
 248                         sock_put(sk); /* postponed passive closing */
 249                 } else {
 250                         /* peer has just issued a shutdown write */
 251                         sk->sk_state = SMC_PEERFINCLOSEWAIT;
 252                 }
 253                 break;
 254         case SMC_PEERCLOSEWAIT1:
 255         case SMC_PEERCLOSEWAIT2:
 256                 if (txflags->peer_done_writing &&
 257                     !smc_close_sent_any_close(conn)) {
 258                         /* just shutdown wr done, send close request */
 259                         rc = smc_close_final(conn);
 260                         if (rc)
 261                                 break;
 262                 }
 263                 /* peer sending PeerConnectionClosed will cause transition */
 264                 break;
 265         case SMC_PEERFINCLOSEWAIT:
 266                 /* peer sending PeerConnectionClosed will cause transition */
 267                 break;
 268         case SMC_PROCESSABORT:
 269                 smc_close_abort(conn);
 270                 sk->sk_state = SMC_CLOSED;
 271                 break;
 272         case SMC_PEERABORTWAIT:
 273         case SMC_CLOSED:
 274                 /* nothing to do, add tracing in future patch */
 275                 break;
 276         }
 277
 278         if (old_state != sk->sk_state)
 279                 sk->sk_state_change(sk);
 280         return rc;
 281 }
 282
 283 static void smc_close_passive_abort_received(struct smc_sock *smc)
 284 {
 285         struct smc_cdc_conn_state_flags *txflags =
 286                 &smc->conn.local_tx_ctrl.conn_state_flags;
 287         struct sock *sk = &smc->sk;
 288
 289         switch (sk->sk_state) {
 290         case SMC_INIT:
 291         case SMC_ACTIVE:
 292         case SMC_APPCLOSEWAIT1:
 293                 sk->sk_state = SMC_PROCESSABORT;
 294                 sock_put(sk); /* passive closing */
 295                 break;
 296         case SMC_APPFINCLOSEWAIT:
 297                 sk->sk_state = SMC_PROCESSABORT;
 298                 break;
 299         case SMC_PEERCLOSEWAIT1:
 300         case SMC_PEERCLOSEWAIT2:
 301                 if (txflags->peer_done_writing &&
 302                     !smc_close_sent_any_close(&smc->conn))
 303                         /* just shutdown, but not yet closed locally */
 304                         sk->sk_state = SMC_PROCESSABORT;
 305                 else
 306                         sk->sk_state = SMC_CLOSED;
 307                 sock_put(sk); /* passive closing */
 308                 break;
 309         case SMC_APPCLOSEWAIT2:
 310         case SMC_PEERFINCLOSEWAIT:
 311                 sk->sk_state = SMC_CLOSED;
 312                 sock_put(sk); /* passive closing */
 313                 break;
 314         case SMC_PEERABORTWAIT:
 315                 sk->sk_state = SMC_CLOSED;
 316                 break;
 317         case SMC_PROCESSABORT:
 318         /* nothing to do, add tracing in future patch */
 319                 break;
 320         }
 321 }
 322
 323 /* Either some kind of closing has been received: peer_conn_closed,
 324  * peer_conn_abort, or peer_done_writing
 325  * or the link group of the connection terminates abnormally.
 326  */
 327 static void smc_close_passive_work(struct work_struct *work)
 328 {
 329         struct smc_connection *conn = container_of(work,
 330                                                    struct smc_connection,
 331                                                    close_work);
 332         struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
 333         struct smc_cdc_conn_state_flags *rxflags;
 334         struct sock *sk = &smc->sk;
 335         int old_state;
 336
 337         lock_sock(sk);
 338         old_state = sk->sk_state;
 339
 340         if (!conn->alert_token_local) {
 341                 /* abnormal termination */
 342                 smc_close_active_abort(smc);
 343                 goto wakeup;
 344         }
 345
 346         rxflags = &conn->local_rx_ctrl.conn_state_flags;
 347         if (rxflags->peer_conn_abort) {
 348                 /* peer has not received all data */
 349                 smc_close_passive_abort_received(smc);
 350                 release_sock(&smc->sk);
 351                 cancel_delayed_work_sync(&conn->tx_work);
 352                 lock_sock(&smc->sk);
 353                 goto wakeup;
 354         }
 355
 356         switch (sk->sk_state) {
 357         case SMC_INIT:
 358                 if (atomic_read(&conn->bytes_to_rcv) ||
 359                     (rxflags->peer_done_writing &&
 360                      !smc_cdc_rxed_any_close(conn))) {
 361                         sk->sk_state = SMC_APPCLOSEWAIT1;
 362                 } else {
 363                         sk->sk_state = SMC_CLOSED;
 364                         sock_put(sk); /* passive closing */
 365                 }
 366                 break;
 367         case SMC_ACTIVE:
 368                 sk->sk_state = SMC_APPCLOSEWAIT1;
 369                 /* postpone sock_put() for passive closing to cover
 370                  * received SEND_SHUTDOWN as well
 371                  */
 372                 break;
 373         case SMC_PEERCLOSEWAIT1:
 374                 if (rxflags->peer_done_writing)
 375                         sk->sk_state = SMC_PEERCLOSEWAIT2;
 376                 /* fall through */
 377                 /* to check for closing */
 378         case SMC_PEERCLOSEWAIT2:
 379                 if (!smc_cdc_rxed_any_close(conn))
 380                         break;
 381                 if (sock_flag(sk, SOCK_DEAD) &&
 382                     smc_close_sent_any_close(conn)) {
 383                         /* smc_release has already been called locally */
 384                         sk->sk_state = SMC_CLOSED;
 385                 } else {
 386                         /* just shutdown, but not yet closed locally */
 387                         sk->sk_state = SMC_APPFINCLOSEWAIT;
 388                 }
 389                 sock_put(sk); /* passive closing */
 390                 break;
 391         case SMC_PEERFINCLOSEWAIT:
 392                 if (smc_cdc_rxed_any_close(conn)) {
 393                         sk->sk_state = SMC_CLOSED;
 394                         sock_put(sk); /* passive closing */
 395                 }
 396                 break;
 397         case SMC_APPCLOSEWAIT1:
 398         case SMC_APPCLOSEWAIT2:
 399                 /* postpone sock_put() for passive closing to cover
 400                  * received SEND_SHUTDOWN as well
 401                  */
 402                 break;
 403         case SMC_APPFINCLOSEWAIT:
 404         case SMC_PEERABORTWAIT:
 405         case SMC_PROCESSABORT:
 406         case SMC_CLOSED:
 407                 /* nothing to do, add tracing in future patch */
 408                 break;
 409         }
 410
 411 wakeup:
 412         sk->sk_data_ready(sk); /* wakeup blocked rcvbuf consumers */
 413         sk->sk_write_space(sk); /* wakeup blocked sndbuf producers */
 414
 415         if (old_state != sk->sk_state) {
 416                 sk->sk_state_change(sk);
 417                 if ((sk->sk_state == SMC_CLOSED) &&
 418                     (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket))
 419                         smc_conn_free(conn);
 420         }
 421         release_sock(sk);
 422         sock_put(sk); /* sock_hold done by schedulers of close_work */
 423 }
 424
 425 int smc_close_shutdown_write(struct smc_sock *smc)
 426 {
 427         struct smc_connection *conn = &smc->conn;
 428         struct sock *sk = &smc->sk;
 429         int old_state;
 430         long timeout;
 431         int rc = 0;
 432
 433         timeout = current->flags & PF_EXITING ?
 434                   0 : sock_flag(sk, SOCK_LINGER) ?
 435                       sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
 436
 437         old_state = sk->sk_state;
 438 again:
 439         switch (sk->sk_state) {
 440         case SMC_ACTIVE:
 441                 smc_close_stream_wait(smc, timeout);
 442                 release_sock(sk);
 443                 cancel_delayed_work_sync(&conn->tx_work);
 444                 lock_sock(sk);
 445                 if (sk->sk_state != SMC_ACTIVE)
 446                         goto again;
 447                 /* send close wr request */
 448                 rc = smc_close_wr(conn);
 449                 if (rc)
 450                         break;
 451                 sk->sk_state = SMC_PEERCLOSEWAIT1;
 452                 break;
 453         case SMC_APPCLOSEWAIT1:
 454                 /* passive close */
 455                 if (!smc_cdc_rxed_any_close(conn))
 456                         smc_close_stream_wait(smc, timeout);
 457                 release_sock(sk);
 458                 cancel_delayed_work_sync(&conn->tx_work);
 459                 lock_sock(sk);
 460                 if (sk->sk_state != SMC_APPCLOSEWAIT1)
 461                         goto again;
 462                 /* confirm close from peer */
 463                 rc = smc_close_wr(conn);
 464                 if (rc)
 465                         break;
 466                 sk->sk_state = SMC_APPCLOSEWAIT2;
 467                 break;
 468         case SMC_APPCLOSEWAIT2:
 469         case SMC_PEERFINCLOSEWAIT:
 470         case SMC_PEERCLOSEWAIT1:
 471         case SMC_PEERCLOSEWAIT2:
 472         case SMC_APPFINCLOSEWAIT:
 473         case SMC_PROCESSABORT:
 474         case SMC_PEERABORTWAIT:
 475                 /* nothing to do, add tracing in future patch */
 476                 break;
 477         }
 478
 479         if (old_state != sk->sk_state)
 480                 sk->sk_state_change(sk);
 481         return rc;
 482 }
 483
 484 /* Initialize close properties on connection establishment. */
 485 void smc_close_init(struct smc_sock *smc)
 486 {
 487         INIT_WORK(&smc->conn.close_work, smc_close_passive_work);
 488 }