1 | /* |
2 | * Copyright (c) 2006, 2018 Oracle and/or its affiliates. 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> |
34 | #include <linux/slab.h> |
35 | #include <linux/in.h> |
36 | #include <linux/module.h> |
37 | #include <net/tcp.h> |
38 | #include <net/net_namespace.h> |
39 | #include <net/netns/generic.h> |
40 | #include <net/addrconf.h> |
41 | |
42 | #include "rds.h" |
43 | #include "tcp.h" |
44 | |
45 | /* only for info exporting */ |
46 | static DEFINE_SPINLOCK(rds_tcp_tc_list_lock); |
47 | static LIST_HEAD(rds_tcp_tc_list); |
48 | |
49 | /* rds_tcp_tc_count counts only IPv4 connections. |
50 | * rds6_tcp_tc_count counts both IPv4 and IPv6 connections. |
51 | */ |
52 | static unsigned int rds_tcp_tc_count; |
53 | #if IS_ENABLED(CONFIG_IPV6) |
54 | static unsigned int rds6_tcp_tc_count; |
55 | #endif |
56 | |
57 | /* Track rds_tcp_connection structs so they can be cleaned up */ |
58 | static DEFINE_SPINLOCK(rds_tcp_conn_lock); |
59 | static LIST_HEAD(rds_tcp_conn_list); |
60 | static atomic_t rds_tcp_unloading = ATOMIC_INIT(0); |
61 | |
62 | static struct kmem_cache *rds_tcp_conn_slab; |
63 | |
64 | static int rds_tcp_skbuf_handler(struct ctl_table *ctl, int write, |
65 | void *buffer, size_t *lenp, loff_t *fpos); |
66 | |
67 | static int rds_tcp_min_sndbuf = SOCK_MIN_SNDBUF; |
68 | static int rds_tcp_min_rcvbuf = SOCK_MIN_RCVBUF; |
69 | |
70 | static struct ctl_table rds_tcp_sysctl_table[] = { |
71 | #define RDS_TCP_SNDBUF 0 |
72 | { |
73 | .procname = "rds_tcp_sndbuf" , |
74 | /* data is per-net pointer */ |
75 | .maxlen = sizeof(int), |
76 | .mode = 0644, |
77 | .proc_handler = rds_tcp_skbuf_handler, |
78 | .extra1 = &rds_tcp_min_sndbuf, |
79 | }, |
80 | #define RDS_TCP_RCVBUF 1 |
81 | { |
82 | .procname = "rds_tcp_rcvbuf" , |
83 | /* data is per-net pointer */ |
84 | .maxlen = sizeof(int), |
85 | .mode = 0644, |
86 | .proc_handler = rds_tcp_skbuf_handler, |
87 | .extra1 = &rds_tcp_min_rcvbuf, |
88 | }, |
89 | { } |
90 | }; |
91 | |
92 | u32 rds_tcp_write_seq(struct rds_tcp_connection *tc) |
93 | { |
94 | /* seq# of the last byte of data in tcp send buffer */ |
95 | return tcp_sk(tc->t_sock->sk)->write_seq; |
96 | } |
97 | |
98 | u32 rds_tcp_snd_una(struct rds_tcp_connection *tc) |
99 | { |
100 | return tcp_sk(tc->t_sock->sk)->snd_una; |
101 | } |
102 | |
103 | void rds_tcp_restore_callbacks(struct socket *sock, |
104 | struct rds_tcp_connection *tc) |
105 | { |
106 | rdsdebug("restoring sock %p callbacks from tc %p\n" , sock, tc); |
107 | write_lock_bh(&sock->sk->sk_callback_lock); |
108 | |
109 | /* done under the callback_lock to serialize with write_space */ |
110 | spin_lock(lock: &rds_tcp_tc_list_lock); |
111 | list_del_init(entry: &tc->t_list_item); |
112 | #if IS_ENABLED(CONFIG_IPV6) |
113 | rds6_tcp_tc_count--; |
114 | #endif |
115 | if (!tc->t_cpath->cp_conn->c_isv6) |
116 | rds_tcp_tc_count--; |
117 | spin_unlock(lock: &rds_tcp_tc_list_lock); |
118 | |
119 | tc->t_sock = NULL; |
120 | |
121 | sock->sk->sk_write_space = tc->t_orig_write_space; |
122 | sock->sk->sk_data_ready = tc->t_orig_data_ready; |
123 | sock->sk->sk_state_change = tc->t_orig_state_change; |
124 | sock->sk->sk_user_data = NULL; |
125 | |
126 | write_unlock_bh(&sock->sk->sk_callback_lock); |
127 | } |
128 | |
129 | /* |
130 | * rds_tcp_reset_callbacks() switches the to the new sock and |
131 | * returns the existing tc->t_sock. |
132 | * |
133 | * The only functions that set tc->t_sock are rds_tcp_set_callbacks |
134 | * and rds_tcp_reset_callbacks. Send and receive trust that |
135 | * it is set. The absence of RDS_CONN_UP bit protects those paths |
136 | * from being called while it isn't set. |
137 | */ |
138 | void rds_tcp_reset_callbacks(struct socket *sock, |
139 | struct rds_conn_path *cp) |
140 | { |
141 | struct rds_tcp_connection *tc = cp->cp_transport_data; |
142 | struct socket *osock = tc->t_sock; |
143 | |
144 | if (!osock) |
145 | goto newsock; |
146 | |
147 | /* Need to resolve a duelling SYN between peers. |
148 | * We have an outstanding SYN to this peer, which may |
149 | * potentially have transitioned to the RDS_CONN_UP state, |
150 | * so we must quiesce any send threads before resetting |
151 | * cp_transport_data. We quiesce these threads by setting |
152 | * cp_state to something other than RDS_CONN_UP, and then |
153 | * waiting for any existing threads in rds_send_xmit to |
154 | * complete release_in_xmit(). (Subsequent threads entering |
155 | * rds_send_xmit() will bail on !rds_conn_up(). |
156 | * |
157 | * However an incoming syn-ack at this point would end up |
158 | * marking the conn as RDS_CONN_UP, and would again permit |
159 | * rds_send_xmi() threads through, so ideally we would |
160 | * synchronize on RDS_CONN_UP after lock_sock(), but cannot |
161 | * do that: waiting on !RDS_IN_XMIT after lock_sock() may |
162 | * end up deadlocking with tcp_sendmsg(), and the RDS_IN_XMIT |
163 | * would not get set. As a result, we set c_state to |
164 | * RDS_CONN_RESETTTING, to ensure that rds_tcp_state_change |
165 | * cannot mark rds_conn_path_up() in the window before lock_sock() |
166 | */ |
167 | atomic_set(v: &cp->cp_state, i: RDS_CONN_RESETTING); |
168 | wait_event(cp->cp_waitq, !test_bit(RDS_IN_XMIT, &cp->cp_flags)); |
169 | /* reset receive side state for rds_tcp_data_recv() for osock */ |
170 | cancel_delayed_work_sync(dwork: &cp->cp_send_w); |
171 | cancel_delayed_work_sync(dwork: &cp->cp_recv_w); |
172 | lock_sock(sk: osock->sk); |
173 | if (tc->t_tinc) { |
174 | rds_inc_put(inc: &tc->t_tinc->ti_inc); |
175 | tc->t_tinc = NULL; |
176 | } |
177 | tc->t_tinc_hdr_rem = sizeof(struct rds_header); |
178 | tc->t_tinc_data_rem = 0; |
179 | rds_tcp_restore_callbacks(sock: osock, tc); |
180 | release_sock(sk: osock->sk); |
181 | sock_release(sock: osock); |
182 | newsock: |
183 | rds_send_path_reset(conn: cp); |
184 | lock_sock(sk: sock->sk); |
185 | rds_tcp_set_callbacks(sock, cp); |
186 | release_sock(sk: sock->sk); |
187 | } |
188 | |
189 | /* Add tc to rds_tcp_tc_list and set tc->t_sock. See comments |
190 | * above rds_tcp_reset_callbacks for notes about synchronization |
191 | * with data path |
192 | */ |
193 | void rds_tcp_set_callbacks(struct socket *sock, struct rds_conn_path *cp) |
194 | { |
195 | struct rds_tcp_connection *tc = cp->cp_transport_data; |
196 | |
197 | rdsdebug("setting sock %p callbacks to tc %p\n" , sock, tc); |
198 | write_lock_bh(&sock->sk->sk_callback_lock); |
199 | |
200 | /* done under the callback_lock to serialize with write_space */ |
201 | spin_lock(lock: &rds_tcp_tc_list_lock); |
202 | list_add_tail(new: &tc->t_list_item, head: &rds_tcp_tc_list); |
203 | #if IS_ENABLED(CONFIG_IPV6) |
204 | rds6_tcp_tc_count++; |
205 | #endif |
206 | if (!tc->t_cpath->cp_conn->c_isv6) |
207 | rds_tcp_tc_count++; |
208 | spin_unlock(lock: &rds_tcp_tc_list_lock); |
209 | |
210 | /* accepted sockets need our listen data ready undone */ |
211 | if (sock->sk->sk_data_ready == rds_tcp_listen_data_ready) |
212 | sock->sk->sk_data_ready = sock->sk->sk_user_data; |
213 | |
214 | tc->t_sock = sock; |
215 | tc->t_cpath = cp; |
216 | tc->t_orig_data_ready = sock->sk->sk_data_ready; |
217 | tc->t_orig_write_space = sock->sk->sk_write_space; |
218 | tc->t_orig_state_change = sock->sk->sk_state_change; |
219 | |
220 | sock->sk->sk_user_data = cp; |
221 | sock->sk->sk_data_ready = rds_tcp_data_ready; |
222 | sock->sk->sk_write_space = rds_tcp_write_space; |
223 | sock->sk->sk_state_change = rds_tcp_state_change; |
224 | |
225 | write_unlock_bh(&sock->sk->sk_callback_lock); |
226 | } |
227 | |
228 | /* Handle RDS_INFO_TCP_SOCKETS socket option. It only returns IPv4 |
229 | * connections for backward compatibility. |
230 | */ |
231 | static void rds_tcp_tc_info(struct socket *rds_sock, unsigned int len, |
232 | struct rds_info_iterator *iter, |
233 | struct rds_info_lengths *lens) |
234 | { |
235 | struct rds_info_tcp_socket tsinfo; |
236 | struct rds_tcp_connection *tc; |
237 | unsigned long flags; |
238 | |
239 | spin_lock_irqsave(&rds_tcp_tc_list_lock, flags); |
240 | |
241 | if (len / sizeof(tsinfo) < rds_tcp_tc_count) |
242 | goto out; |
243 | |
244 | list_for_each_entry(tc, &rds_tcp_tc_list, t_list_item) { |
245 | struct inet_sock *inet = inet_sk(tc->t_sock->sk); |
246 | |
247 | if (tc->t_cpath->cp_conn->c_isv6) |
248 | continue; |
249 | |
250 | tsinfo.local_addr = inet->inet_saddr; |
251 | tsinfo.local_port = inet->inet_sport; |
252 | tsinfo.peer_addr = inet->inet_daddr; |
253 | tsinfo.peer_port = inet->inet_dport; |
254 | |
255 | tsinfo.hdr_rem = tc->t_tinc_hdr_rem; |
256 | tsinfo.data_rem = tc->t_tinc_data_rem; |
257 | tsinfo.last_sent_nxt = tc->t_last_sent_nxt; |
258 | tsinfo.last_expected_una = tc->t_last_expected_una; |
259 | tsinfo.last_seen_una = tc->t_last_seen_una; |
260 | tsinfo.tos = tc->t_cpath->cp_conn->c_tos; |
261 | |
262 | rds_info_copy(iter, data: &tsinfo, bytes: sizeof(tsinfo)); |
263 | } |
264 | |
265 | out: |
266 | lens->nr = rds_tcp_tc_count; |
267 | lens->each = sizeof(tsinfo); |
268 | |
269 | spin_unlock_irqrestore(lock: &rds_tcp_tc_list_lock, flags); |
270 | } |
271 | |
272 | #if IS_ENABLED(CONFIG_IPV6) |
273 | /* Handle RDS6_INFO_TCP_SOCKETS socket option. It returns both IPv4 and |
274 | * IPv6 connections. IPv4 connection address is returned in an IPv4 mapped |
275 | * address. |
276 | */ |
277 | static void rds6_tcp_tc_info(struct socket *sock, unsigned int len, |
278 | struct rds_info_iterator *iter, |
279 | struct rds_info_lengths *lens) |
280 | { |
281 | struct rds6_info_tcp_socket tsinfo6; |
282 | struct rds_tcp_connection *tc; |
283 | unsigned long flags; |
284 | |
285 | spin_lock_irqsave(&rds_tcp_tc_list_lock, flags); |
286 | |
287 | if (len / sizeof(tsinfo6) < rds6_tcp_tc_count) |
288 | goto out; |
289 | |
290 | list_for_each_entry(tc, &rds_tcp_tc_list, t_list_item) { |
291 | struct sock *sk = tc->t_sock->sk; |
292 | struct inet_sock *inet = inet_sk(sk); |
293 | |
294 | tsinfo6.local_addr = sk->sk_v6_rcv_saddr; |
295 | tsinfo6.local_port = inet->inet_sport; |
296 | tsinfo6.peer_addr = sk->sk_v6_daddr; |
297 | tsinfo6.peer_port = inet->inet_dport; |
298 | |
299 | tsinfo6.hdr_rem = tc->t_tinc_hdr_rem; |
300 | tsinfo6.data_rem = tc->t_tinc_data_rem; |
301 | tsinfo6.last_sent_nxt = tc->t_last_sent_nxt; |
302 | tsinfo6.last_expected_una = tc->t_last_expected_una; |
303 | tsinfo6.last_seen_una = tc->t_last_seen_una; |
304 | |
305 | rds_info_copy(iter, data: &tsinfo6, bytes: sizeof(tsinfo6)); |
306 | } |
307 | |
308 | out: |
309 | lens->nr = rds6_tcp_tc_count; |
310 | lens->each = sizeof(tsinfo6); |
311 | |
312 | spin_unlock_irqrestore(lock: &rds_tcp_tc_list_lock, flags); |
313 | } |
314 | #endif |
315 | |
316 | int rds_tcp_laddr_check(struct net *net, const struct in6_addr *addr, |
317 | __u32 scope_id) |
318 | { |
319 | struct net_device *dev = NULL; |
320 | #if IS_ENABLED(CONFIG_IPV6) |
321 | int ret; |
322 | #endif |
323 | |
324 | if (ipv6_addr_v4mapped(a: addr)) { |
325 | if (inet_addr_type(net, addr: addr->s6_addr32[3]) == RTN_LOCAL) |
326 | return 0; |
327 | return -EADDRNOTAVAIL; |
328 | } |
329 | |
330 | /* If the scope_id is specified, check only those addresses |
331 | * hosted on the specified interface. |
332 | */ |
333 | if (scope_id != 0) { |
334 | rcu_read_lock(); |
335 | dev = dev_get_by_index_rcu(net, ifindex: scope_id); |
336 | /* scope_id is not valid... */ |
337 | if (!dev) { |
338 | rcu_read_unlock(); |
339 | return -EADDRNOTAVAIL; |
340 | } |
341 | rcu_read_unlock(); |
342 | } |
343 | #if IS_ENABLED(CONFIG_IPV6) |
344 | ret = ipv6_chk_addr(net, addr, dev, strict: 0); |
345 | if (ret) |
346 | return 0; |
347 | #endif |
348 | return -EADDRNOTAVAIL; |
349 | } |
350 | |
351 | static void rds_tcp_conn_free(void *arg) |
352 | { |
353 | struct rds_tcp_connection *tc = arg; |
354 | unsigned long flags; |
355 | |
356 | rdsdebug("freeing tc %p\n" , tc); |
357 | |
358 | spin_lock_irqsave(&rds_tcp_conn_lock, flags); |
359 | if (!tc->t_tcp_node_detached) |
360 | list_del(entry: &tc->t_tcp_node); |
361 | spin_unlock_irqrestore(lock: &rds_tcp_conn_lock, flags); |
362 | |
363 | kmem_cache_free(s: rds_tcp_conn_slab, objp: tc); |
364 | } |
365 | |
366 | static int rds_tcp_conn_alloc(struct rds_connection *conn, gfp_t gfp) |
367 | { |
368 | struct rds_tcp_connection *tc; |
369 | int i, j; |
370 | int ret = 0; |
371 | |
372 | for (i = 0; i < RDS_MPATH_WORKERS; i++) { |
373 | tc = kmem_cache_alloc(cachep: rds_tcp_conn_slab, flags: gfp); |
374 | if (!tc) { |
375 | ret = -ENOMEM; |
376 | goto fail; |
377 | } |
378 | mutex_init(&tc->t_conn_path_lock); |
379 | tc->t_sock = NULL; |
380 | tc->t_tinc = NULL; |
381 | tc->t_tinc_hdr_rem = sizeof(struct rds_header); |
382 | tc->t_tinc_data_rem = 0; |
383 | |
384 | conn->c_path[i].cp_transport_data = tc; |
385 | tc->t_cpath = &conn->c_path[i]; |
386 | tc->t_tcp_node_detached = true; |
387 | |
388 | rdsdebug("rds_conn_path [%d] tc %p\n" , i, |
389 | conn->c_path[i].cp_transport_data); |
390 | } |
391 | spin_lock_irq(lock: &rds_tcp_conn_lock); |
392 | for (i = 0; i < RDS_MPATH_WORKERS; i++) { |
393 | tc = conn->c_path[i].cp_transport_data; |
394 | tc->t_tcp_node_detached = false; |
395 | list_add_tail(new: &tc->t_tcp_node, head: &rds_tcp_conn_list); |
396 | } |
397 | spin_unlock_irq(lock: &rds_tcp_conn_lock); |
398 | fail: |
399 | if (ret) { |
400 | for (j = 0; j < i; j++) |
401 | rds_tcp_conn_free(arg: conn->c_path[j].cp_transport_data); |
402 | } |
403 | return ret; |
404 | } |
405 | |
406 | static bool list_has_conn(struct list_head *list, struct rds_connection *conn) |
407 | { |
408 | struct rds_tcp_connection *tc, *_tc; |
409 | |
410 | list_for_each_entry_safe(tc, _tc, list, t_tcp_node) { |
411 | if (tc->t_cpath->cp_conn == conn) |
412 | return true; |
413 | } |
414 | return false; |
415 | } |
416 | |
417 | static void rds_tcp_set_unloading(void) |
418 | { |
419 | atomic_set(v: &rds_tcp_unloading, i: 1); |
420 | } |
421 | |
422 | static bool rds_tcp_is_unloading(struct rds_connection *conn) |
423 | { |
424 | return atomic_read(v: &rds_tcp_unloading) != 0; |
425 | } |
426 | |
427 | static void rds_tcp_destroy_conns(void) |
428 | { |
429 | struct rds_tcp_connection *tc, *_tc; |
430 | LIST_HEAD(tmp_list); |
431 | |
432 | /* avoid calling conn_destroy with irqs off */ |
433 | spin_lock_irq(lock: &rds_tcp_conn_lock); |
434 | list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) { |
435 | if (!list_has_conn(list: &tmp_list, conn: tc->t_cpath->cp_conn)) |
436 | list_move_tail(list: &tc->t_tcp_node, head: &tmp_list); |
437 | } |
438 | spin_unlock_irq(lock: &rds_tcp_conn_lock); |
439 | |
440 | list_for_each_entry_safe(tc, _tc, &tmp_list, t_tcp_node) |
441 | rds_conn_destroy(conn: tc->t_cpath->cp_conn); |
442 | } |
443 | |
444 | static void rds_tcp_exit(void); |
445 | |
446 | static u8 rds_tcp_get_tos_map(u8 tos) |
447 | { |
448 | /* all user tos mapped to default 0 for TCP transport */ |
449 | return 0; |
450 | } |
451 | |
452 | struct rds_transport rds_tcp_transport = { |
453 | .laddr_check = rds_tcp_laddr_check, |
454 | .xmit_path_prepare = rds_tcp_xmit_path_prepare, |
455 | .xmit_path_complete = rds_tcp_xmit_path_complete, |
456 | .xmit = rds_tcp_xmit, |
457 | .recv_path = rds_tcp_recv_path, |
458 | .conn_alloc = rds_tcp_conn_alloc, |
459 | .conn_free = rds_tcp_conn_free, |
460 | .conn_path_connect = rds_tcp_conn_path_connect, |
461 | .conn_path_shutdown = rds_tcp_conn_path_shutdown, |
462 | .inc_copy_to_user = rds_tcp_inc_copy_to_user, |
463 | .inc_free = rds_tcp_inc_free, |
464 | .stats_info_copy = rds_tcp_stats_info_copy, |
465 | .exit = rds_tcp_exit, |
466 | .get_tos_map = rds_tcp_get_tos_map, |
467 | .t_owner = THIS_MODULE, |
468 | .t_name = "tcp" , |
469 | .t_type = RDS_TRANS_TCP, |
470 | .t_prefer_loopback = 1, |
471 | .t_mp_capable = 1, |
472 | .t_unloading = rds_tcp_is_unloading, |
473 | }; |
474 | |
475 | static unsigned int rds_tcp_netid; |
476 | |
477 | /* per-network namespace private data for this module */ |
478 | struct rds_tcp_net { |
479 | struct socket *rds_tcp_listen_sock; |
480 | struct work_struct rds_tcp_accept_w; |
481 | struct ctl_table_header *rds_tcp_sysctl; |
482 | struct ctl_table *ctl_table; |
483 | int sndbuf_size; |
484 | int rcvbuf_size; |
485 | }; |
486 | |
487 | /* All module specific customizations to the RDS-TCP socket should be done in |
488 | * rds_tcp_tune() and applied after socket creation. |
489 | */ |
490 | bool rds_tcp_tune(struct socket *sock) |
491 | { |
492 | struct sock *sk = sock->sk; |
493 | struct net *net = sock_net(sk); |
494 | struct rds_tcp_net *rtn; |
495 | |
496 | tcp_sock_set_nodelay(sk: sock->sk); |
497 | lock_sock(sk); |
498 | /* TCP timer functions might access net namespace even after |
499 | * a process which created this net namespace terminated. |
500 | */ |
501 | if (!sk->sk_net_refcnt) { |
502 | if (!maybe_get_net(net)) { |
503 | release_sock(sk); |
504 | return false; |
505 | } |
506 | /* Update ns_tracker to current stack trace and refcounted tracker */ |
507 | __netns_tracker_free(net, tracker: &sk->ns_tracker, refcounted: false); |
508 | |
509 | sk->sk_net_refcnt = 1; |
510 | netns_tracker_alloc(net, tracker: &sk->ns_tracker, GFP_KERNEL); |
511 | sock_inuse_add(net, val: 1); |
512 | } |
513 | rtn = net_generic(net, id: rds_tcp_netid); |
514 | if (rtn->sndbuf_size > 0) { |
515 | sk->sk_sndbuf = rtn->sndbuf_size; |
516 | sk->sk_userlocks |= SOCK_SNDBUF_LOCK; |
517 | } |
518 | if (rtn->rcvbuf_size > 0) { |
519 | sk->sk_rcvbuf = rtn->rcvbuf_size; |
520 | sk->sk_userlocks |= SOCK_RCVBUF_LOCK; |
521 | } |
522 | release_sock(sk); |
523 | return true; |
524 | } |
525 | |
526 | static void rds_tcp_accept_worker(struct work_struct *work) |
527 | { |
528 | struct rds_tcp_net *rtn = container_of(work, |
529 | struct rds_tcp_net, |
530 | rds_tcp_accept_w); |
531 | |
532 | while (rds_tcp_accept_one(sock: rtn->rds_tcp_listen_sock) == 0) |
533 | cond_resched(); |
534 | } |
535 | |
536 | void rds_tcp_accept_work(struct sock *sk) |
537 | { |
538 | struct net *net = sock_net(sk); |
539 | struct rds_tcp_net *rtn = net_generic(net, id: rds_tcp_netid); |
540 | |
541 | queue_work(wq: rds_wq, work: &rtn->rds_tcp_accept_w); |
542 | } |
543 | |
544 | static __net_init int rds_tcp_init_net(struct net *net) |
545 | { |
546 | struct rds_tcp_net *rtn = net_generic(net, id: rds_tcp_netid); |
547 | struct ctl_table *tbl; |
548 | int err = 0; |
549 | |
550 | memset(rtn, 0, sizeof(*rtn)); |
551 | |
552 | /* {snd, rcv}buf_size default to 0, which implies we let the |
553 | * stack pick the value, and permit auto-tuning of buffer size. |
554 | */ |
555 | if (net == &init_net) { |
556 | tbl = rds_tcp_sysctl_table; |
557 | } else { |
558 | tbl = kmemdup(p: rds_tcp_sysctl_table, |
559 | size: sizeof(rds_tcp_sysctl_table), GFP_KERNEL); |
560 | if (!tbl) { |
561 | pr_warn("could not set allocate sysctl table\n" ); |
562 | return -ENOMEM; |
563 | } |
564 | rtn->ctl_table = tbl; |
565 | } |
566 | tbl[RDS_TCP_SNDBUF].data = &rtn->sndbuf_size; |
567 | tbl[RDS_TCP_RCVBUF].data = &rtn->rcvbuf_size; |
568 | rtn->rds_tcp_sysctl = register_net_sysctl_sz(net, path: "net/rds/tcp" , table: tbl, |
569 | ARRAY_SIZE(rds_tcp_sysctl_table)); |
570 | if (!rtn->rds_tcp_sysctl) { |
571 | pr_warn("could not register sysctl\n" ); |
572 | err = -ENOMEM; |
573 | goto fail; |
574 | } |
575 | |
576 | #if IS_ENABLED(CONFIG_IPV6) |
577 | rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, isv6: true); |
578 | #else |
579 | rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, false); |
580 | #endif |
581 | if (!rtn->rds_tcp_listen_sock) { |
582 | pr_warn("could not set up IPv6 listen sock\n" ); |
583 | |
584 | #if IS_ENABLED(CONFIG_IPV6) |
585 | /* Try IPv4 as some systems disable IPv6 */ |
586 | rtn->rds_tcp_listen_sock = rds_tcp_listen_init(net, isv6: false); |
587 | if (!rtn->rds_tcp_listen_sock) { |
588 | #endif |
589 | unregister_net_sysctl_table(header: rtn->rds_tcp_sysctl); |
590 | rtn->rds_tcp_sysctl = NULL; |
591 | err = -EAFNOSUPPORT; |
592 | goto fail; |
593 | #if IS_ENABLED(CONFIG_IPV6) |
594 | } |
595 | #endif |
596 | } |
597 | INIT_WORK(&rtn->rds_tcp_accept_w, rds_tcp_accept_worker); |
598 | return 0; |
599 | |
600 | fail: |
601 | if (net != &init_net) |
602 | kfree(objp: tbl); |
603 | return err; |
604 | } |
605 | |
606 | static void rds_tcp_kill_sock(struct net *net) |
607 | { |
608 | struct rds_tcp_connection *tc, *_tc; |
609 | LIST_HEAD(tmp_list); |
610 | struct rds_tcp_net *rtn = net_generic(net, id: rds_tcp_netid); |
611 | struct socket *lsock = rtn->rds_tcp_listen_sock; |
612 | |
613 | rtn->rds_tcp_listen_sock = NULL; |
614 | rds_tcp_listen_stop(sock: lsock, acceptor: &rtn->rds_tcp_accept_w); |
615 | spin_lock_irq(lock: &rds_tcp_conn_lock); |
616 | list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) { |
617 | struct net *c_net = read_pnet(pnet: &tc->t_cpath->cp_conn->c_net); |
618 | |
619 | if (net != c_net) |
620 | continue; |
621 | if (!list_has_conn(list: &tmp_list, conn: tc->t_cpath->cp_conn)) { |
622 | list_move_tail(list: &tc->t_tcp_node, head: &tmp_list); |
623 | } else { |
624 | list_del(entry: &tc->t_tcp_node); |
625 | tc->t_tcp_node_detached = true; |
626 | } |
627 | } |
628 | spin_unlock_irq(lock: &rds_tcp_conn_lock); |
629 | list_for_each_entry_safe(tc, _tc, &tmp_list, t_tcp_node) |
630 | rds_conn_destroy(conn: tc->t_cpath->cp_conn); |
631 | } |
632 | |
633 | static void __net_exit rds_tcp_exit_net(struct net *net) |
634 | { |
635 | struct rds_tcp_net *rtn = net_generic(net, id: rds_tcp_netid); |
636 | |
637 | rds_tcp_kill_sock(net); |
638 | |
639 | if (rtn->rds_tcp_sysctl) |
640 | unregister_net_sysctl_table(header: rtn->rds_tcp_sysctl); |
641 | |
642 | if (net != &init_net) |
643 | kfree(objp: rtn->ctl_table); |
644 | } |
645 | |
646 | static struct pernet_operations rds_tcp_net_ops = { |
647 | .init = rds_tcp_init_net, |
648 | .exit = rds_tcp_exit_net, |
649 | .id = &rds_tcp_netid, |
650 | .size = sizeof(struct rds_tcp_net), |
651 | }; |
652 | |
653 | void *rds_tcp_listen_sock_def_readable(struct net *net) |
654 | { |
655 | struct rds_tcp_net *rtn = net_generic(net, id: rds_tcp_netid); |
656 | struct socket *lsock = rtn->rds_tcp_listen_sock; |
657 | |
658 | if (!lsock) |
659 | return NULL; |
660 | |
661 | return lsock->sk->sk_user_data; |
662 | } |
663 | |
664 | /* when sysctl is used to modify some kernel socket parameters,this |
665 | * function resets the RDS connections in that netns so that we can |
666 | * restart with new parameters. The assumption is that such reset |
667 | * events are few and far-between. |
668 | */ |
669 | static void rds_tcp_sysctl_reset(struct net *net) |
670 | { |
671 | struct rds_tcp_connection *tc, *_tc; |
672 | |
673 | spin_lock_irq(lock: &rds_tcp_conn_lock); |
674 | list_for_each_entry_safe(tc, _tc, &rds_tcp_conn_list, t_tcp_node) { |
675 | struct net *c_net = read_pnet(pnet: &tc->t_cpath->cp_conn->c_net); |
676 | |
677 | if (net != c_net || !tc->t_sock) |
678 | continue; |
679 | |
680 | /* reconnect with new parameters */ |
681 | rds_conn_path_drop(cpath: tc->t_cpath, destroy: false); |
682 | } |
683 | spin_unlock_irq(lock: &rds_tcp_conn_lock); |
684 | } |
685 | |
686 | static int rds_tcp_skbuf_handler(struct ctl_table *ctl, int write, |
687 | void *buffer, size_t *lenp, loff_t *fpos) |
688 | { |
689 | struct net *net = current->nsproxy->net_ns; |
690 | int err; |
691 | |
692 | err = proc_dointvec_minmax(ctl, write, buffer, lenp, fpos); |
693 | if (err < 0) { |
694 | pr_warn("Invalid input. Must be >= %d\n" , |
695 | *(int *)(ctl->extra1)); |
696 | return err; |
697 | } |
698 | if (write) |
699 | rds_tcp_sysctl_reset(net); |
700 | return 0; |
701 | } |
702 | |
703 | static void rds_tcp_exit(void) |
704 | { |
705 | rds_tcp_set_unloading(); |
706 | synchronize_rcu(); |
707 | rds_info_deregister_func(RDS_INFO_TCP_SOCKETS, func: rds_tcp_tc_info); |
708 | #if IS_ENABLED(CONFIG_IPV6) |
709 | rds_info_deregister_func(RDS6_INFO_TCP_SOCKETS, func: rds6_tcp_tc_info); |
710 | #endif |
711 | unregister_pernet_device(&rds_tcp_net_ops); |
712 | rds_tcp_destroy_conns(); |
713 | rds_trans_unregister(trans: &rds_tcp_transport); |
714 | rds_tcp_recv_exit(); |
715 | kmem_cache_destroy(s: rds_tcp_conn_slab); |
716 | } |
717 | module_exit(rds_tcp_exit); |
718 | |
719 | static int __init rds_tcp_init(void) |
720 | { |
721 | int ret; |
722 | |
723 | rds_tcp_conn_slab = kmem_cache_create(name: "rds_tcp_connection" , |
724 | size: sizeof(struct rds_tcp_connection), |
725 | align: 0, flags: 0, NULL); |
726 | if (!rds_tcp_conn_slab) { |
727 | ret = -ENOMEM; |
728 | goto out; |
729 | } |
730 | |
731 | ret = rds_tcp_recv_init(); |
732 | if (ret) |
733 | goto out_slab; |
734 | |
735 | ret = register_pernet_device(&rds_tcp_net_ops); |
736 | if (ret) |
737 | goto out_recv; |
738 | |
739 | rds_trans_register(trans: &rds_tcp_transport); |
740 | |
741 | rds_info_register_func(RDS_INFO_TCP_SOCKETS, func: rds_tcp_tc_info); |
742 | #if IS_ENABLED(CONFIG_IPV6) |
743 | rds_info_register_func(RDS6_INFO_TCP_SOCKETS, func: rds6_tcp_tc_info); |
744 | #endif |
745 | |
746 | goto out; |
747 | out_recv: |
748 | rds_tcp_recv_exit(); |
749 | out_slab: |
750 | kmem_cache_destroy(s: rds_tcp_conn_slab); |
751 | out: |
752 | return ret; |
753 | } |
754 | module_init(rds_tcp_init); |
755 | |
756 | MODULE_AUTHOR("Oracle Corporation <rds-devel@oss.oracle.com>" ); |
757 | MODULE_DESCRIPTION("RDS: TCP transport" ); |
758 | MODULE_LICENSE("Dual BSD/GPL" ); |
759 | |