2019-05-27 09:55:01 +03:00
/* SPDX-License-Identifier: GPL-2.0-or-later */
2005-08-10 06:59:20 +04:00
/*
* INET An implementation of the TCP / IP protocol suite for the LINUX
* operating system . INET is implemented using the BSD Socket
* interface as the means of communication with the user level .
*
* Authors : Lotsa people , from code originally in tcp
*/
# ifndef _INET_HASHTABLES_H
# define _INET_HASHTABLES_H
2005-08-10 07:09:30 +04:00
2005-08-10 07:07:13 +04:00
# include <linux/interrupt.h>
2008-10-07 22:41:57 +04:00
# include <linux/ip.h>
2005-08-10 07:09:06 +04:00
# include <linux/ipv6.h>
2005-08-10 07:00:51 +04:00
# include <linux/list.h>
# include <linux/slab.h>
2005-08-10 07:09:06 +04:00
# include <linux/socket.h>
2005-08-10 07:00:51 +04:00
# include <linux/spinlock.h>
2005-08-10 06:59:20 +04:00
# include <linux/types.h>
2005-08-10 07:08:09 +04:00
# include <linux/wait.h>
2005-08-10 06:59:20 +04:00
2005-08-10 07:10:42 +04:00
# include <net/inet_connection_sock.h>
2005-12-27 07:43:12 +03:00
# include <net/inet_sock.h>
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
# include <net/ip.h>
2005-08-10 07:07:13 +04:00
# include <net/sock.h>
2008-10-07 22:41:57 +04:00
# include <net/route.h>
2005-08-10 07:08:28 +04:00
# include <net/tcp_states.h>
2008-06-17 04:14:11 +04:00
# include <net/netns/hash.h>
2005-08-10 07:07:13 +04:00
2017-06-30 13:08:01 +03:00
# include <linux/refcount.h>
2005-08-10 07:09:46 +04:00
# include <asm/byteorder.h>
2005-08-10 07:08:09 +04:00
2005-08-10 07:00:51 +04:00
/* This is for all connections with a full identity, no wildcards.
tcp/dccp: remove twchain
TCP listener refactoring, part 3 :
Our goal is to hash SYN_RECV sockets into main ehash for fast lookup,
and parallel SYN processing.
Current inet_ehash_bucket contains two chains, one for ESTABLISH (and
friend states) sockets, another for TIME_WAIT sockets only.
As the hash table is sized to get at most one socket per bucket, it
makes little sense to have separate twchain, as it makes the lookup
slightly more complicated, and doubles hash table memory usage.
If we make sure all socket types have the lookup keys at the same
offsets, we can use a generic and faster lookup. It turns out TIME_WAIT
and ESTABLISHED sockets already have common lookup fields for IPv4.
[ INET_TW_MATCH() is no longer needed ]
I'll provide a follow-up to factorize IPv6 lookup as well, to remove
INET6_TW_MATCH()
This way, SYN_RECV pseudo sockets will be supported the same.
A new sock_gen_put() helper is added, doing either a sock_put() or
inet_twsk_put() [ and will support SYN_RECV later ].
Note this helper should only be called in real slow path, when rcu
lookup found a socket that was moved to another identity (freed/reused
immediately), but could eventually be used in other contexts, like
sock_edemux()
Before patch :
dmesg | grep "TCP established"
TCP established hash table entries: 524288 (order: 11, 8388608 bytes)
After patch :
TCP established hash table entries: 524288 (order: 10, 4194304 bytes)
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-03 11:22:02 +04:00
* The ' e ' prefix stands for Establish , but we really put all sockets
* but LISTEN ones .
2005-08-10 07:00:51 +04:00
*/
struct inet_ehash_bucket {
2008-11-17 06:40:17 +03:00
struct hlist_nulls_head chain ;
2005-10-05 02:55:51 +04:00
} ;
2005-08-10 07:00:51 +04:00
/* There are a few simple rules, which allow for local port reuse by
* an application . In essence :
*
* 1 ) Sockets bound to different interfaces may share a local port .
* Failing that , goto test 2.
* 2 ) If all sockets have sk - > sk_reuse set , and none of them are in
* TCP_LISTEN state , the port may be shared .
* Failing that , goto test 3.
* 3 ) If all sockets are bound to a specific inet_sk ( sk ) - > rcv_saddr local
* address , and none of them are the same , the port may be
* shared .
* Failing this , the port cannot be shared .
*
* The interesting point , is test # 2. This is what an FTP server does
* all day . To optimize this case we use a specific flag bit defined
* below . As we add sockets to a bind bucket list , we perform a
* check of : ( newsk - > sk_reuse & & ( newsk - > sk_state ! = TCP_LISTEN ) )
* As long as all sockets added to a bind bucket pass this test ,
* the flag bit will be set .
* The resulting situation is that tcp_v [ 46 ] _verify_bind ( ) can just check
* for this flag bit , if it is set and the socket trying to bind has
* sk - > sk_reuse set , we don ' t even have to walk the owners list at all ,
* we return that it is ok to bind this socket to the requested local port .
*
* Sounds like a lot of work , but it is worth it . In a more naive
* implementation ( ie . current FreeBSD etc . ) the entire list of ports
* must be walked for each data port opened by an ftp server . Needless
* to say , this does not scale at all . With a couple thousand FTP
* users logged onto your box , isn ' t it nice to know that new data
* ports are created in O ( 1 ) time ? I thought so . ; - ) - DaveM
*/
2017-01-17 18:51:06 +03:00
# define FASTREUSEPORT_ANY 1
# define FASTREUSEPORT_STRICT 2
2005-08-10 07:00:51 +04:00
struct inet_bind_bucket {
2015-03-12 07:06:44 +03:00
possible_net_t ib_net ;
2018-11-07 18:36:02 +03:00
int l3mdev ;
2005-08-10 07:00:51 +04:00
unsigned short port ;
2013-01-22 13:50:24 +04:00
signed char fastreuse ;
signed char fastreuseport ;
kuid_t fastuid ;
2017-01-17 18:51:06 +03:00
# if IS_ENABLED(CONFIG_IPV6)
struct in6_addr fast_v6_rcv_saddr ;
# endif
__be32 fast_rcv_saddr ;
unsigned short fast_sk_family ;
bool fast_ipv6_only ;
2005-08-10 07:00:51 +04:00
struct hlist_node node ;
struct hlist_head owners ;
} ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
struct inet_bind2_bucket {
possible_net_t ib_net ;
int l3mdev ;
unsigned short port ;
2022-09-27 03:25:44 +03:00
# if IS_ENABLED(CONFIG_IPV6)
unsigned short family ;
# endif
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
union {
# if IS_ENABLED(CONFIG_IPV6)
struct in6_addr v6_rcv_saddr ;
# endif
__be32 rcv_saddr ;
} ;
/* Node in the bhash2 inet_bind_hashbucket chain */
struct hlist_node node ;
/* List of sockets hashed to this bucket */
struct hlist_head owners ;
2022-12-26 16:27:52 +03:00
/* bhash has twsk in owners, but bhash2 has twsk in
* deathrow not to add a member in struct sock_common .
*/
struct hlist_head deathrow ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
} ;
static inline struct net * ib_net ( const struct inet_bind_bucket * ib )
{
return read_pnet ( & ib - > ib_net ) ;
}
static inline struct net * ib2_net ( const struct inet_bind2_bucket * ib )
2008-11-12 11:54:20 +03:00
{
return read_pnet ( & ib - > ib_net ) ;
}
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 05:06:00 +04:00
# define inet_bind_bucket_for_each(tb, head) \
hlist_for_each_entry ( tb , head , node )
2005-08-10 07:00:51 +04:00
struct inet_bind_hashbucket {
spinlock_t lock ;
struct hlist_head chain ;
} ;
2019-12-14 05:20:41 +03:00
/* Sockets can be hashed in established or listening table.
* We must use different ' nulls ' end - of - chain value for all hash buckets :
* A socket might transition from ESTABLISH to LISTEN state without
* RCU grace period . A lookup in ehash table needs to handle this case .
2008-11-24 04:22:55 +03:00
*/
2019-12-14 05:20:41 +03:00
# define LISTENING_NULLS_BASE (1U << 29)
2008-11-20 11:40:07 +03:00
struct inet_listen_hashbucket {
spinlock_t lock ;
2022-05-12 03:06:05 +03:00
struct hlist_nulls_head nulls_head ;
2008-11-20 11:40:07 +03:00
} ;
2005-08-10 07:00:51 +04:00
/* This is for listening sockets, thus all sockets which possess wildcards. */
# define INET_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */
struct inet_hashinfo {
/* This is for sockets with full identity only. Sockets here will
* always be without wildcards and will have the following invariant :
*
* TCP_ESTABLISHED < = sk - > sk_state < TCP_CLOSE
*
*/
struct inet_ehash_bucket * ehash ;
2008-11-21 07:39:09 +03:00
spinlock_t * ehash_locks ;
2009-10-09 04:16:19 +04:00
unsigned int ehash_mask ;
2007-11-07 13:40:20 +03:00
unsigned int ehash_locks_mask ;
2005-08-10 07:00:51 +04:00
/* Ok, let's try this, I give up, we do need a local binding
* TCP hash as well as the others for fast bind / connect .
*/
2017-12-01 23:52:31 +03:00
struct kmem_cache * bind_bucket_cachep ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
/* This bind table is hashed by local port */
2005-08-10 07:00:51 +04:00
struct inet_bind_hashbucket * bhash ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
struct kmem_cache * bind2_bucket_cachep ;
/* This bind table is hashed by local port and sk->sk_rcv_saddr (ipv4)
* or sk - > sk_v6_rcv_saddr ( ipv6 ) . This 2 nd bind table is used
* primarily for expediting bind conflict resolution .
*/
struct inet_bind_hashbucket * bhash2 ;
2007-10-09 12:59:42 +04:00
unsigned int bhash_size ;
2005-08-10 07:00:51 +04:00
2017-12-01 23:52:31 +03:00
/* The 2nd listener table hashed by local port and address */
unsigned int lhash2_mask ;
struct inet_listen_hashbucket * lhash2 ;
tcp: Introduce optional per-netns ehash.
The more sockets we have in the hash table, the longer we spend looking
up the socket. While running a number of small workloads on the same
host, they penalise each other and cause performance degradation.
The root cause might be a single workload that consumes much more
resources than the others. It often happens on a cloud service where
different workloads share the same computing resource.
On EC2 c5.24xlarge instance (196 GiB memory and 524288 (1Mi / 2) ehash
entries), after running iperf3 in different netns, creating 24Mi sockets
without data transfer in the root netns causes about 10% performance
regression for the iperf3's connection.
thash_entries sockets length Gbps
524288 1 1 50.7
24Mi 48 45.1
It is basically related to the length of the list of each hash bucket.
For testing purposes to see how performance drops along the length,
I set 131072 (1Mi / 8) to thash_entries, and here's the result.
thash_entries sockets length Gbps
131072 1 1 50.7
1Mi 8 49.9
2Mi 16 48.9
4Mi 32 47.3
8Mi 64 44.6
16Mi 128 40.6
24Mi 192 36.3
32Mi 256 32.5
40Mi 320 27.0
48Mi 384 25.0
To resolve the socket lookup degradation, we introduce an optional
per-netns hash table for TCP, but it's just ehash, and we still share
the global bhash, bhash2 and lhash2.
With a smaller ehash, we can look up non-listener sockets faster and
isolate such noisy neighbours. In addition, we can reduce lock contention.
We can control the ehash size by a new sysctl knob. However, depending
on workloads, it will require very sensitive tuning, so we disable the
feature by default (net.ipv4.tcp_child_ehash_entries == 0). Moreover,
we can fall back to using the global ehash in case we fail to allocate
enough memory for a new ehash. The maximum size is 16Mi, which is large
enough that even if we have 48Mi sockets, the average list length is 3,
and regression would be less than 1%.
We can check the current ehash size by another read-only sysctl knob,
net.ipv4.tcp_ehash_entries. A negative value means the netns shares
the global ehash (per-netns ehash is disabled or failed to allocate
memory).
# dmesg | cut -d ' ' -f 5- | grep "established hash"
TCP established hash table entries: 524288 (order: 10, 4194304 bytes, vmalloc hugepage)
# sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = 524288 # can be changed by thash_entries
# sysctl net.ipv4.tcp_child_ehash_entries
net.ipv4.tcp_child_ehash_entries = 0 # disabled by default
# ip netns add test1
# ip netns exec test1 sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = -524288 # share the global ehash
# sysctl -w net.ipv4.tcp_child_ehash_entries=100
net.ipv4.tcp_child_ehash_entries = 100
# ip netns add test2
# ip netns exec test2 sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = 128 # own a per-netns ehash with 2^n buckets
When more than two processes in the same netns create per-netns ehash
concurrently with different sizes, we need to guarantee the size in
one of the following ways:
1) Share the global ehash and create per-netns ehash
First, unshare() with tcp_child_ehash_entries==0. It creates dedicated
netns sysctl knobs where we can safely change tcp_child_ehash_entries
and clone()/unshare() to create a per-netns ehash.
2) Control write on sysctl by BPF
We can use BPF_PROG_TYPE_CGROUP_SYSCTL to allow/deny read/write on
sysctl knobs.
Note that the global ehash allocated at the boot time is spread over
available NUMA nodes, but inet_pernet_hashinfo_alloc() will allocate
pages for each per-netns ehash depending on the current process's NUMA
policy. By default, the allocation is done in the local node only, so
the per-netns hash table could fully reside on a random node. Thus,
depending on the NUMA policy the netns is created with and the CPU the
current thread is running on, we could see some performance differences
for highly optimised networking applications.
Note also that the default values of two sysctl knobs depend on the ehash
size and should be tuned carefully:
tcp_max_tw_buckets : tcp_child_ehash_entries / 2
tcp_max_syn_backlog : max(128, tcp_child_ehash_entries / 128)
As a bonus, we can dismantle netns faster. Currently, while destroying
netns, we call inet_twsk_purge(), which walks through the global ehash.
It can be potentially big because it can have many sockets other than
TIME_WAIT in all netns. Splitting ehash changes that situation, where
it's only necessary for inet_twsk_purge() to clean up TIME_WAIT sockets
in each netns.
With regard to this, we do not free the per-netns ehash in inet_twsk_kill()
to avoid UAF while iterating the per-netns ehash in inet_twsk_purge().
Instead, we do it in tcp_sk_exit_batch() after calling tcp_twsk_purge() to
keep it protocol-family-independent.
In the future, we could optimise ehash lookup/iteration further by removing
netns comparison for the per-netns ehash.
Signed-off-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-09-08 04:10:22 +03:00
bool pernet ;
2023-08-03 10:53:34 +03:00
} ____cacheline_aligned_in_smp ;
2005-08-10 07:00:51 +04:00
2022-09-08 04:10:19 +03:00
static inline struct inet_hashinfo * tcp_or_dccp_get_hashinfo ( const struct sock * sk )
{
# if IS_ENABLED(CONFIG_IP_DCCP)
return sk - > sk_prot - > h . hashinfo ? :
sock_net ( sk ) - > ipv4 . tcp_death_row . hashinfo ;
# else
return sock_net ( sk ) - > ipv4 . tcp_death_row . hashinfo ;
# endif
}
2017-12-01 23:52:31 +03:00
static inline struct inet_listen_hashbucket *
inet_lhash2_bucket ( struct inet_hashinfo * h , u32 hash )
{
return & h - > lhash2 [ hash & h - > lhash2_mask ] ;
}
[INET]: speedup inet (tcp/dccp) lookups
Arnaldo and I agreed it could be applied now, because I have other
pending patches depending on this one (Thank you Arnaldo)
(The other important patch moves skc_refcnt in a separate cache line,
so that the SMP/NUMA performance doesnt suffer from cache line ping pongs)
1) First some performance data :
--------------------------------
tcp_v4_rcv() wastes a *lot* of time in __inet_lookup_established()
The most time critical code is :
sk_for_each(sk, node, &head->chain) {
if (INET_MATCH(sk, acookie, saddr, daddr, ports, dif))
goto hit; /* You sunk my battleship! */
}
The sk_for_each() does use prefetch() hints but only the begining of
"struct sock" is prefetched.
As INET_MATCH first comparison uses inet_sk(__sk)->daddr, wich is far
away from the begining of "struct sock", it has to bring into CPU
cache cold cache line. Each iteration has to use at least 2 cache
lines.
This can be problematic if some chains are very long.
2) The goal
-----------
The idea I had is to change things so that INET_MATCH() may return
FALSE in 99% of cases only using the data already in the CPU cache,
using one cache line per iteration.
3) Description of the patch
---------------------------
Adds a new 'unsigned int skc_hash' field in 'struct sock_common',
filling a 32 bits hole on 64 bits platform.
struct sock_common {
unsigned short skc_family;
volatile unsigned char skc_state;
unsigned char skc_reuse;
int skc_bound_dev_if;
struct hlist_node skc_node;
struct hlist_node skc_bind_node;
atomic_t skc_refcnt;
+ unsigned int skc_hash;
struct proto *skc_prot;
};
Store in this 32 bits field the full hash, not masked by (ehash_size -
1) Using this full hash as the first comparison done in INET_MATCH
permits us immediatly skip the element without touching a second cache
line in case of a miss.
Suppress the sk_hashent/tw_hashent fields since skc_hash (aliased to
sk_hash and tw_hash) already contains the slot number if we mask with
(ehash_size - 1)
File include/net/inet_hashtables.h
64 bits platforms :
#define INET_MATCH(__sk, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
(((__sk)->sk_hash == (__hash))
((*((__u64 *)&(inet_sk(__sk)->daddr)))== (__cookie)) && \
((*((__u32 *)&(inet_sk(__sk)->dport))) == (__ports)) && \
(!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
32bits platforms:
#define TCP_IPV4_MATCH(__sk, __hash, __cookie, __saddr, __daddr, __ports, __dif)\
(((__sk)->sk_hash == (__hash)) && \
(inet_sk(__sk)->daddr == (__saddr)) && \
(inet_sk(__sk)->rcv_saddr == (__daddr)) && \
(!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
- Adds a prefetch(head->chain.first) in
__inet_lookup_established()/__tcp_v4_check_established() and
__inet6_lookup_established()/__tcp_v6_check_established() and
__dccp_v4_check_established() to bring into cache the first element of the
list, before the {read|write}_lock(&head->lock);
Signed-off-by: Eric Dumazet <dada1@cosmosbay.com>
Acked-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2005-10-04 01:13:38 +04:00
static inline struct inet_ehash_bucket * inet_ehash_bucket (
struct inet_hashinfo * hashinfo ,
unsigned int hash )
{
2009-10-09 04:16:19 +04:00
return & hashinfo - > ehash [ hash & hashinfo - > ehash_mask ] ;
2005-08-10 06:59:20 +04:00
}
2008-11-21 07:39:09 +03:00
static inline spinlock_t * inet_ehash_lockp (
2007-11-07 13:40:20 +03:00
struct inet_hashinfo * hashinfo ,
unsigned int hash )
{
return & hashinfo - > ehash_locks [ hash & hashinfo - > ehash_locks_mask ] ;
}
2015-05-26 17:55:34 +03:00
int inet_ehash_locks_alloc ( struct inet_hashinfo * hashinfo ) ;
2007-11-07 13:40:20 +03:00
2020-06-09 17:18:16 +03:00
static inline void inet_hashinfo2_free_mod ( struct inet_hashinfo * h )
{
kfree ( h - > lhash2 ) ;
h - > lhash2 = NULL ;
}
2007-11-07 13:40:20 +03:00
static inline void inet_ehash_locks_free ( struct inet_hashinfo * hashinfo )
{
2015-05-26 17:55:34 +03:00
kvfree ( hashinfo - > ehash_locks ) ;
hashinfo - > ehash_locks = NULL ;
2007-11-07 13:40:20 +03:00
}
tcp: Introduce optional per-netns ehash.
The more sockets we have in the hash table, the longer we spend looking
up the socket. While running a number of small workloads on the same
host, they penalise each other and cause performance degradation.
The root cause might be a single workload that consumes much more
resources than the others. It often happens on a cloud service where
different workloads share the same computing resource.
On EC2 c5.24xlarge instance (196 GiB memory and 524288 (1Mi / 2) ehash
entries), after running iperf3 in different netns, creating 24Mi sockets
without data transfer in the root netns causes about 10% performance
regression for the iperf3's connection.
thash_entries sockets length Gbps
524288 1 1 50.7
24Mi 48 45.1
It is basically related to the length of the list of each hash bucket.
For testing purposes to see how performance drops along the length,
I set 131072 (1Mi / 8) to thash_entries, and here's the result.
thash_entries sockets length Gbps
131072 1 1 50.7
1Mi 8 49.9
2Mi 16 48.9
4Mi 32 47.3
8Mi 64 44.6
16Mi 128 40.6
24Mi 192 36.3
32Mi 256 32.5
40Mi 320 27.0
48Mi 384 25.0
To resolve the socket lookup degradation, we introduce an optional
per-netns hash table for TCP, but it's just ehash, and we still share
the global bhash, bhash2 and lhash2.
With a smaller ehash, we can look up non-listener sockets faster and
isolate such noisy neighbours. In addition, we can reduce lock contention.
We can control the ehash size by a new sysctl knob. However, depending
on workloads, it will require very sensitive tuning, so we disable the
feature by default (net.ipv4.tcp_child_ehash_entries == 0). Moreover,
we can fall back to using the global ehash in case we fail to allocate
enough memory for a new ehash. The maximum size is 16Mi, which is large
enough that even if we have 48Mi sockets, the average list length is 3,
and regression would be less than 1%.
We can check the current ehash size by another read-only sysctl knob,
net.ipv4.tcp_ehash_entries. A negative value means the netns shares
the global ehash (per-netns ehash is disabled or failed to allocate
memory).
# dmesg | cut -d ' ' -f 5- | grep "established hash"
TCP established hash table entries: 524288 (order: 10, 4194304 bytes, vmalloc hugepage)
# sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = 524288 # can be changed by thash_entries
# sysctl net.ipv4.tcp_child_ehash_entries
net.ipv4.tcp_child_ehash_entries = 0 # disabled by default
# ip netns add test1
# ip netns exec test1 sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = -524288 # share the global ehash
# sysctl -w net.ipv4.tcp_child_ehash_entries=100
net.ipv4.tcp_child_ehash_entries = 100
# ip netns add test2
# ip netns exec test2 sysctl net.ipv4.tcp_ehash_entries
net.ipv4.tcp_ehash_entries = 128 # own a per-netns ehash with 2^n buckets
When more than two processes in the same netns create per-netns ehash
concurrently with different sizes, we need to guarantee the size in
one of the following ways:
1) Share the global ehash and create per-netns ehash
First, unshare() with tcp_child_ehash_entries==0. It creates dedicated
netns sysctl knobs where we can safely change tcp_child_ehash_entries
and clone()/unshare() to create a per-netns ehash.
2) Control write on sysctl by BPF
We can use BPF_PROG_TYPE_CGROUP_SYSCTL to allow/deny read/write on
sysctl knobs.
Note that the global ehash allocated at the boot time is spread over
available NUMA nodes, but inet_pernet_hashinfo_alloc() will allocate
pages for each per-netns ehash depending on the current process's NUMA
policy. By default, the allocation is done in the local node only, so
the per-netns hash table could fully reside on a random node. Thus,
depending on the NUMA policy the netns is created with and the CPU the
current thread is running on, we could see some performance differences
for highly optimised networking applications.
Note also that the default values of two sysctl knobs depend on the ehash
size and should be tuned carefully:
tcp_max_tw_buckets : tcp_child_ehash_entries / 2
tcp_max_syn_backlog : max(128, tcp_child_ehash_entries / 128)
As a bonus, we can dismantle netns faster. Currently, while destroying
netns, we call inet_twsk_purge(), which walks through the global ehash.
It can be potentially big because it can have many sockets other than
TIME_WAIT in all netns. Splitting ehash changes that situation, where
it's only necessary for inet_twsk_purge() to clean up TIME_WAIT sockets
in each netns.
With regard to this, we do not free the per-netns ehash in inet_twsk_kill()
to avoid UAF while iterating the per-netns ehash in inet_twsk_purge().
Instead, we do it in tcp_sk_exit_batch() after calling tcp_twsk_purge() to
keep it protocol-family-independent.
In the future, we could optimise ehash lookup/iteration further by removing
netns comparison for the per-netns ehash.
Signed-off-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-09-08 04:10:22 +03:00
struct inet_hashinfo * inet_pernet_hashinfo_alloc ( struct inet_hashinfo * hashinfo ,
unsigned int ehash_entries ) ;
void inet_pernet_hashinfo_free ( struct inet_hashinfo * hashinfo ) ;
2013-09-21 21:22:41 +04:00
struct inet_bind_bucket *
inet_bind_bucket_create ( struct kmem_cache * cachep , struct net * net ,
struct inet_bind_hashbucket * head ,
2018-11-07 18:36:02 +03:00
const unsigned short snum , int l3mdev ) ;
2013-09-21 21:22:41 +04:00
void inet_bind_bucket_destroy ( struct kmem_cache * cachep ,
struct inet_bind_bucket * tb ) ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
bool inet_bind_bucket_match ( const struct inet_bind_bucket * tb ,
const struct net * net , unsigned short port ,
int l3mdev ) ;
struct inet_bind2_bucket *
inet_bind2_bucket_create ( struct kmem_cache * cachep , struct net * net ,
struct inet_bind_hashbucket * head ,
unsigned short port , int l3mdev ,
const struct sock * sk ) ;
void inet_bind2_bucket_destroy ( struct kmem_cache * cachep ,
struct inet_bind2_bucket * tb ) ;
struct inet_bind2_bucket *
inet_bind2_bucket_find ( const struct inet_bind_hashbucket * head ,
const struct net * net ,
unsigned short port , int l3mdev ,
const struct sock * sk ) ;
bool inet_bind2_bucket_match_addr_any ( const struct inet_bind2_bucket * tb ,
const struct net * net , unsigned short port ,
int l3mdev , const struct sock * sk ) ;
2015-03-19 00:05:33 +03:00
static inline u32 inet_bhashfn ( const struct net * net , const __u16 lport ,
const u32 bhash_size )
2005-08-10 07:00:51 +04:00
{
2008-06-17 04:14:11 +04:00
return ( lport + net_hash_mix ( net ) ) & ( bhash_size - 1 ) ;
2005-08-10 07:00:51 +04:00
}
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
static inline struct inet_bind_hashbucket *
inet_bhashfn_portaddr ( const struct inet_hashinfo * hinfo , const struct sock * sk ,
const struct net * net , unsigned short port )
{
u32 hash ;
# if IS_ENABLED(CONFIG_IPV6)
if ( sk - > sk_family = = AF_INET6 )
hash = ipv6_portaddr_hash ( net , & sk - > sk_v6_rcv_saddr , port ) ;
else
# endif
hash = ipv4_portaddr_hash ( net , sk - > sk_rcv_saddr , port ) ;
return & hinfo - > bhash2 [ hash & ( hinfo - > bhash_size - 1 ) ] ;
}
struct inet_bind_hashbucket *
inet_bhash2_addr_any_hashbucket ( const struct sock * sk , const struct net * net , int port ) ;
/* This should be called whenever a socket's sk_rcv_saddr (ipv4) or
* sk_v6_rcv_saddr ( ipv6 ) changes after it has been binded . The socket ' s
* rcv_saddr field should already have been updated when this is called .
*/
2022-11-19 04:49:13 +03:00
int inet_bhash2_update_saddr ( struct sock * sk , void * saddr , int family ) ;
2022-11-19 04:49:14 +03:00
void inet_bhash2_reset_saddr ( struct sock * sk ) ;
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
2013-09-21 21:22:41 +04:00
void inet_bind_hash ( struct sock * sk , struct inet_bind_bucket * tb ,
net: Add a bhash2 table hashed by port and address
The current bind hashtable (bhash) is hashed by port only.
In the socket bind path, we have to check for bind conflicts by
traversing the specified port's inet_bind_bucket while holding the
hashbucket's spinlock (see inet_csk_get_port() and
inet_csk_bind_conflict()). In instances where there are tons of
sockets hashed to the same port at different addresses, the bind
conflict check is time-intensive and can cause softirq cpu lockups,
as well as stops new tcp connections since __inet_inherit_port()
also contests for the spinlock.
This patch adds a second bind table, bhash2, that hashes by
port and sk->sk_rcv_saddr (ipv4) and sk->sk_v6_rcv_saddr (ipv6).
Searching the bhash2 table leads to significantly faster conflict
resolution and less time holding the hashbucket spinlock.
Please note a few things:
* There can be the case where the a socket's address changes after it
has been bound. There are two cases where this happens:
1) The case where there is a bind() call on INADDR_ANY (ipv4) or
IPV6_ADDR_ANY (ipv6) and then a connect() call. The kernel will
assign the socket an address when it handles the connect()
2) In inet_sk_reselect_saddr(), which is called when rebuilding the
sk header and a few pre-conditions are met (eg rerouting fails).
In these two cases, we need to update the bhash2 table by removing the
entry for the old address, and add a new entry reflecting the updated
address.
* The bhash2 table must have its own lock, even though concurrent
accesses on the same port are protected by the bhash lock. Bhash2 must
have its own lock to protect against cases where sockets on different
ports hash to different bhash hashbuckets but to the same bhash2
hashbucket.
This brings up a few stipulations:
1) When acquiring both the bhash and the bhash2 lock, the bhash2 lock
will always be acquired after the bhash lock and released before the
bhash lock is released.
2) There are no nested bhash2 hashbucket locks. A bhash2 lock is always
acquired+released before another bhash2 lock is acquired+released.
* The bhash table cannot be superseded by the bhash2 table because for
bind requests on INADDR_ANY (ipv4) or IPV6_ADDR_ANY (ipv6), every socket
bound to that port must be checked for a potential conflict. The bhash
table is the only source of port->socket associations.
Signed-off-by: Joanne Koong <joannelkoong@gmail.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-08-22 21:10:21 +03:00
struct inet_bind2_bucket * tb2 , unsigned short port ) ;
2005-08-10 07:07:13 +04:00
/* Caller must disable local BH processing. */
2015-09-29 17:42:44 +03:00
int __inet_inherit_port ( const struct sock * sk , struct sock * child ) ;
2005-08-10 07:07:13 +04:00
2013-09-21 21:22:41 +04:00
void inet_put_port ( struct sock * sk ) ;
2005-08-10 07:07:13 +04:00
2017-12-01 23:52:31 +03:00
void inet_hashinfo2_init ( struct inet_hashinfo * h , const char * name ,
unsigned long numentries , int scale ,
unsigned long low_limit ,
unsigned long high_limit ) ;
2018-12-24 23:57:17 +03:00
int inet_hashinfo2_init_mod ( struct inet_hashinfo * h ) ;
2005-08-10 07:08:09 +04:00
tcp: fix race condition when creating child sockets from syncookies
When the TCP stack is in SYN flood mode, the server child socket is
created from the SYN cookie received in a TCP packet with the ACK flag
set.
The child socket is created when the server receives the first TCP
packet with a valid SYN cookie from the client. Usually, this packet
corresponds to the final step of the TCP 3-way handshake, the ACK
packet. But is also possible to receive a valid SYN cookie from the
first TCP data packet sent by the client, and thus create a child socket
from that SYN cookie.
Since a client socket is ready to send data as soon as it receives the
SYN+ACK packet from the server, the client can send the ACK packet (sent
by the TCP stack code), and the first data packet (sent by the userspace
program) almost at the same time, and thus the server will equally
receive the two TCP packets with valid SYN cookies almost at the same
instant.
When such event happens, the TCP stack code has a race condition that
occurs between the momement a lookup is done to the established
connections hashtable to check for the existence of a connection for the
same client, and the moment that the child socket is added to the
established connections hashtable. As a consequence, this race condition
can lead to a situation where we add two child sockets to the
established connections hashtable and deliver two sockets to the
userspace program to the same client.
This patch fixes the race condition by checking if an existing child
socket exists for the same client when we are adding the second child
socket to the established connections socket. If an existing child
socket exists, we drop the packet and discard the second child socket
to the same client.
Signed-off-by: Ricardo Dias <rdias@singlestore.com>
Signed-off-by: Eric Dumazet <edumazet@google.com>
Link: https://lore.kernel.org/r/20201120111133.GA67501@rdias-suse-pc.lan
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2020-11-20 14:11:33 +03:00
bool inet_ehash_insert ( struct sock * sk , struct sock * osk , bool * found_dup_sk ) ;
bool inet_ehash_nolisten ( struct sock * sk , struct sock * osk ,
bool * found_dup_sk ) ;
2017-01-17 18:51:01 +03:00
int __inet_hash ( struct sock * sk , struct sock * osk ) ;
2016-02-10 19:50:35 +03:00
int inet_hash ( struct sock * sk ) ;
2013-09-21 21:22:41 +04:00
void inet_unhash ( struct sock * sk ) ;
2005-08-10 07:09:06 +04:00
2013-09-21 21:22:41 +04:00
struct sock * __inet_lookup_listener ( struct net * net ,
struct inet_hashinfo * hashinfo ,
2016-02-10 19:50:38 +03:00
struct sk_buff * skb , int doff ,
2013-09-21 21:22:41 +04:00
const __be32 saddr , const __be16 sport ,
const __be32 daddr ,
const unsigned short hnum ,
2017-08-07 18:44:17 +03:00
const int dif , const int sdif ) ;
2006-08-10 02:47:12 +04:00
2008-01-31 16:06:40 +03:00
static inline struct sock * inet_lookup_listener ( struct net * net ,
struct inet_hashinfo * hashinfo ,
2016-02-10 19:50:38 +03:00
struct sk_buff * skb , int doff ,
2013-01-22 13:50:24 +04:00
__be32 saddr , __be16 sport ,
2017-08-07 18:44:17 +03:00
__be32 daddr , __be16 dport , int dif , int sdif )
2006-08-10 02:47:12 +04:00
{
2016-02-10 19:50:38 +03:00
return __inet_lookup_listener ( net , hashinfo , skb , doff , saddr , sport ,
2017-08-07 18:44:17 +03:00
daddr , ntohs ( dport ) , dif , sdif ) ;
2006-08-10 02:47:12 +04:00
}
2005-08-10 07:09:30 +04:00
/* Socket demux engine toys. */
2006-09-28 05:43:07 +04:00
/* What happens here is ugly; there's a pair of adjacent fields in
struct inet_sock ; __be16 dport followed by __u16 num . We want to
search by pair , so we combine the keys into a single 32 bit value
and compare with 32 bit value read from & . . . - > dport . Let ' s at least
make sure that it ' s not mixed with anything else . . .
On 64 bit targets we combine comparisons with pair of adjacent __be32
fields in the same way .
*/
2005-08-10 07:09:30 +04:00
# ifdef __BIG_ENDIAN
# define INET_COMBINED_PORTS(__sport, __dport) \
2006-09-28 05:43:07 +04:00
( ( __force __portpair ) ( ( ( __force __u32 ) ( __be16 ) ( __sport ) < < 16 ) | ( __u32 ) ( __dport ) ) )
2005-08-10 07:09:30 +04:00
# else /* __LITTLE_ENDIAN */
# define INET_COMBINED_PORTS(__sport, __dport) \
2006-09-28 05:43:07 +04:00
( ( __force __portpair ) ( ( ( __u32 ) ( __dport ) < < 16 ) | ( __force __u32 ) ( __be16 ) ( __sport ) ) )
2005-08-10 07:09:30 +04:00
# endif
# ifdef __BIG_ENDIAN
# define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
2006-09-28 05:43:07 +04:00
const __addrpair __name = ( __force __addrpair ) ( \
( ( ( __force __u64 ) ( __be32 ) ( __saddr ) ) < < 32 ) | \
2014-05-14 07:30:07 +04:00
( ( __force __u64 ) ( __be32 ) ( __daddr ) ) )
2005-08-10 07:09:30 +04:00
# else /* __LITTLE_ENDIAN */
# define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
2006-09-28 05:43:07 +04:00
const __addrpair __name = ( __force __addrpair ) ( \
( ( ( __force __u64 ) ( __be32 ) ( __daddr ) ) < < 32 ) | \
2014-05-14 07:30:07 +04:00
( ( __force __u64 ) ( __be32 ) ( __saddr ) ) )
2005-08-10 07:09:30 +04:00
# endif /* __BIG_ENDIAN */
2022-05-12 19:56:01 +03:00
2022-05-13 21:55:50 +03:00
static inline bool inet_match ( struct net * net , const struct sock * sk ,
2022-05-12 19:56:01 +03:00
const __addrpair cookie , const __portpair ports ,
int dif , int sdif )
{
if ( ! net_eq ( sock_net ( sk ) , net ) | |
sk - > sk_portpair ! = ports | |
sk - > sk_addrpair ! = cookie )
return false ;
2022-07-25 21:14:42 +03:00
/* READ_ONCE() paired with WRITE_ONCE() in sock_bindtoindex_locked() */
return inet_sk_bound_dev_eq ( net , READ_ONCE ( sk - > sk_bound_dev_if ) , dif ,
sdif ) ;
2022-05-12 19:56:01 +03:00
}
2005-08-10 07:09:46 +04:00
2016-04-01 18:52:14 +03:00
/* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so we need
2005-08-10 07:09:46 +04:00
* not check it for lookups anymore , thanks Alexey . - DaveM
*/
2013-09-21 21:22:41 +04:00
struct sock * __inet_lookup_established ( struct net * net ,
struct inet_hashinfo * hashinfo ,
const __be32 saddr , const __be16 sport ,
const __be32 daddr , const u16 hnum ,
2017-08-07 18:44:17 +03:00
const int dif , const int sdif ) ;
2005-08-10 07:09:46 +04:00
2023-07-20 18:30:08 +03:00
typedef u32 ( inet_ehashfn_t ) ( const struct net * net ,
const __be32 laddr , const __u16 lport ,
const __be32 faddr , const __be16 fport ) ;
inet_ehashfn_t inet_ehashfn ;
INDIRECT_CALLABLE_DECLARE ( inet_ehashfn_t udp_ehashfn ) ;
2023-07-20 18:30:07 +03:00
struct sock * inet_lookup_reuseport ( struct net * net , struct sock * sk ,
struct sk_buff * skb , int doff ,
__be32 saddr , __be16 sport ,
2023-07-20 18:30:08 +03:00
__be32 daddr , unsigned short hnum ,
inet_ehashfn_t * ehashfn ) ;
2023-07-20 18:30:07 +03:00
2023-07-20 18:30:10 +03:00
struct sock * inet_lookup_run_sk_lookup ( struct net * net ,
int protocol ,
struct sk_buff * skb , int doff ,
__be32 saddr , __be16 sport ,
__be32 daddr , u16 hnum , const int dif ,
inet_ehashfn_t * ehashfn ) ;
2006-08-10 02:47:12 +04:00
static inline struct sock *
2008-01-31 16:06:40 +03:00
inet_lookup_established ( struct net * net , struct inet_hashinfo * hashinfo ,
2006-09-28 05:43:33 +04:00
const __be32 saddr , const __be16 sport ,
const __be32 daddr , const __be16 dport ,
2006-08-10 02:47:12 +04:00
const int dif )
{
2008-01-31 16:06:40 +03:00
return __inet_lookup_established ( net , hashinfo , saddr , sport , daddr ,
2017-08-07 18:44:17 +03:00
ntohs ( dport ) , dif , 0 ) ;
2006-08-10 02:47:12 +04:00
}
2008-01-31 16:06:40 +03:00
static inline struct sock * __inet_lookup ( struct net * net ,
struct inet_hashinfo * hashinfo ,
2016-02-10 19:50:38 +03:00
struct sk_buff * skb , int doff ,
2006-09-28 05:43:33 +04:00
const __be32 saddr , const __be16 sport ,
const __be32 daddr , const __be16 dport ,
2017-08-07 18:44:17 +03:00
const int dif , const int sdif ,
2016-04-01 18:52:17 +03:00
bool * refcounted )
2005-08-10 07:09:46 +04:00
{
2006-08-10 02:47:12 +04:00
u16 hnum = ntohs ( dport ) ;
2016-04-01 18:52:17 +03:00
struct sock * sk ;
2008-01-31 16:06:40 +03:00
2016-04-01 18:52:17 +03:00
sk = __inet_lookup_established ( net , hashinfo , saddr , sport ,
2017-08-07 18:44:17 +03:00
daddr , hnum , dif , sdif ) ;
2016-04-01 18:52:17 +03:00
* refcounted = true ;
if ( sk )
return sk ;
* refcounted = false ;
return __inet_lookup_listener ( net , hashinfo , skb , doff , saddr ,
2017-08-07 18:44:17 +03:00
sport , daddr , hnum , dif , sdif ) ;
2005-08-10 07:09:46 +04:00
}
2008-01-31 16:06:40 +03:00
static inline struct sock * inet_lookup ( struct net * net ,
struct inet_hashinfo * hashinfo ,
2016-02-10 19:50:38 +03:00
struct sk_buff * skb , int doff ,
2006-09-28 05:43:33 +04:00
const __be32 saddr , const __be16 sport ,
const __be32 daddr , const __be16 dport ,
2005-08-10 07:09:46 +04:00
const int dif )
{
struct sock * sk ;
2016-04-01 18:52:17 +03:00
bool refcounted ;
2005-08-10 07:09:46 +04:00
2016-02-10 19:50:38 +03:00
sk = __inet_lookup ( net , hashinfo , skb , doff , saddr , sport , daddr ,
2017-08-07 18:44:17 +03:00
dport , dif , 0 , & refcounted ) ;
2005-08-10 07:09:46 +04:00
2017-06-30 13:08:01 +03:00
if ( sk & & ! refcounted & & ! refcount_inc_not_zero ( & sk - > sk_refcnt ) )
2016-04-01 18:52:17 +03:00
sk = NULL ;
2005-08-10 07:09:46 +04:00
return sk ;
}
2005-12-14 10:25:31 +03:00
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
static inline
struct sock * inet_steal_sock ( struct net * net , struct sk_buff * skb , int doff ,
const __be32 saddr , const __be16 sport ,
const __be32 daddr , const __be16 dport ,
bool * refcounted , inet_ehashfn_t * ehashfn )
{
struct sock * sk , * reuse_sk ;
bool prefetched ;
sk = skb_steal_sock ( skb , refcounted , & prefetched ) ;
if ( ! sk )
return NULL ;
2023-08-15 11:53:41 +03:00
if ( ! prefetched | | ! sk_fullsock ( sk ) )
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
return sk ;
if ( sk - > sk_protocol = = IPPROTO_TCP ) {
if ( sk - > sk_state ! = TCP_LISTEN )
return sk ;
} else if ( sk - > sk_protocol = = IPPROTO_UDP ) {
if ( sk - > sk_state ! = TCP_CLOSE )
return sk ;
} else {
return sk ;
}
reuse_sk = inet_lookup_reuseport ( net , sk , skb , doff ,
saddr , sport , daddr , ntohs ( dport ) ,
ehashfn ) ;
if ( ! reuse_sk )
return sk ;
/* We've chosen a new reuseport sock which is never refcounted. This
* implies that sk also isn ' t refcounted .
*/
WARN_ON_ONCE ( * refcounted ) ;
return reuse_sk ;
}
2008-10-07 22:41:57 +04:00
static inline struct sock * __inet_lookup_skb ( struct inet_hashinfo * hashinfo ,
struct sk_buff * skb ,
2016-02-10 19:50:38 +03:00
int doff ,
2008-10-07 22:41:57 +04:00
const __be16 sport ,
2016-04-01 18:52:17 +03:00
const __be16 dport ,
2017-08-07 18:44:17 +03:00
const int sdif ,
2016-04-01 18:52:17 +03:00
bool * refcounted )
2008-10-07 22:41:57 +04:00
{
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
struct net * net = dev_net ( skb_dst ( skb ) - > dev ) ;
2008-10-07 22:41:57 +04:00
const struct iphdr * iph = ip_hdr ( skb ) ;
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
struct sock * sk ;
2008-10-07 22:41:57 +04:00
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
sk = inet_steal_sock ( net , skb , doff , iph - > saddr , sport , iph - > daddr , dport ,
refcounted , inet_ehashfn ) ;
if ( IS_ERR ( sk ) )
return NULL ;
2012-06-20 08:22:05 +04:00
if ( sk )
2008-10-07 23:41:01 +04:00
return sk ;
2016-04-01 18:52:17 +03:00
bpf, net: Support SO_REUSEPORT sockets with bpf_sk_assign
Currently the bpf_sk_assign helper in tc BPF context refuses SO_REUSEPORT
sockets. This means we can't use the helper to steer traffic to Envoy,
which configures SO_REUSEPORT on its sockets. In turn, we're blocked
from removing TPROXY from our setup.
The reason that bpf_sk_assign refuses such sockets is that the
bpf_sk_lookup helpers don't execute SK_REUSEPORT programs. Instead,
one of the reuseport sockets is selected by hash. This could cause
dispatch to the "wrong" socket:
sk = bpf_sk_lookup_tcp(...) // select SO_REUSEPORT by hash
bpf_sk_assign(skb, sk) // SK_REUSEPORT wasn't executed
Fixing this isn't as simple as invoking SK_REUSEPORT from the lookup
helpers unfortunately. In the tc context, L2 headers are at the start
of the skb, while SK_REUSEPORT expects L3 headers instead.
Instead, we execute the SK_REUSEPORT program when the assigned socket
is pulled out of the skb, further up the stack. This creates some
trickiness with regards to refcounting as bpf_sk_assign will put both
refcounted and RCU freed sockets in skb->sk. reuseport sockets are RCU
freed. We can infer that the sk_assigned socket is RCU freed if the
reuseport lookup succeeds, but convincing yourself of this fact isn't
straight forward. Therefore we defensively check refcounting on the
sk_assign sock even though it's probably not required in practice.
Fixes: 8e368dc72e86 ("bpf: Fix use of sk->sk_reuseport from sk_assign")
Fixes: cf7fbe660f2d ("bpf: Add socket assign support")
Co-developed-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Cc: Joe Stringer <joe@cilium.io>
Link: https://lore.kernel.org/bpf/CACAyw98+qycmpQzKupquhkxbvWK4OFyDuuLMBNROnfWMZxUWeA@mail.gmail.com/
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Signed-off-by: Lorenz Bauer <lmb@isovalent.com>
Link: https://lore.kernel.org/r/20230720-so-reuseport-v6-7-7021b683cdae@isovalent.com
Signed-off-by: Martin KaFai Lau <martin.lau@kernel.org>
2023-07-20 18:30:11 +03:00
return __inet_lookup ( net , hashinfo , skb ,
2016-04-01 18:52:17 +03:00
doff , iph - > saddr , sport ,
2017-08-07 18:44:17 +03:00
iph - > daddr , dport , inet_iif ( skb ) , sdif ,
2016-04-01 18:52:17 +03:00
refcounted ) ;
2008-10-07 22:41:57 +04:00
}
2015-03-19 00:05:35 +03:00
static inline void sk_daddr_set ( struct sock * sk , __be32 addr )
{
sk - > sk_daddr = addr ; /* alias of inet_daddr */
# if IS_ENABLED(CONFIG_IPV6)
ipv6_addr_set_v4mapped ( addr , & sk - > sk_v6_daddr ) ;
# endif
}
static inline void sk_rcv_saddr_set ( struct sock * sk , __be32 addr )
{
sk - > sk_rcv_saddr = addr ; /* alias of inet_rcv_saddr */
# if IS_ENABLED(CONFIG_IPV6)
ipv6_addr_set_v4mapped ( addr , & sk - > sk_v6_rcv_saddr ) ;
# endif
}
2015-03-19 00:05:34 +03:00
2013-09-21 21:22:41 +04:00
int __inet_hash_connect ( struct inet_timewait_death_row * death_row ,
2022-05-02 11:46:08 +03:00
struct sock * sk , u64 port_offset ,
2013-09-21 21:22:41 +04:00
int ( * check_established ) ( struct inet_timewait_death_row * ,
struct sock * , __u16 ,
2015-03-19 00:05:37 +03:00
struct inet_timewait_sock * * ) ) ;
2009-12-04 06:46:54 +03:00
2013-09-21 21:22:41 +04:00
int inet_hash_connect ( struct inet_timewait_death_row * death_row ,
struct sock * sk ) ;
2005-08-10 06:59:20 +04:00
# endif /* _INET_HASHTABLES_H */
