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>
42 * cheesy, but simple..
44 static void rds_tcp_accept_worker(struct work_struct
*work
);
45 static DECLARE_WORK(rds_tcp_listen_work
, rds_tcp_accept_worker
);
46 static struct socket
*rds_tcp_listen_sock
;
48 static int rds_tcp_keepalive(struct socket
*sock
)
50 /* values below based on xs_udp_default_timeout */
51 int keepidle
= 5; /* send a probe 'keepidle' secs after last data */
52 int keepcnt
= 5; /* number of unack'ed probes before declaring dead */
56 ret
= kernel_setsockopt(sock
, SOL_SOCKET
, SO_KEEPALIVE
,
57 (char *)&keepalive
, sizeof(keepalive
));
61 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPCNT
,
62 (char *)&keepcnt
, sizeof(keepcnt
));
66 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPIDLE
,
67 (char *)&keepidle
, sizeof(keepidle
));
71 /* KEEPINTVL is the interval between successive probes. We follow
72 * the model in xs_tcp_finish_connecting() and re-use keepidle.
74 ret
= kernel_setsockopt(sock
, IPPROTO_TCP
, TCP_KEEPINTVL
,
75 (char *)&keepidle
, sizeof(keepidle
));
80 static int rds_tcp_accept_one(struct socket
*sock
)
82 struct socket
*new_sock
= NULL
;
83 struct rds_connection
*conn
;
85 struct inet_sock
*inet
;
86 struct rds_tcp_connection
*rs_tcp
;
88 ret
= sock_create_kern(sock_net(sock
->sk
), sock
->sk
->sk_family
,
89 sock
->sk
->sk_type
, sock
->sk
->sk_protocol
,
94 new_sock
->type
= sock
->type
;
95 new_sock
->ops
= sock
->ops
;
96 ret
= sock
->ops
->accept(sock
, new_sock
, O_NONBLOCK
);
100 ret
= rds_tcp_keepalive(new_sock
);
104 rds_tcp_tune(new_sock
);
106 inet
= inet_sk(new_sock
->sk
);
108 rdsdebug("accepted tcp %pI4:%u -> %pI4:%u\n",
109 &inet
->inet_saddr
, ntohs(inet
->inet_sport
),
110 &inet
->inet_daddr
, ntohs(inet
->inet_dport
));
112 conn
= rds_conn_create(sock_net(sock
->sk
),
113 inet
->inet_saddr
, inet
->inet_daddr
,
114 &rds_tcp_transport
, GFP_KERNEL
);
119 /* An incoming SYN request came in, and TCP just accepted it.
120 * We always create a new conn for listen side of TCP, and do not
121 * add it to the c_hash_list.
123 * If the client reboots, this conn will need to be cleaned up.
124 * rds_tcp_state_change() will do that cleanup
126 rs_tcp
= (struct rds_tcp_connection
*)conn
->c_transport_data
;
127 WARN_ON(!rs_tcp
|| rs_tcp
->t_sock
);
130 * see the comment above rds_queue_delayed_reconnect()
132 if (!rds_conn_transition(conn
, RDS_CONN_DOWN
, RDS_CONN_CONNECTING
)) {
133 if (rds_conn_state(conn
) == RDS_CONN_UP
)
134 rds_tcp_stats_inc(s_tcp_listen_closed_stale
);
136 rds_tcp_stats_inc(s_tcp_connect_raced
);
142 rds_tcp_set_callbacks(new_sock
, conn
);
143 rds_connect_complete(conn
);
149 sock_release(new_sock
);
153 static void rds_tcp_accept_worker(struct work_struct
*work
)
155 while (rds_tcp_accept_one(rds_tcp_listen_sock
) == 0)
159 void rds_tcp_listen_data_ready(struct sock
*sk
)
161 void (*ready
)(struct sock
*sk
);
163 rdsdebug("listen data ready sk %p\n", sk
);
165 read_lock(&sk
->sk_callback_lock
);
166 ready
= sk
->sk_user_data
;
167 if (!ready
) { /* check for teardown race */
168 ready
= sk
->sk_data_ready
;
173 * ->sk_data_ready is also called for a newly established child socket
174 * before it has been accepted and the accepter has set up their
175 * data_ready.. we only want to queue listen work for our listening
178 if (sk
->sk_state
== TCP_LISTEN
)
179 queue_work(rds_wq
, &rds_tcp_listen_work
);
182 read_unlock(&sk
->sk_callback_lock
);
186 int rds_tcp_listen_init(void)
188 struct sockaddr_in sin
;
189 struct socket
*sock
= NULL
;
192 /* MUST call sock_create_kern directly so that we avoid get_net()
193 * in sk_alloc(). Doing a get_net() will result in cleanup_net()
194 * never getting invoked, which will leave sock and other things
197 ret
= sock_create_kern(current
->nsproxy
->net_ns
, PF_INET
,
198 SOCK_STREAM
, IPPROTO_TCP
, &sock
);
202 sock
->sk
->sk_reuse
= SK_CAN_REUSE
;
203 rds_tcp_nonagle(sock
);
205 write_lock_bh(&sock
->sk
->sk_callback_lock
);
206 sock
->sk
->sk_user_data
= sock
->sk
->sk_data_ready
;
207 sock
->sk
->sk_data_ready
= rds_tcp_listen_data_ready
;
208 write_unlock_bh(&sock
->sk
->sk_callback_lock
);
210 sin
.sin_family
= PF_INET
;
211 sin
.sin_addr
.s_addr
= (__force u32
)htonl(INADDR_ANY
);
212 sin
.sin_port
= (__force u16
)htons(RDS_TCP_PORT
);
214 ret
= sock
->ops
->bind(sock
, (struct sockaddr
*)&sin
, sizeof(sin
));
218 ret
= sock
->ops
->listen(sock
, 64);
222 rds_tcp_listen_sock
= sock
;
230 void rds_tcp_listen_stop(void)
232 struct socket
*sock
= rds_tcp_listen_sock
;
240 /* serialize with and prevent further callbacks */
242 write_lock_bh(&sk
->sk_callback_lock
);
243 if (sk
->sk_user_data
) {
244 sk
->sk_data_ready
= sk
->sk_user_data
;
245 sk
->sk_user_data
= NULL
;
247 write_unlock_bh(&sk
->sk_callback_lock
);
250 /* wait for accepts to stop and close the socket */
251 flush_workqueue(rds_wq
);
253 rds_tcp_listen_sock
= NULL
;