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;
184 timeout = current->flags & PF_EXITING ?
185 0 : sock_flag(sk, SOCK_LINGER) ?
186 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
189 old_state = sk->sk_state;
192 sk->sk_state = SMC_CLOSED;
193 if (smc->smc_listen_work.func)
194 cancel_work_sync(&smc->smc_listen_work);
197 sk->sk_state = SMC_CLOSED;
198 sk->sk_state_change(sk); /* wake up accept */
199 if (smc->clcsock && smc->clcsock->sk) {
200 rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR);
201 /* wake up kernel_accept of smc_tcp_listen_worker */
202 smc->clcsock->sk->sk_data_ready(smc->clcsock->sk);
205 smc_close_cleanup_listen(sk);
206 cancel_work_sync(&smc->smc_listen_work);
210 smc_close_stream_wait(smc, timeout);
212 cancel_delayed_work_sync(&conn->tx_work);
214 if (sk->sk_state == SMC_ACTIVE) {
215 /* send close request */
216 rc = smc_close_final(conn);
217 sk->sk_state = SMC_PEERCLOSEWAIT1;
219 /* peer event has changed the state */
223 case SMC_APPFINCLOSEWAIT:
224 /* socket already shutdown wr or both (active close) */
225 if (txflags->peer_done_writing &&
226 !smc_close_sent_any_close(conn)) {
227 /* just shutdown wr done, send close request */
228 rc = smc_close_final(conn);
230 sk->sk_state = SMC_CLOSED;
231 smc_close_wait_tx_pends(smc);
233 case SMC_APPCLOSEWAIT1:
234 case SMC_APPCLOSEWAIT2:
235 if (!smc_cdc_rxed_any_close(conn))
236 smc_close_stream_wait(smc, timeout);
238 cancel_delayed_work_sync(&conn->tx_work);
240 if (sk->sk_err != ECONNABORTED) {
241 /* confirm close from peer */
242 rc = smc_close_final(conn);
246 if (smc_cdc_rxed_any_close(conn))
247 /* peer has closed the socket already */
248 sk->sk_state = SMC_CLOSED;
250 /* peer has just issued a shutdown write */
251 sk->sk_state = SMC_PEERFINCLOSEWAIT;
252 smc_close_wait_tx_pends(smc);
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);
261 /* peer sending PeerConnectionClosed will cause transition */
263 case SMC_PEERFINCLOSEWAIT:
264 /* peer sending PeerConnectionClosed will cause transition */
266 case SMC_PROCESSABORT:
268 cancel_delayed_work_sync(&conn->tx_work);
270 smc_close_abort(conn);
271 sk->sk_state = SMC_CLOSED;
272 smc_close_wait_tx_pends(smc);
274 case SMC_PEERABORTWAIT:
276 /* nothing to do, add tracing in future patch */
280 if (old_state != sk->sk_state)
281 sk->sk_state_change(&smc->sk);
285 static void smc_close_passive_abort_received(struct smc_sock *smc)
287 struct smc_cdc_conn_state_flags *txflags =
288 &smc->conn.local_tx_ctrl.conn_state_flags;
289 struct sock *sk = &smc->sk;
291 switch (sk->sk_state) {
293 case SMC_APPFINCLOSEWAIT:
294 case SMC_APPCLOSEWAIT1:
295 case SMC_APPCLOSEWAIT2:
296 smc_close_abort(&smc->conn);
297 sk->sk_state = SMC_PROCESSABORT;
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 smc_close_abort(&smc->conn);
305 sk->sk_state = SMC_PROCESSABORT;
307 sk->sk_state = SMC_CLOSED;
310 case SMC_PEERFINCLOSEWAIT:
311 case SMC_PEERABORTWAIT:
312 sk->sk_state = SMC_CLOSED;
315 case SMC_PROCESSABORT:
316 /* nothing to do, add tracing in future patch */
321 /* Some kind of closing has been received: peer_conn_closed, peer_conn_abort,
322 * or peer_done_writing.
324 static void smc_close_passive_work(struct work_struct *work)
326 struct smc_connection *conn = container_of(work,
327 struct smc_connection,
329 struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
330 struct smc_cdc_conn_state_flags *rxflags;
331 struct sock *sk = &smc->sk;
335 old_state = sk->sk_state;
337 if (!conn->alert_token_local) {
338 /* abnormal termination */
339 smc_close_active_abort(smc);
343 rxflags = &smc->conn.local_rx_ctrl.conn_state_flags;
344 if (rxflags->peer_conn_abort) {
345 smc_close_passive_abort_received(smc);
349 switch (sk->sk_state) {
351 if (atomic_read(&smc->conn.bytes_to_rcv) ||
352 (rxflags->peer_done_writing &&
353 !smc_cdc_rxed_any_close(conn)))
354 sk->sk_state = SMC_APPCLOSEWAIT1;
356 sk->sk_state = SMC_CLOSED;
359 sk->sk_state = SMC_APPCLOSEWAIT1;
361 case SMC_PEERCLOSEWAIT1:
362 if (rxflags->peer_done_writing)
363 sk->sk_state = SMC_PEERCLOSEWAIT2;
365 /* to check for closing */
366 case SMC_PEERCLOSEWAIT2:
367 case SMC_PEERFINCLOSEWAIT:
368 if (!smc_cdc_rxed_any_close(&smc->conn))
370 if (sock_flag(sk, SOCK_DEAD) &&
371 smc_close_sent_any_close(conn)) {
372 /* smc_release has already been called locally */
373 sk->sk_state = SMC_CLOSED;
375 /* just shutdown, but not yet closed locally */
376 sk->sk_state = SMC_APPFINCLOSEWAIT;
379 case SMC_APPCLOSEWAIT1:
380 case SMC_APPCLOSEWAIT2:
381 case SMC_APPFINCLOSEWAIT:
382 case SMC_PEERABORTWAIT:
383 case SMC_PROCESSABORT:
385 /* nothing to do, add tracing in future patch */
390 sk->sk_data_ready(sk); /* wakeup blocked rcvbuf consumers */
391 sk->sk_write_space(sk); /* wakeup blocked sndbuf producers */
393 if (old_state != sk->sk_state) {
394 sk->sk_state_change(sk);
395 if ((sk->sk_state == SMC_CLOSED) &&
396 (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket)) {
397 smc_conn_free(&smc->conn);
398 schedule_delayed_work(&smc->sock_put_work,
399 SMC_CLOSE_SOCK_PUT_DELAY);
402 release_sock(&smc->sk);
405 void smc_close_sock_put_work(struct work_struct *work)
407 struct smc_sock *smc = container_of(to_delayed_work(work),
411 smc->sk.sk_prot->unhash(&smc->sk);
415 int smc_close_shutdown_write(struct smc_sock *smc)
417 struct smc_connection *conn = &smc->conn;
418 struct sock *sk = &smc->sk;
423 timeout = current->flags & PF_EXITING ?
424 0 : sock_flag(sk, SOCK_LINGER) ?
425 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT;
428 old_state = sk->sk_state;
431 smc_close_stream_wait(smc, timeout);
433 cancel_delayed_work_sync(&conn->tx_work);
435 /* send close wr request */
436 rc = smc_close_wr(conn);
437 if (sk->sk_state == SMC_ACTIVE)
438 sk->sk_state = SMC_PEERCLOSEWAIT1;
442 case SMC_APPCLOSEWAIT1:
444 if (!smc_cdc_rxed_any_close(conn))
445 smc_close_stream_wait(smc, timeout);
447 cancel_delayed_work_sync(&conn->tx_work);
449 /* confirm close from peer */
450 rc = smc_close_wr(conn);
451 sk->sk_state = SMC_APPCLOSEWAIT2;
453 case SMC_APPCLOSEWAIT2:
454 case SMC_PEERFINCLOSEWAIT:
455 case SMC_PEERCLOSEWAIT1:
456 case SMC_PEERCLOSEWAIT2:
457 case SMC_APPFINCLOSEWAIT:
458 case SMC_PROCESSABORT:
459 case SMC_PEERABORTWAIT:
460 /* nothing to do, add tracing in future patch */
464 if (old_state != sk->sk_state)
465 sk->sk_state_change(&smc->sk);
469 /* Initialize close properties on connection establishment. */
470 void smc_close_init(struct smc_sock *smc)
472 INIT_WORK(&smc->conn.close_work, smc_close_passive_work);