~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/smc/smc_close.c

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /net/smc/smc_close.c (Version linux-6.11.5) and /net/smc/smc_close.c (Version linux-5.17.15)


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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php