1 // SPDX-License-Identifier: GPL-2.0
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
5 * Socket Closing - normal and abnormal
7 * Copyright IBM Corp. 2016
9 * Author(s): Ursula Braun <ubraun@linux.vnet.ibm.com>
12 #include <linux/workqueue.h>
13 #include <linux/sched/signal.h>
20 #include "smc_close.h"
22 #define SMC_CLOSE_WAIT_TX_PENDS_TIME (5 * HZ)
24 static void smc_close_cleanup_listen(struct sock *parent)
28 /* Close non-accepted connections */
29 while ((sk = smc_accept_dequeue(parent, NULL)))
30 smc_close_non_accepted(sk);
33 static void smc_close_wait_tx_pends(struct smc_sock *smc)
35 DEFINE_WAIT_FUNC(wait, woken_wake_function);
36 struct sock *sk = &smc->sk;
39 timeout = SMC_CLOSE_WAIT_TX_PENDS_TIME;
40 add_wait_queue(sk_sleep(sk), &wait);
41 while (!signal_pending(current) && timeout) {
44 rc = sk_wait_event(sk, &timeout,
45 !smc_cdc_tx_has_pending(&smc->conn),
50 remove_wait_queue(sk_sleep(sk), &wait);
53 /* wait for sndbuf data being transmitted */
54 static void smc_close_stream_wait(struct smc_sock *smc, long timeout)
56 DEFINE_WAIT_FUNC(wait, woken_wake_function);
57 struct sock *sk = &smc->sk;
62 if (!smc_tx_prepared_sends(&smc->conn))
65 smc->wait_close_tx_prepared = 1;
66 add_wait_queue(sk_sleep(sk), &wait);
67 while (!signal_pending(current) && timeout) {
70 rc = sk_wait_event(sk, &timeout,
71 !smc_tx_prepared_sends(&smc->conn) ||
72 (sk->sk_err == ECONNABORTED) ||
73 (sk->sk_err == ECONNRESET),
78 remove_wait_queue(sk_sleep(sk), &wait);
79 smc->wait_close_tx_prepared = 0;
82 void smc_close_wake_tx_prepared(struct smc_sock *smc)
84 if (smc->wait_close_tx_prepared)
85 /* wake up socket closing */
86 smc->sk.sk_state_change(&smc->sk);
89 static int smc_close_wr(struct smc_connection *conn)
91 conn->local_tx_ctrl.conn_state_flags.peer_done_writing = 1;
93 return smc_cdc_get_slot_and_msg_send(conn);
96 static int smc_close_final(struct smc_connection *conn)
98 if (atomic_read(&conn->bytes_to_rcv))
99 conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
101 conn->local_tx_ctrl.conn_state_flags.peer_conn_closed = 1;
103 return smc_cdc_get_slot_and_msg_send(conn);
106 static int smc_close_abort(struct smc_connection *conn)
108 conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1;
110 return smc_cdc_get_slot_and_msg_send(conn);
113 /* terminate smc socket abnormally - active abort
114 * RDMA communication no longer possible
116 void smc_close_active_abort(struct smc_sock *smc)
118 struct smc_cdc_conn_state_flags *txflags =
119 &smc->conn.local_tx_ctrl.conn_state_flags;
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);
126 switch (smc->sk.sk_state) {
129 smc->sk.sk_state = SMC_PEERABORTWAIT;
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;
138 smc->sk.sk_state = SMC_CLOSED;
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);
147 smc->sk.sk_state = SMC_CLOSED;
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);
156 smc->sk.sk_state = SMC_CLOSED;
158 case SMC_PEERFINCLOSEWAIT:
159 case SMC_PEERABORTWAIT:
164 sock_set_flag(&smc->sk, SOCK_DEAD);
165 smc->sk.sk_state_change(&smc->sk);
168 static inline bool smc_close_sent_any_close(struct smc_connection *conn)
170 return conn->local_tx_ctrl.conn_state_flags.peer_conn_abort ||
171 conn->local_tx_ctrl.conn_state_flags.peer_conn_closed;
174 int smc_close_active(struct smc_sock *smc)
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;
185 timeout = current->flags & PF_EXITING ?
186 0 : sock_flag(sk, SOCK_LINGER) ?
187 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
190 old_state = sk->sk_state;
193 sk->sk_state = SMC_CLOSED;
194 if (smc->smc_listen_work.func)
195 cancel_work_sync(&smc->smc_listen_work);
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);
206 smc_close_cleanup_listen(sk);
207 cancel_work_sync(&smc->smc_listen_work);
211 smc_close_stream_wait(smc, timeout);
213 cancel_delayed_work_sync(&conn->tx_work);
215 if (sk->sk_state == SMC_ACTIVE) {
216 /* send close request */
217 rc = smc_close_final(conn);
218 sk->sk_state = SMC_PEERCLOSEWAIT1;
220 /* actively shutdown clcsock before peer close it,
221 * prevent peer from entering TIME_WAIT state.
223 if (smc->clcsock && smc->clcsock->sk) {
224 rc1 = kernel_sock_shutdown(smc->clcsock,
229 /* peer event has changed the state */
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);
240 sk->sk_state = SMC_CLOSED;
241 smc_close_wait_tx_pends(smc);
243 case SMC_APPCLOSEWAIT1:
244 case SMC_APPCLOSEWAIT2:
245 if (!smc_cdc_rxed_any_close(conn))
246 smc_close_stream_wait(smc, timeout);
248 cancel_delayed_work_sync(&conn->tx_work);
250 if (sk->sk_err != ECONNABORTED) {
251 /* confirm close from peer */
252 rc = smc_close_final(conn);
256 if (smc_cdc_rxed_any_close(conn))
257 /* peer has closed the socket already */
258 sk->sk_state = SMC_CLOSED;
260 /* peer has just issued a shutdown write */
261 sk->sk_state = SMC_PEERFINCLOSEWAIT;
262 smc_close_wait_tx_pends(smc);
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);
271 /* peer sending PeerConnectionClosed will cause transition */
273 case SMC_PEERFINCLOSEWAIT:
274 /* peer sending PeerConnectionClosed will cause transition */
276 case SMC_PROCESSABORT:
278 cancel_delayed_work_sync(&conn->tx_work);
280 smc_close_abort(conn);
281 sk->sk_state = SMC_CLOSED;
282 smc_close_wait_tx_pends(smc);
284 case SMC_PEERABORTWAIT:
286 /* nothing to do, add tracing in future patch */
290 if (old_state != sk->sk_state)
291 sk->sk_state_change(&smc->sk);
295 static void smc_close_passive_abort_received(struct smc_sock *smc)
297 struct smc_cdc_conn_state_flags *txflags =
298 &smc->conn.local_tx_ctrl.conn_state_flags;
299 struct sock *sk = &smc->sk;
301 switch (sk->sk_state) {
303 case SMC_APPFINCLOSEWAIT:
304 case SMC_APPCLOSEWAIT1:
305 case SMC_APPCLOSEWAIT2:
306 smc_close_abort(&smc->conn);
307 sk->sk_state = SMC_PROCESSABORT;
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;
317 sk->sk_state = SMC_CLOSED;
320 case SMC_PEERFINCLOSEWAIT:
321 case SMC_PEERABORTWAIT:
322 sk->sk_state = SMC_CLOSED;
325 case SMC_PROCESSABORT:
326 /* nothing to do, add tracing in future patch */
331 /* Some kind of closing has been received: peer_conn_closed, peer_conn_abort,
332 * or peer_done_writing.
334 static void smc_close_passive_work(struct work_struct *work)
336 struct smc_connection *conn = container_of(work,
337 struct smc_connection,
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;
345 old_state = sk->sk_state;
347 if (!conn->alert_token_local) {
348 /* abnormal termination */
349 smc_close_active_abort(smc);
353 rxflags = &smc->conn.local_rx_ctrl.conn_state_flags;
354 if (rxflags->peer_conn_abort) {
355 smc_close_passive_abort_received(smc);
359 switch (sk->sk_state) {
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;
366 sk->sk_state = SMC_CLOSED;
369 sk->sk_state = SMC_APPCLOSEWAIT1;
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))
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;
384 /* just shutdown, but not yet closed locally */
385 sk->sk_state = SMC_APPFINCLOSEWAIT;
388 case SMC_APPCLOSEWAIT1:
389 case SMC_APPCLOSEWAIT2:
390 case SMC_APPFINCLOSEWAIT:
391 case SMC_PEERABORTWAIT:
392 case SMC_PROCESSABORT:
394 /* nothing to do, add tracing in future patch */
399 sk->sk_data_ready(sk); /* wakeup blocked rcvbuf consumers */
400 sk->sk_write_space(sk); /* wakeup blocked sndbuf producers */
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);
411 release_sock(&smc->sk);
414 void smc_close_sock_put_work(struct work_struct *work)
416 struct smc_sock *smc = container_of(to_delayed_work(work),
420 smc->sk.sk_prot->unhash(&smc->sk);
424 int smc_close_shutdown_write(struct smc_sock *smc)
426 struct smc_connection *conn = &smc->conn;
427 struct sock *sk = &smc->sk;
432 timeout = current->flags & PF_EXITING ?
433 0 : sock_flag(sk, SOCK_LINGER) ?
434 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
437 old_state = sk->sk_state;
440 smc_close_stream_wait(smc, timeout);
442 cancel_delayed_work_sync(&conn->tx_work);
444 /* send close wr request */
445 rc = smc_close_wr(conn);
446 if (sk->sk_state == SMC_ACTIVE)
447 sk->sk_state = SMC_PEERCLOSEWAIT1;
451 case SMC_APPCLOSEWAIT1:
453 if (!smc_cdc_rxed_any_close(conn))
454 smc_close_stream_wait(smc, timeout);
456 cancel_delayed_work_sync(&conn->tx_work);
458 /* confirm close from peer */
459 rc = smc_close_wr(conn);
460 sk->sk_state = SMC_APPCLOSEWAIT2;
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 */
473 if (old_state != sk->sk_state)
474 sk->sk_state_change(&smc->sk);
478 /* Initialize close properties on connection establishment. */
479 void smc_close_init(struct smc_sock *smc)
481 INIT_WORK(&smc->conn.close_work, smc_close_passive_work);