blob: 4bf4befe5066a0084a7430cc39f9fd0c08a9a20e [file] [log] [blame]
Andy Grover70041082009-08-21 12:28:31 +00001/*
2 * Copyright (c) 2006 Oracle. All rights reserved.
3 *
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:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
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.
22 *
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
30 * SOFTWARE.
31 *
32 */
33#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/gfp.h>
Andy Grover70041082009-08-21 12:28:31 +000035#include <linux/in.h>
36#include <net/tcp.h>
37
38#include "rds.h"
39#include "tcp.h"
40
Sowmini Varadhan467fa152015-08-05 01:43:26 -040041int rds_tcp_keepalive(struct socket *sock)
Sowmini Varadhanf711a6a2015-05-05 15:20:51 -040042{
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 */
46 int keepalive = 1;
47 int ret = 0;
48
49 ret = kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE,
50 (char *)&keepalive, sizeof(keepalive));
51 if (ret < 0)
52 goto bail;
53
54 ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT,
55 (char *)&keepcnt, sizeof(keepcnt));
56 if (ret < 0)
57 goto bail;
58
59 ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE,
60 (char *)&keepidle, sizeof(keepidle));
61 if (ret < 0)
62 goto bail;
63
64 /* KEEPINTVL is the interval between successive probes. We follow
65 * the model in xs_tcp_finish_connecting() and re-use keepidle.
66 */
67 ret = kernel_setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL,
68 (char *)&keepidle, sizeof(keepidle));
69bail:
70 return ret;
71}
72
Sowmini Varadhan467fa152015-08-05 01:43:26 -040073int rds_tcp_accept_one(struct socket *sock)
Andy Grover70041082009-08-21 12:28:31 +000074{
75 struct socket *new_sock = NULL;
76 struct rds_connection *conn;
77 int ret;
78 struct inet_sock *inet;
Sowmini Varadhanbd7c5f92016-05-02 11:24:52 -070079 struct rds_tcp_connection *rs_tcp = NULL;
80 int conn_state;
81 struct sock *nsk;
Andy Grover70041082009-08-21 12:28:31 +000082
Sowmini Varadhan37e14f42016-05-18 10:06:23 -070083 if (!sock) /* module unload or netns delete in progress */
84 return -ENETUNREACH;
85
Sowmini Varadhand5a8ac22015-08-05 01:43:25 -040086 ret = sock_create_kern(sock_net(sock->sk), sock->sk->sk_family,
87 sock->sk->sk_type, sock->sk->sk_protocol,
88 &new_sock);
Andy Grover70041082009-08-21 12:28:31 +000089 if (ret)
90 goto out;
91
92 new_sock->type = sock->type;
93 new_sock->ops = sock->ops;
94 ret = sock->ops->accept(sock, new_sock, O_NONBLOCK);
95 if (ret < 0)
96 goto out;
97
Sowmini Varadhanf711a6a2015-05-05 15:20:51 -040098 ret = rds_tcp_keepalive(new_sock);
99 if (ret < 0)
100 goto out;
101
Andy Grover70041082009-08-21 12:28:31 +0000102 rds_tcp_tune(new_sock);
103
104 inet = inet_sk(new_sock->sk);
105
Joe Perches6884b342010-02-02 12:43:59 +0000106 rdsdebug("accepted tcp %pI4:%u -> %pI4:%u\n",
107 &inet->inet_saddr, ntohs(inet->inet_sport),
108 &inet->inet_daddr, ntohs(inet->inet_dport));
Andy Grover70041082009-08-21 12:28:31 +0000109
Sowmini Varadhand5a8ac22015-08-05 01:43:25 -0400110 conn = rds_conn_create(sock_net(sock->sk),
111 inet->inet_saddr, inet->inet_daddr,
Eric Dumazetc720c7e82009-10-15 06:30:45 +0000112 &rds_tcp_transport, GFP_KERNEL);
Andy Grover70041082009-08-21 12:28:31 +0000113 if (IS_ERR(conn)) {
114 ret = PTR_ERR(conn);
115 goto out;
116 }
Sowmini Varadhanf711a6a2015-05-05 15:20:51 -0400117 /* An incoming SYN request came in, and TCP just accepted it.
Sowmini Varadhanf711a6a2015-05-05 15:20:51 -0400118 *
119 * If the client reboots, this conn will need to be cleaned up.
120 * rds_tcp_state_change() will do that cleanup
121 */
122 rs_tcp = (struct rds_tcp_connection *)conn->c_transport_data;
Sowmini Varadhan3b20fc32015-09-30 16:54:07 -0400123 rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING);
Sowmini Varadhanbd7c5f92016-05-02 11:24:52 -0700124 mutex_lock(&rs_tcp->t_conn_lock);
125 conn_state = rds_conn_state(conn);
126 if (conn_state != RDS_CONN_CONNECTING && conn_state != RDS_CONN_UP)
127 goto rst_nsk;
Sowmini Varadhaneb192842016-05-02 11:24:51 -0700128 if (rs_tcp->t_sock) {
129 /* Need to resolve a duelling SYN between peers.
130 * We have an outstanding SYN to this peer, which may
131 * potentially have transitioned to the RDS_CONN_UP state,
132 * so we must quiesce any send threads before resetting
133 * c_transport_data.
134 */
Sowmini Varadhanc948bb52016-05-18 10:06:24 -0700135 if (ntohl(inet->inet_saddr) < ntohl(inet->inet_daddr) ||
136 !conn->c_outgoing) {
Sowmini Varadhanbd7c5f92016-05-02 11:24:52 -0700137 goto rst_nsk;
Sowmini Varadhanc948bb52016-05-18 10:06:24 -0700138 } else {
139 atomic_set(&conn->c_state, RDS_CONN_CONNECTING);
140 wait_event(conn->c_waitq,
141 !test_bit(RDS_IN_XMIT, &conn->c_flags));
Sowmini Varadhaneb192842016-05-02 11:24:51 -0700142 rds_tcp_restore_callbacks(rs_tcp->t_sock, rs_tcp);
143 conn->c_outgoing = 0;
144 }
145 }
Andy Grover70041082009-08-21 12:28:31 +0000146 rds_tcp_set_callbacks(new_sock, conn);
Sowmini Varadhaneb192842016-05-02 11:24:51 -0700147 rds_connect_complete(conn); /* marks RDS_CONN_UP */
Andy Grover70041082009-08-21 12:28:31 +0000148 new_sock = NULL;
149 ret = 0;
Sowmini Varadhanbd7c5f92016-05-02 11:24:52 -0700150 goto out;
151rst_nsk:
152 /* reset the newly returned accept sock and bail */
153 nsk = new_sock->sk;
154 rds_tcp_stats_inc(s_tcp_listen_closed_stale);
155 nsk->sk_user_data = NULL;
156 nsk->sk_prot->disconnect(nsk, 0);
157 tcp_done(nsk);
158 new_sock = NULL;
159 ret = 0;
Andy Grover70041082009-08-21 12:28:31 +0000160out:
Sowmini Varadhanbd7c5f92016-05-02 11:24:52 -0700161 if (rs_tcp)
162 mutex_unlock(&rs_tcp->t_conn_lock);
Andy Grover70041082009-08-21 12:28:31 +0000163 if (new_sock)
164 sock_release(new_sock);
165 return ret;
166}
167
David S. Miller676d2362014-04-11 16:15:36 -0400168void rds_tcp_listen_data_ready(struct sock *sk)
Andy Grover70041082009-08-21 12:28:31 +0000169{
David S. Miller676d2362014-04-11 16:15:36 -0400170 void (*ready)(struct sock *sk);
Andy Grover70041082009-08-21 12:28:31 +0000171
172 rdsdebug("listen data ready sk %p\n", sk);
173
Eric Dumazet38036622016-05-17 17:44:08 -0700174 read_lock_bh(&sk->sk_callback_lock);
Andy Grover70041082009-08-21 12:28:31 +0000175 ready = sk->sk_user_data;
Andy Grover8690bfa2010-01-12 11:56:44 -0800176 if (!ready) { /* check for teardown race */
Andy Grover70041082009-08-21 12:28:31 +0000177 ready = sk->sk_data_ready;
178 goto out;
179 }
180
181 /*
182 * ->sk_data_ready is also called for a newly established child socket
183 * before it has been accepted and the accepter has set up their
184 * data_ready.. we only want to queue listen work for our listening
185 * socket
186 */
187 if (sk->sk_state == TCP_LISTEN)
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400188 rds_tcp_accept_work(sk);
Andy Grover70041082009-08-21 12:28:31 +0000189
190out:
Eric Dumazet38036622016-05-17 17:44:08 -0700191 read_unlock_bh(&sk->sk_callback_lock);
David S. Miller676d2362014-04-11 16:15:36 -0400192 ready(sk);
Andy Grover70041082009-08-21 12:28:31 +0000193}
194
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400195struct socket *rds_tcp_listen_init(struct net *net)
Andy Grover70041082009-08-21 12:28:31 +0000196{
197 struct sockaddr_in sin;
198 struct socket *sock = NULL;
199 int ret;
200
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400201 ret = sock_create_kern(net, PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
Andy Grover70041082009-08-21 12:28:31 +0000202 if (ret < 0)
203 goto out;
204
Pavel Emelyanov4a17fd52012-04-19 03:39:36 +0000205 sock->sk->sk_reuse = SK_CAN_REUSE;
Andy Grover70041082009-08-21 12:28:31 +0000206 rds_tcp_nonagle(sock);
207
208 write_lock_bh(&sock->sk->sk_callback_lock);
209 sock->sk->sk_user_data = sock->sk->sk_data_ready;
210 sock->sk->sk_data_ready = rds_tcp_listen_data_ready;
211 write_unlock_bh(&sock->sk->sk_callback_lock);
212
Himangi Saraogi01728372014-05-30 21:17:13 +0530213 sin.sin_family = PF_INET;
Andy Grover70041082009-08-21 12:28:31 +0000214 sin.sin_addr.s_addr = (__force u32)htonl(INADDR_ANY);
215 sin.sin_port = (__force u16)htons(RDS_TCP_PORT);
216
217 ret = sock->ops->bind(sock, (struct sockaddr *)&sin, sizeof(sin));
218 if (ret < 0)
219 goto out;
220
221 ret = sock->ops->listen(sock, 64);
222 if (ret < 0)
223 goto out;
224
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400225 return sock;
Andy Grover70041082009-08-21 12:28:31 +0000226out:
227 if (sock)
228 sock_release(sock);
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400229 return NULL;
Andy Grover70041082009-08-21 12:28:31 +0000230}
231
Sowmini Varadhan467fa152015-08-05 01:43:26 -0400232void rds_tcp_listen_stop(struct socket *sock)
Andy Grover70041082009-08-21 12:28:31 +0000233{
Andy Grover70041082009-08-21 12:28:31 +0000234 struct sock *sk;
235
Andy Grover8690bfa2010-01-12 11:56:44 -0800236 if (!sock)
Andy Grover70041082009-08-21 12:28:31 +0000237 return;
238
239 sk = sock->sk;
240
241 /* serialize with and prevent further callbacks */
242 lock_sock(sk);
243 write_lock_bh(&sk->sk_callback_lock);
244 if (sk->sk_user_data) {
245 sk->sk_data_ready = sk->sk_user_data;
246 sk->sk_user_data = NULL;
247 }
248 write_unlock_bh(&sk->sk_callback_lock);
249 release_sock(sk);
250
251 /* wait for accepts to stop and close the socket */
252 flush_workqueue(rds_wq);
253 sock_release(sock);
Andy Grover70041082009-08-21 12:28:31 +0000254}