2 * Copyright (c) 2006 Oracle. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 #include <linux/kernel.h>
34 #include <linux/gfp.h>
41 int rds_tcp_keepalive(struct socket
*sock
)
43 /* values below based on xs_udp_default_timeout */
44 int keepidle
= 5; /* send a probe 'keepidle' secs after last data */
45 int keepcnt
= 5; /* number of unack'ed probes before declaring dead */
49 ret
= kernel_setsockopt(sock
, SOL_SOCKET
, SO_KEEPALIVE
,
50 (char *)&keepalive
, sizeof(keepalive
));
54 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPCNT
,
55 (char *)&keepcnt
, sizeof(keepcnt
));
59 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPIDLE
,
60 (char *)&keepidle
, sizeof(keepidle
));
64 /* KEEPINTVL is the interval between successive probes. We follow
65 * the model in xs_tcp_finish_connecting() and re-use keepidle.
67 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPINTVL
,
68 (char *)&keepidle
, sizeof(keepidle
));
73 int rds_tcp_accept_one(struct socket
*sock
)
75 struct socket
*new_sock
= NULL
;
76 struct rds_connection
*conn
;
78 struct inet_sock
*inet
;
79 struct rds_tcp_connection
*rs_tcp
= NULL
;
82 if (!sock
) /* module unload or netns delete in progress */
85 ret
= sock_create_kern(sock_net(sock
->sk
), sock
->sk
->sk_family
,
86 sock
->sk
->sk_type
, sock
->sk
->sk_protocol
,
91 new_sock
->type
= sock
->type
;
92 new_sock
->ops
= sock
->ops
;
93 ret
= sock
->ops
->accept(sock
, new_sock
, O_NONBLOCK
);
97 ret
= rds_tcp_keepalive(new_sock
);
101 rds_tcp_tune(new_sock
);
103 inet
= inet_sk(new_sock
->sk
);
105 rdsdebug("accepted tcp %pI4:%u -> %pI4:%u\n",
106 &inet
->inet_saddr
, ntohs(inet
->inet_sport
),
107 &inet
->inet_daddr
, ntohs(inet
->inet_dport
));
109 conn
= rds_conn_create(sock_net(sock
->sk
),
110 inet
->inet_saddr
, inet
->inet_daddr
,
111 &rds_tcp_transport
, GFP_KERNEL
);
116 /* An incoming SYN request came in, and TCP just accepted it.
118 * If the client reboots, this conn will need to be cleaned up.
119 * rds_tcp_state_change() will do that cleanup
121 rs_tcp
= (struct rds_tcp_connection
*)conn
->c_transport_data
;
122 rds_conn_transition(conn
, RDS_CONN_DOWN
, RDS_CONN_CONNECTING
);
123 mutex_lock(&rs_tcp
->t_conn_lock
);
124 conn_state
= rds_conn_state(conn
);
125 if (conn_state
!= RDS_CONN_CONNECTING
&& conn_state
!= RDS_CONN_UP
)
127 if (rs_tcp
->t_sock
) {
128 /* Need to resolve a duelling SYN between peers.
129 * We have an outstanding SYN to this peer, which may
130 * potentially have transitioned to the RDS_CONN_UP state,
131 * so we must quiesce any send threads before resetting
134 if (ntohl(inet
->inet_saddr
) < ntohl(inet
->inet_daddr
) ||
138 rds_tcp_reset_callbacks(new_sock
, conn
);
139 conn
->c_outgoing
= 0;
140 /* rds_connect_path_complete() marks RDS_CONN_UP */
141 rds_connect_path_complete(conn
, RDS_CONN_DISCONNECTING
);
144 rds_tcp_set_callbacks(new_sock
, conn
);
145 rds_connect_path_complete(conn
, RDS_CONN_CONNECTING
);
151 /* reset the newly returned accept sock and bail */
152 kernel_sock_shutdown(new_sock
, SHUT_RDWR
);
156 mutex_unlock(&rs_tcp
->t_conn_lock
);
158 sock_release(new_sock
);
162 void rds_tcp_listen_data_ready(struct sock
*sk
)
164 void (*ready
)(struct sock
*sk
);
166 rdsdebug("listen data ready sk %p\n", sk
);
168 read_lock_bh(&sk
->sk_callback_lock
);
169 ready
= sk
->sk_user_data
;
170 if (!ready
) { /* check for teardown race */
171 ready
= sk
->sk_data_ready
;
176 * ->sk_data_ready is also called for a newly established child socket
177 * before it has been accepted and the accepter has set up their
178 * data_ready.. we only want to queue listen work for our listening
181 if (sk
->sk_state
== TCP_LISTEN
)
182 rds_tcp_accept_work(sk
);
185 read_unlock_bh(&sk
->sk_callback_lock
);
189 struct socket
*rds_tcp_listen_init(struct net
*net
)
191 struct sockaddr_in sin
;
192 struct socket
*sock
= NULL
;
195 ret
= sock_create_kern(net
, PF_INET
, SOCK_STREAM
, IPPROTO_TCP
, &sock
);
199 sock
->sk
->sk_reuse
= SK_CAN_REUSE
;
200 rds_tcp_nonagle(sock
);
202 write_lock_bh(&sock
->sk
->sk_callback_lock
);
203 sock
->sk
->sk_user_data
= sock
->sk
->sk_data_ready
;
204 sock
->sk
->sk_data_ready
= rds_tcp_listen_data_ready
;
205 write_unlock_bh(&sock
->sk
->sk_callback_lock
);
207 sin
.sin_family
= PF_INET
;
208 sin
.sin_addr
.s_addr
= (__force u32
)htonl(INADDR_ANY
);
209 sin
.sin_port
= (__force u16
)htons(RDS_TCP_PORT
);
211 ret
= sock
->ops
->bind(sock
, (struct sockaddr
*)&sin
, sizeof(sin
));
215 ret
= sock
->ops
->listen(sock
, 64);
226 void rds_tcp_listen_stop(struct socket
*sock
)
235 /* serialize with and prevent further callbacks */
237 write_lock_bh(&sk
->sk_callback_lock
);
238 if (sk
->sk_user_data
) {
239 sk
->sk_data_ready
= sk
->sk_user_data
;
240 sk
->sk_user_data
= NULL
;
242 write_unlock_bh(&sk
->sk_callback_lock
);
245 /* wait for accepts to stop and close the socket */
246 flush_workqueue(rds_wq
);