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