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 sk->sk_err = ECONNABORTED; 104 if (smc->clcsock && smc->clcsock->sk) { 105 smc->clcsock->sk->sk_err = ECONNABORTED; 106 smc->clcsock->sk->sk_state_change(smc->clcsock->sk); 107 } 108 switch (sk->sk_state) { 109 case SMC_INIT: 110 case SMC_ACTIVE: 111 sk->sk_state = SMC_PEERABORTWAIT; 112 release_sock(sk); 113 cancel_delayed_work_sync(&smc->conn.tx_work); 114 lock_sock(sk); 115 sock_put(sk); /* passive closing */ 116 break; 117 case SMC_APPCLOSEWAIT1: 118 case SMC_APPCLOSEWAIT2: 119 if (!smc_cdc_rxed_any_close(&smc->conn)) 120 sk->sk_state = SMC_PEERABORTWAIT; 121 else 122 sk->sk_state = SMC_CLOSED; 123 release_sock(sk); 124 cancel_delayed_work_sync(&smc->conn.tx_work); 125 lock_sock(sk); 126 break; 127 case SMC_PEERCLOSEWAIT1: 128 case SMC_PEERCLOSEWAIT2: 129 if (!txflags->peer_conn_closed) { 130 /* just SHUTDOWN_SEND done */ 131 sk->sk_state = SMC_PEERABORTWAIT; 132 } else { 133 sk->sk_state = SMC_CLOSED; 134 } 135 sock_put(sk); /* passive closing */ 136 break; 137 case SMC_PROCESSABORT: 138 case SMC_APPFINCLOSEWAIT: 139 sk->sk_state = SMC_CLOSED; 140 break; 141 case SMC_PEERFINCLOSEWAIT: 142 sock_put(sk); /* passive closing */ 143 break; 144 case SMC_PEERABORTWAIT: 145 case SMC_CLOSED: 146 break; 147 } 148 149 sock_set_flag(sk, SOCK_DEAD); 150 sk->sk_state_change(sk); 151 } 152 153 static inline bool smc_close_sent_any_close(struct smc_connection *conn) 154 { 155 return conn->local_tx_ctrl.conn_state_flags.peer_conn_abort || 156 conn->local_tx_ctrl.conn_state_flags.peer_conn_closed; 157 } 158 159 int smc_close_active(struct smc_sock *smc) 160 { 161 struct smc_cdc_conn_state_flags *txflags = 162 &smc->conn.local_tx_ctrl.conn_state_flags; 163 struct smc_connection *conn = &smc->conn; 164 struct sock *sk = &smc->sk; 165 int old_state; 166 long timeout; 167 int rc = 0; 168 169 timeout = current->flags & PF_EXITING ? 170 0 : sock_flag(sk, SOCK_LINGER) ? 171 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT; 172 173 old_state = sk->sk_state; 174 again: 175 switch (sk->sk_state) { 176 case SMC_INIT: 177 sk->sk_state = SMC_CLOSED; 178 break; 179 case SMC_LISTEN: 180 sk->sk_state = SMC_CLOSED; 181 sk->sk_state_change(sk); /* wake up accept */ 182 if (smc->clcsock && smc->clcsock->sk) { 183 rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR); 184 /* wake up kernel_accept of smc_tcp_listen_worker */ 185 smc->clcsock->sk->sk_data_ready(smc->clcsock->sk); 186 } 187 smc_close_cleanup_listen(sk); 188 release_sock(sk); 189 flush_work(&smc->tcp_listen_work); 190 lock_sock(sk); 191 break; 192 case SMC_ACTIVE: 193 smc_close_stream_wait(smc, timeout); 194 release_sock(sk); 195 cancel_delayed_work_sync(&conn->tx_work); 196 lock_sock(sk); 197 if (sk->sk_state == SMC_ACTIVE) { 198 /* send close request */ 199 rc = smc_close_final(conn); 200 if (rc) 201 break; 202 sk->sk_state = SMC_PEERCLOSEWAIT1; 203 } else { 204 /* peer event has changed the state */ 205 goto again; 206 } 207 break; 208 case SMC_APPFINCLOSEWAIT: 209 /* socket already shutdown wr or both (active close) */ 210 if (txflags->peer_done_writing && 211 !smc_close_sent_any_close(conn)) { 212 /* just shutdown wr done, send close request */ 213 rc = smc_close_final(conn); 214 if (rc) 215 break; 216 } 217 sk->sk_state = SMC_CLOSED; 218 break; 219 case SMC_APPCLOSEWAIT1: 220 case SMC_APPCLOSEWAIT2: 221 if (!smc_cdc_rxed_any_close(conn)) 222 smc_close_stream_wait(smc, timeout); 223 release_sock(sk); 224 cancel_delayed_work_sync(&conn->tx_work); 225 lock_sock(sk); 226 if (sk->sk_state != SMC_APPCLOSEWAIT1 && 227 sk->sk_state != SMC_APPCLOSEWAIT2) 228 goto again; 229 /* confirm close from peer */ 230 rc = smc_close_final(conn); 231 if (rc) 232 break; 233 if (smc_cdc_rxed_any_close(conn)) { 234 /* peer has closed the socket already */ 235 sk->sk_state = SMC_CLOSED; 236 sock_put(sk); /* postponed passive closing */ 237 } else { 238 /* peer has just issued a shutdown write */ 239 sk->sk_state = SMC_PEERFINCLOSEWAIT; 240 } 241 break; 242 case SMC_PEERCLOSEWAIT1: 243 case SMC_PEERCLOSEWAIT2: 244 if (txflags->peer_done_writing && 245 !smc_close_sent_any_close(conn)) { 246 /* just shutdown wr done, send close request */ 247 rc = smc_close_final(conn); 248 if (rc) 249 break; 250 } 251 /* peer sending PeerConnectionClosed will cause transition */ 252 break; 253 case SMC_PEERFINCLOSEWAIT: 254 /* peer sending PeerConnectionClosed will cause transition */ 255 break; 256 case SMC_PROCESSABORT: 257 smc_close_abort(conn); 258 sk->sk_state = SMC_CLOSED; 259 break; 260 case SMC_PEERABORTWAIT: 261 case SMC_CLOSED: 262 /* nothing to do, add tracing in future patch */ 263 break; 264 } 265 266 if (old_state != sk->sk_state) 267 sk->sk_state_change(sk); 268 return rc; 269 } 270 271 static void smc_close_passive_abort_received(struct smc_sock *smc) 272 { 273 struct smc_cdc_conn_state_flags *txflags = 274 &smc->conn.local_tx_ctrl.conn_state_flags; 275 struct sock *sk = &smc->sk; 276 277 switch (sk->sk_state) { 278 case SMC_INIT: 279 case SMC_ACTIVE: 280 case SMC_APPCLOSEWAIT1: 281 sk->sk_state = SMC_PROCESSABORT; 282 sock_put(sk); /* passive closing */ 283 break; 284 case SMC_APPFINCLOSEWAIT: 285 sk->sk_state = SMC_PROCESSABORT; 286 break; 287 case SMC_PEERCLOSEWAIT1: 288 case SMC_PEERCLOSEWAIT2: 289 if (txflags->peer_done_writing && 290 !smc_close_sent_any_close(&smc->conn)) 291 /* just shutdown, but not yet closed locally */ 292 sk->sk_state = SMC_PROCESSABORT; 293 else 294 sk->sk_state = SMC_CLOSED; 295 sock_put(sk); /* passive closing */ 296 break; 297 case SMC_APPCLOSEWAIT2: 298 case SMC_PEERFINCLOSEWAIT: 299 sk->sk_state = SMC_CLOSED; 300 sock_put(sk); /* passive closing */ 301 break; 302 case SMC_PEERABORTWAIT: 303 sk->sk_state = SMC_CLOSED; 304 break; 305 case SMC_PROCESSABORT: 306 /* nothing to do, add tracing in future patch */ 307 break; 308 } 309 } 310 311 /* Either some kind of closing has been received: peer_conn_closed, 312 * peer_conn_abort, or peer_done_writing 313 * or the link group of the connection terminates abnormally. 314 */ 315 static void smc_close_passive_work(struct work_struct *work) 316 { 317 struct smc_connection *conn = container_of(work, 318 struct smc_connection, 319 close_work); 320 struct smc_sock *smc = container_of(conn, struct smc_sock, conn); 321 struct smc_cdc_conn_state_flags *rxflags; 322 struct sock *sk = &smc->sk; 323 int old_state; 324 325 lock_sock(sk); 326 old_state = sk->sk_state; 327 328 if (!conn->alert_token_local) { 329 /* abnormal termination */ 330 smc_close_active_abort(smc); 331 goto wakeup; 332 } 333 334 rxflags = &conn->local_rx_ctrl.conn_state_flags; 335 if (rxflags->peer_conn_abort) { 336 /* peer has not received all data */ 337 smc_close_passive_abort_received(smc); 338 release_sock(&smc->sk); 339 cancel_delayed_work_sync(&conn->tx_work); 340 lock_sock(&smc->sk); 341 goto wakeup; 342 } 343 344 switch (sk->sk_state) { 345 case SMC_INIT: 346 if (atomic_read(&conn->bytes_to_rcv) || 347 (rxflags->peer_done_writing && 348 !smc_cdc_rxed_any_close(conn))) { 349 sk->sk_state = SMC_APPCLOSEWAIT1; 350 } else { 351 sk->sk_state = SMC_CLOSED; 352 sock_put(sk); /* passive closing */ 353 } 354 break; 355 case SMC_ACTIVE: 356 sk->sk_state = SMC_APPCLOSEWAIT1; 357 /* postpone sock_put() for passive closing to cover 358 * received SEND_SHUTDOWN as well 359 */ 360 break; 361 case SMC_PEERCLOSEWAIT1: 362 if (rxflags->peer_done_writing) 363 sk->sk_state = SMC_PEERCLOSEWAIT2; 364 /* fall through */ 365 /* to check for closing */ 366 case SMC_PEERCLOSEWAIT2: 367 if (!smc_cdc_rxed_any_close(conn)) 368 break; 369 if (sock_flag(sk, SOCK_DEAD) && 370 smc_close_sent_any_close(conn)) { 371 /* smc_release has already been called locally */ 372 sk->sk_state = SMC_CLOSED; 373 } else { 374 /* just shutdown, but not yet closed locally */ 375 sk->sk_state = SMC_APPFINCLOSEWAIT; 376 } 377 sock_put(sk); /* passive closing */ 378 break; 379 case SMC_PEERFINCLOSEWAIT: 380 if (smc_cdc_rxed_any_close(conn)) { 381 sk->sk_state = SMC_CLOSED; 382 sock_put(sk); /* passive closing */ 383 } 384 break; 385 case SMC_APPCLOSEWAIT1: 386 case SMC_APPCLOSEWAIT2: 387 /* postpone sock_put() for passive closing to cover 388 * received SEND_SHUTDOWN as well 389 */ 390 break; 391 case SMC_APPFINCLOSEWAIT: 392 case SMC_PEERABORTWAIT: 393 case SMC_PROCESSABORT: 394 case SMC_CLOSED: 395 /* nothing to do, add tracing in future patch */ 396 break; 397 } 398 399 wakeup: 400 sk->sk_data_ready(sk); /* wakeup blocked rcvbuf consumers */ 401 sk->sk_write_space(sk); /* wakeup blocked sndbuf producers */ 402 403 if (old_state != sk->sk_state) { 404 sk->sk_state_change(sk); 405 if ((sk->sk_state == SMC_CLOSED) && 406 (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket)) 407 smc_conn_free(conn); 408 } 409 release_sock(sk); 410 sock_put(sk); /* sock_hold done by schedulers of close_work */ 411 } 412 413 int smc_close_shutdown_write(struct smc_sock *smc) 414 { 415 struct smc_connection *conn = &smc->conn; 416 struct sock *sk = &smc->sk; 417 int old_state; 418 long timeout; 419 int rc = 0; 420 421 timeout = current->flags & PF_EXITING ? 422 0 : sock_flag(sk, SOCK_LINGER) ? 423 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT; 424 425 old_state = sk->sk_state; 426 again: 427 switch (sk->sk_state) { 428 case SMC_ACTIVE: 429 smc_close_stream_wait(smc, timeout); 430 release_sock(sk); 431 cancel_delayed_work_sync(&conn->tx_work); 432 lock_sock(sk); 433 if (sk->sk_state != SMC_ACTIVE) 434 goto again; 435 /* send close wr request */ 436 rc = smc_close_wr(conn); 437 if (rc) 438 break; 439 sk->sk_state = SMC_PEERCLOSEWAIT1; 440 break; 441 case SMC_APPCLOSEWAIT1: 442 /* passive close */ 443 if (!smc_cdc_rxed_any_close(conn)) 444 smc_close_stream_wait(smc, timeout); 445 release_sock(sk); 446 cancel_delayed_work_sync(&conn->tx_work); 447 lock_sock(sk); 448 if (sk->sk_state != SMC_APPCLOSEWAIT1) 449 goto again; 450 /* confirm close from peer */ 451 rc = smc_close_wr(conn); 452 if (rc) 453 break; 454 sk->sk_state = SMC_APPCLOSEWAIT2; 455 break; 456 case SMC_APPCLOSEWAIT2: 457 case SMC_PEERFINCLOSEWAIT: 458 case SMC_PEERCLOSEWAIT1: 459 case SMC_PEERCLOSEWAIT2: 460 case SMC_APPFINCLOSEWAIT: 461 case SMC_PROCESSABORT: 462 case SMC_PEERABORTWAIT: 463 /* nothing to do, add tracing in future patch */ 464 break; 465 } 466 467 if (old_state != sk->sk_state) 468 sk->sk_state_change(sk); 469 return rc; 470 } 471 472 /* Initialize close properties on connection establishment. */ 473 void smc_close_init(struct smc_sock *smc) 474 { 475 INIT_WORK(&smc->conn.close_work, smc_close_passive_work); 476 } 477