2005-08-09 20:59:20 -06: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
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _INET_HASHTABLES_H
|
|
|
|
#define _INET_HASHTABLES_H
|
|
|
|
|
2005-08-09 21:09:30 -06:00
|
|
|
|
2005-08-09 21:07:13 -06:00
|
|
|
#include <linux/interrupt.h>
|
2008-10-07 12:41:57 -06:00
|
|
|
#include <linux/ip.h>
|
2005-08-09 21:09:06 -06:00
|
|
|
#include <linux/ipv6.h>
|
2005-08-09 21:00:51 -06:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/slab.h>
|
2005-08-09 21:09:06 -06:00
|
|
|
#include <linux/socket.h>
|
2005-08-09 21:00:51 -06:00
|
|
|
#include <linux/spinlock.h>
|
2005-08-09 20:59:20 -06:00
|
|
|
#include <linux/types.h>
|
2005-08-09 21:08:09 -06:00
|
|
|
#include <linux/wait.h>
|
2007-11-10 22:18:39 -07:00
|
|
|
#include <linux/vmalloc.h>
|
2005-08-09 20:59:20 -06:00
|
|
|
|
2005-08-09 21:10:42 -06:00
|
|
|
#include <net/inet_connection_sock.h>
|
2005-12-26 21:43:12 -07:00
|
|
|
#include <net/inet_sock.h>
|
2005-08-09 21:07:13 -06:00
|
|
|
#include <net/sock.h>
|
2008-10-07 12:41:57 -06:00
|
|
|
#include <net/route.h>
|
2005-08-09 21:08:28 -06:00
|
|
|
#include <net/tcp_states.h>
|
2008-06-16 18:14:11 -06:00
|
|
|
#include <net/netns/hash.h>
|
2005-08-09 21:07:13 -06:00
|
|
|
|
2011-07-26 17:09:06 -06:00
|
|
|
#include <linux/atomic.h>
|
2005-08-09 21:09:46 -06:00
|
|
|
#include <asm/byteorder.h>
|
2005-08-09 21:08:09 -06:00
|
|
|
|
2005-08-09 21:00:51 -06: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 01:22:02 -06:00
|
|
|
* The 'e' prefix stands for Establish, but we really put all sockets
|
|
|
|
* but LISTEN ones.
|
2005-08-09 21:00:51 -06:00
|
|
|
*/
|
|
|
|
struct inet_ehash_bucket {
|
2008-11-16 20:40:17 -07:00
|
|
|
struct hlist_nulls_head chain;
|
2005-10-04 16:55:51 -06:00
|
|
|
};
|
2005-08-09 21:00:51 -06: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
|
|
|
|
*/
|
|
|
|
struct inet_bind_bucket {
|
2008-11-12 01:54:20 -07:00
|
|
|
#ifdef CONFIG_NET_NS
|
2008-01-31 06:05:50 -07:00
|
|
|
struct net *ib_net;
|
2008-11-12 01:54:20 -07:00
|
|
|
#endif
|
2005-08-09 21:00:51 -06:00
|
|
|
unsigned short port;
|
2013-01-22 02:50:24 -07:00
|
|
|
signed char fastreuse;
|
|
|
|
signed char fastreuseport;
|
|
|
|
kuid_t fastuid;
|
inet: Allowing more than 64k connections and heavily optimize bind(0) time.
With simple extension to the binding mechanism, which allows to bind more
than 64k sockets (or smaller amount, depending on sysctl parameters),
we have to traverse the whole bind hash table to find out empty bucket.
And while it is not a problem for example for 32k connections, bind()
completion time grows exponentially (since after each successful binding
we have to traverse one bucket more to find empty one) even if we start
each time from random offset inside the hash table.
So, when hash table is full, and we want to add another socket, we have
to traverse the whole table no matter what, so effectivelly this will be
the worst case performance and it will be constant.
Attached picture shows bind() time depending on number of already bound
sockets.
Green area corresponds to the usual binding to zero port process, which
turns on kernel port selection as described above. Red area is the bind
process, when number of reuse-bound sockets is not limited by 64k (or
sysctl parameters). The same exponential growth (hidden by the green
area) before number of ports reaches sysctl limit.
At this time bind hash table has exactly one reuse-enbaled socket in a
bucket, but it is possible that they have different addresses. Actually
kernel selects the first port to try randomly, so at the beginning bind
will take roughly constant time, but with time number of port to check
after random start will increase. And that will have exponential growth,
but because of above random selection, not every next port selection
will necessary take longer time than previous. So we have to consider
the area below in the graph (if you could zoom it, you could find, that
there are many different times placed there), so area can hide another.
Blue area corresponds to the port selection optimization.
This is rather simple design approach: hashtable now maintains (unprecise
and racely updated) number of currently bound sockets, and when number
of such sockets becomes greater than predefined value (I use maximum
port range defined by sysctls), we stop traversing the whole bind hash
table and just stop at first matching bucket after random start. Above
limit roughly corresponds to the case, when bind hash table is full and
we turned on mechanism of allowing to bind more reuse-enabled sockets,
so it does not change behaviour of other sockets.
Signed-off-by: Evgeniy Polyakov <zbr@ioremap.net>
Tested-by: Denys Fedoryschenko <denys@visp.net.lb>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-01-19 17:46:02 -07:00
|
|
|
int num_owners;
|
2005-08-09 21:00:51 -06:00
|
|
|
struct hlist_node node;
|
|
|
|
struct hlist_head owners;
|
|
|
|
};
|
|
|
|
|
2008-11-12 01:54:20 -07:00
|
|
|
static inline struct net *ib_net(struct inet_bind_bucket *ib)
|
|
|
|
{
|
|
|
|
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-27 18:06:00 -07:00
|
|
|
#define inet_bind_bucket_for_each(tb, head) \
|
|
|
|
hlist_for_each_entry(tb, head, node)
|
2005-08-09 21:00:51 -06:00
|
|
|
|
|
|
|
struct inet_bind_hashbucket {
|
|
|
|
spinlock_t lock;
|
|
|
|
struct hlist_head chain;
|
|
|
|
};
|
|
|
|
|
2008-11-23 18:22:55 -07:00
|
|
|
/*
|
|
|
|
* Sockets can be hashed in established or listening table
|
|
|
|
* We must use different 'nulls' end-of-chain value for listening
|
|
|
|
* hash table, or we might find a socket that was closed and
|
|
|
|
* reallocated/inserted into established hash table
|
|
|
|
*/
|
|
|
|
#define LISTENING_NULLS_BASE (1U << 29)
|
2008-11-20 01:40:07 -07:00
|
|
|
struct inet_listen_hashbucket {
|
|
|
|
spinlock_t lock;
|
2008-11-23 18:22:55 -07:00
|
|
|
struct hlist_nulls_head head;
|
2008-11-20 01:40:07 -07:00
|
|
|
};
|
|
|
|
|
2005-08-09 21:00:51 -06: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-20 21:39:09 -07:00
|
|
|
spinlock_t *ehash_locks;
|
2009-10-08 18:16:19 -06:00
|
|
|
unsigned int ehash_mask;
|
2007-11-07 03:40:20 -07:00
|
|
|
unsigned int ehash_locks_mask;
|
2005-08-09 21:00:51 -06: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.
|
|
|
|
*/
|
|
|
|
struct inet_bind_hashbucket *bhash;
|
|
|
|
|
2007-10-09 02:59:42 -06:00
|
|
|
unsigned int bhash_size;
|
2009-02-01 13:31:33 -07:00
|
|
|
/* 4 bytes hole on 64 bit */
|
2005-08-09 21:00:51 -06:00
|
|
|
|
2008-11-20 01:40:07 -07:00
|
|
|
struct kmem_cache *bind_bucket_cachep;
|
2005-08-09 21:00:51 -06:00
|
|
|
|
|
|
|
/* All the above members are written once at bootup and
|
|
|
|
* never written again _or_ are predominantly read-access.
|
|
|
|
*
|
|
|
|
* Now align to a new cache line as all the following members
|
2008-11-20 01:40:07 -07:00
|
|
|
* might be often dirty.
|
|
|
|
*/
|
|
|
|
/* All sockets in TCP_LISTEN state will be in here. This is the only
|
|
|
|
* table where wildcard'd TCP sockets can exist. Hash function here
|
|
|
|
* is just local port number.
|
2005-08-09 21:00:51 -06:00
|
|
|
*/
|
2008-11-20 01:40:07 -07:00
|
|
|
struct inet_listen_hashbucket listening_hash[INET_LHTABLE_SIZE]
|
|
|
|
____cacheline_aligned_in_smp;
|
|
|
|
|
2009-02-01 13:31:33 -07:00
|
|
|
atomic_t bsockets;
|
2005-08-09 21:00:51 -06:00
|
|
|
};
|
|
|
|
|
[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-03 15:13:38 -06:00
|
|
|
static inline struct inet_ehash_bucket *inet_ehash_bucket(
|
|
|
|
struct inet_hashinfo *hashinfo,
|
|
|
|
unsigned int hash)
|
|
|
|
{
|
2009-10-08 18:16:19 -06:00
|
|
|
return &hashinfo->ehash[hash & hashinfo->ehash_mask];
|
2005-08-09 20:59:20 -06:00
|
|
|
}
|
|
|
|
|
2008-11-20 21:39:09 -07:00
|
|
|
static inline spinlock_t *inet_ehash_lockp(
|
2007-11-07 03:40:20 -07:00
|
|
|
struct inet_hashinfo *hashinfo,
|
|
|
|
unsigned int hash)
|
|
|
|
{
|
|
|
|
return &hashinfo->ehash_locks[hash & hashinfo->ehash_locks_mask];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int inet_ehash_locks_alloc(struct inet_hashinfo *hashinfo)
|
|
|
|
{
|
|
|
|
unsigned int i, size = 256;
|
|
|
|
#if defined(CONFIG_PROVE_LOCKING)
|
|
|
|
unsigned int nr_pcpus = 2;
|
|
|
|
#else
|
|
|
|
unsigned int nr_pcpus = num_possible_cpus();
|
|
|
|
#endif
|
|
|
|
if (nr_pcpus >= 4)
|
|
|
|
size = 512;
|
|
|
|
if (nr_pcpus >= 8)
|
|
|
|
size = 1024;
|
|
|
|
if (nr_pcpus >= 16)
|
|
|
|
size = 2048;
|
|
|
|
if (nr_pcpus >= 32)
|
|
|
|
size = 4096;
|
2009-01-27 18:45:10 -07:00
|
|
|
if (sizeof(spinlock_t) != 0) {
|
2007-11-07 03:40:20 -07:00
|
|
|
#ifdef CONFIG_NUMA
|
2008-11-20 21:39:09 -07:00
|
|
|
if (size * sizeof(spinlock_t) > PAGE_SIZE)
|
|
|
|
hashinfo->ehash_locks = vmalloc(size * sizeof(spinlock_t));
|
2007-11-07 03:40:20 -07:00
|
|
|
else
|
|
|
|
#endif
|
2008-11-20 21:39:09 -07:00
|
|
|
hashinfo->ehash_locks = kmalloc(size * sizeof(spinlock_t),
|
2007-11-07 03:40:20 -07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hashinfo->ehash_locks)
|
|
|
|
return ENOMEM;
|
|
|
|
for (i = 0; i < size; i++)
|
2008-11-20 21:39:09 -07:00
|
|
|
spin_lock_init(&hashinfo->ehash_locks[i]);
|
2007-11-07 03:40:20 -07:00
|
|
|
}
|
|
|
|
hashinfo->ehash_locks_mask = size - 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void inet_ehash_locks_free(struct inet_hashinfo *hashinfo)
|
|
|
|
{
|
|
|
|
if (hashinfo->ehash_locks) {
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
unsigned int size = (hashinfo->ehash_locks_mask + 1) *
|
2008-11-20 21:39:09 -07:00
|
|
|
sizeof(spinlock_t);
|
2007-11-07 03:40:20 -07:00
|
|
|
if (size > PAGE_SIZE)
|
|
|
|
vfree(hashinfo->ehash_locks);
|
|
|
|
else
|
|
|
|
#endif
|
2007-11-26 05:23:31 -07:00
|
|
|
kfree(hashinfo->ehash_locks);
|
2007-11-07 03:40:20 -07:00
|
|
|
hashinfo->ehash_locks = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
struct inet_bind_bucket *
|
|
|
|
inet_bind_bucket_create(struct kmem_cache *cachep, struct net *net,
|
|
|
|
struct inet_bind_hashbucket *head,
|
|
|
|
const unsigned short snum);
|
|
|
|
void inet_bind_bucket_destroy(struct kmem_cache *cachep,
|
|
|
|
struct inet_bind_bucket *tb);
|
|
|
|
|
|
|
|
static inline int inet_bhashfn(struct net *net, const __u16 lport,
|
|
|
|
const int bhash_size)
|
2005-08-09 21:00:51 -06:00
|
|
|
{
|
2008-06-16 18:14:11 -06:00
|
|
|
return (lport + net_hash_mix(net)) & (bhash_size - 1);
|
2005-08-09 21:00:51 -06:00
|
|
|
}
|
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
|
|
|
|
const unsigned short snum);
|
2005-08-09 21:07:13 -06:00
|
|
|
|
2005-08-09 21:00:51 -06:00
|
|
|
/* These can have wildcards, don't try too hard. */
|
2008-06-16 18:13:08 -06:00
|
|
|
static inline int inet_lhashfn(struct net *net, const unsigned short num)
|
2005-08-09 21:00:51 -06:00
|
|
|
{
|
2008-06-16 18:14:11 -06:00
|
|
|
return (num + net_hash_mix(net)) & (INET_LHTABLE_SIZE - 1);
|
2005-08-09 21:00:51 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int inet_sk_listen_hashfn(const struct sock *sk)
|
|
|
|
{
|
2009-10-15 00:30:45 -06:00
|
|
|
return inet_lhashfn(sock_net(sk), inet_sk(sk)->inet_num);
|
2005-08-09 21:00:51 -06:00
|
|
|
}
|
|
|
|
|
2005-08-09 21:07:13 -06:00
|
|
|
/* Caller must disable local BH processing. */
|
2013-09-21 11:22:41 -06:00
|
|
|
int __inet_inherit_port(struct sock *sk, struct sock *child);
|
2005-08-09 21:07:13 -06:00
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
void inet_put_port(struct sock *sk);
|
2005-08-09 21:07:13 -06:00
|
|
|
|
2008-11-20 01:40:07 -07:00
|
|
|
void inet_hashinfo_init(struct inet_hashinfo *h);
|
2005-08-09 21:08:09 -06:00
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
int __inet_hash_nolisten(struct sock *sk, struct inet_timewait_sock *tw);
|
|
|
|
void inet_hash(struct sock *sk);
|
|
|
|
void inet_unhash(struct sock *sk);
|
2005-08-09 21:09:06 -06:00
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
struct sock *__inet_lookup_listener(struct net *net,
|
|
|
|
struct inet_hashinfo *hashinfo,
|
|
|
|
const __be32 saddr, const __be16 sport,
|
|
|
|
const __be32 daddr,
|
|
|
|
const unsigned short hnum,
|
|
|
|
const int dif);
|
2006-08-09 16:47:12 -06:00
|
|
|
|
2008-01-31 06:06:40 -07:00
|
|
|
static inline struct sock *inet_lookup_listener(struct net *net,
|
|
|
|
struct inet_hashinfo *hashinfo,
|
2013-01-22 02:50:24 -07:00
|
|
|
__be32 saddr, __be16 sport,
|
2008-01-31 06:06:40 -07:00
|
|
|
__be32 daddr, __be16 dport, int dif)
|
2006-08-09 16:47:12 -06:00
|
|
|
{
|
2013-01-22 02:50:24 -07:00
|
|
|
return __inet_lookup_listener(net, hashinfo, saddr, sport,
|
|
|
|
daddr, ntohs(dport), dif);
|
2006-08-09 16:47:12 -06:00
|
|
|
}
|
2005-08-09 21:09:30 -06:00
|
|
|
|
|
|
|
/* Socket demux engine toys. */
|
2006-09-27 19:43:07 -06: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 32bit value
|
|
|
|
and compare with 32bit value read from &...->dport. Let's at least
|
|
|
|
make sure that it's not mixed with anything else...
|
|
|
|
On 64bit targets we combine comparisons with pair of adjacent __be32
|
|
|
|
fields in the same way.
|
|
|
|
*/
|
2005-08-09 21:09:30 -06:00
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
#define INET_COMBINED_PORTS(__sport, __dport) \
|
2006-09-27 19:43:07 -06:00
|
|
|
((__force __portpair)(((__force __u32)(__be16)(__sport) << 16) | (__u32)(__dport)))
|
2005-08-09 21:09:30 -06:00
|
|
|
#else /* __LITTLE_ENDIAN */
|
|
|
|
#define INET_COMBINED_PORTS(__sport, __dport) \
|
2006-09-27 19:43:07 -06:00
|
|
|
((__force __portpair)(((__u32)(__dport) << 16) | (__force __u32)(__be16)(__sport)))
|
2005-08-09 21:09:30 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if (BITS_PER_LONG == 64)
|
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
#define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
|
2006-09-27 19:43:07 -06:00
|
|
|
const __addrpair __name = (__force __addrpair) ( \
|
|
|
|
(((__force __u64)(__be32)(__saddr)) << 32) | \
|
|
|
|
((__force __u64)(__be32)(__daddr)));
|
2005-08-09 21:09:30 -06:00
|
|
|
#else /* __LITTLE_ENDIAN */
|
|
|
|
#define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
|
2006-09-27 19:43:07 -06:00
|
|
|
const __addrpair __name = (__force __addrpair) ( \
|
|
|
|
(((__force __u64)(__be32)(__daddr)) << 32) | \
|
|
|
|
((__force __u64)(__be32)(__saddr)));
|
2005-08-09 21:09:30 -06:00
|
|
|
#endif /* __BIG_ENDIAN */
|
2012-11-30 02:49:27 -07:00
|
|
|
#define INET_MATCH(__sk, __net, __cookie, __saddr, __daddr, __ports, __dif) \
|
inet: consolidate INET_TW_MATCH
TCP listener refactoring, part 2 :
We can use a generic lookup, sockets being in whatever state, if
we are sure all relevant fields are at the same place in all socket
types (ESTABLISH, TIME_WAIT, SYN_RECV)
This patch removes these macros :
inet_addrpair, inet_addrpair, tw_addrpair, tw_portpair
And adds :
sk_portpair, sk_addrpair, sk_daddr, sk_rcv_saddr
Then, INET_TW_MATCH() is really the same than INET_MATCH()
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-02 05:29:50 -06:00
|
|
|
(((__sk)->sk_portpair == (__ports)) && \
|
|
|
|
((__sk)->sk_addrpair == (__cookie)) && \
|
2012-11-30 02:49:27 -07:00
|
|
|
(!(__sk)->sk_bound_dev_if || \
|
|
|
|
((__sk)->sk_bound_dev_if == (__dif))) && \
|
|
|
|
net_eq(sock_net(__sk), (__net)))
|
2005-08-09 21:09:30 -06:00
|
|
|
#else /* 32-bit arch */
|
|
|
|
#define INET_ADDR_COOKIE(__name, __saddr, __daddr)
|
2012-11-30 02:49:27 -07:00
|
|
|
#define INET_MATCH(__sk, __net, __cookie, __saddr, __daddr, __ports, __dif) \
|
inet: consolidate INET_TW_MATCH
TCP listener refactoring, part 2 :
We can use a generic lookup, sockets being in whatever state, if
we are sure all relevant fields are at the same place in all socket
types (ESTABLISH, TIME_WAIT, SYN_RECV)
This patch removes these macros :
inet_addrpair, inet_addrpair, tw_addrpair, tw_portpair
And adds :
sk_portpair, sk_addrpair, sk_daddr, sk_rcv_saddr
Then, INET_TW_MATCH() is really the same than INET_MATCH()
Signed-off-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-10-02 05:29:50 -06:00
|
|
|
(((__sk)->sk_portpair == (__ports)) && \
|
|
|
|
((__sk)->sk_daddr == (__saddr)) && \
|
|
|
|
((__sk)->sk_rcv_saddr == (__daddr)) && \
|
2012-11-30 02:49:27 -07:00
|
|
|
(!(__sk)->sk_bound_dev_if || \
|
|
|
|
((__sk)->sk_bound_dev_if == (__dif))) && \
|
|
|
|
net_eq(sock_net(__sk), (__net)))
|
2005-08-09 21:09:30 -06:00
|
|
|
#endif /* 64-bit arch */
|
2005-08-09 21:09:46 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so we need
|
|
|
|
* not check it for lookups anymore, thanks Alexey. -DaveM
|
|
|
|
*
|
|
|
|
* Local BH must be disabled here.
|
|
|
|
*/
|
2013-09-21 11:22:41 -06: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,
|
|
|
|
const int dif);
|
2005-08-09 21:09:46 -06:00
|
|
|
|
2006-08-09 16:47:12 -06:00
|
|
|
static inline struct sock *
|
2008-01-31 06:06:40 -07:00
|
|
|
inet_lookup_established(struct net *net, struct inet_hashinfo *hashinfo,
|
2006-09-27 19:43:33 -06:00
|
|
|
const __be32 saddr, const __be16 sport,
|
|
|
|
const __be32 daddr, const __be16 dport,
|
2006-08-09 16:47:12 -06:00
|
|
|
const int dif)
|
|
|
|
{
|
2008-01-31 06:06:40 -07:00
|
|
|
return __inet_lookup_established(net, hashinfo, saddr, sport, daddr,
|
2006-08-09 16:47:12 -06:00
|
|
|
ntohs(dport), dif);
|
|
|
|
}
|
|
|
|
|
2008-01-31 06:06:40 -07:00
|
|
|
static inline struct sock *__inet_lookup(struct net *net,
|
|
|
|
struct inet_hashinfo *hashinfo,
|
2006-09-27 19:43:33 -06:00
|
|
|
const __be32 saddr, const __be16 sport,
|
|
|
|
const __be32 daddr, const __be16 dport,
|
2005-08-09 21:09:46 -06:00
|
|
|
const int dif)
|
|
|
|
{
|
2006-08-09 16:47:12 -06:00
|
|
|
u16 hnum = ntohs(dport);
|
2008-01-31 06:06:40 -07:00
|
|
|
struct sock *sk = __inet_lookup_established(net, hashinfo,
|
|
|
|
saddr, sport, daddr, hnum, dif);
|
|
|
|
|
2013-01-22 02:50:24 -07:00
|
|
|
return sk ? : __inet_lookup_listener(net, hashinfo, saddr, sport,
|
|
|
|
daddr, hnum, dif);
|
2005-08-09 21:09:46 -06:00
|
|
|
}
|
|
|
|
|
2008-01-31 06:06:40 -07:00
|
|
|
static inline struct sock *inet_lookup(struct net *net,
|
|
|
|
struct inet_hashinfo *hashinfo,
|
2006-09-27 19:43:33 -06:00
|
|
|
const __be32 saddr, const __be16 sport,
|
|
|
|
const __be32 daddr, const __be16 dport,
|
2005-08-09 21:09:46 -06:00
|
|
|
const int dif)
|
|
|
|
{
|
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
local_bh_disable();
|
2008-01-31 06:06:40 -07:00
|
|
|
sk = __inet_lookup(net, hashinfo, saddr, sport, daddr, dport, dif);
|
2005-08-09 21:09:46 -06:00
|
|
|
local_bh_enable();
|
|
|
|
|
|
|
|
return sk;
|
|
|
|
}
|
2005-12-14 00:25:31 -07:00
|
|
|
|
2008-10-07 12:41:57 -06:00
|
|
|
static inline struct sock *__inet_lookup_skb(struct inet_hashinfo *hashinfo,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
const __be16 sport,
|
|
|
|
const __be16 dport)
|
|
|
|
{
|
2012-06-19 22:22:05 -06:00
|
|
|
struct sock *sk = skb_steal_sock(skb);
|
2008-10-07 12:41:57 -06:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
|
|
|
|
2012-06-19 22:22:05 -06:00
|
|
|
if (sk)
|
2008-10-07 13:41:01 -06:00
|
|
|
return sk;
|
|
|
|
else
|
2009-06-01 23:19:30 -06:00
|
|
|
return __inet_lookup(dev_net(skb_dst(skb)->dev), hashinfo,
|
2008-10-07 13:41:01 -06:00
|
|
|
iph->saddr, sport,
|
|
|
|
iph->daddr, dport, inet_iif(skb));
|
2008-10-07 12:41:57 -06:00
|
|
|
}
|
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
int __inet_hash_connect(struct inet_timewait_death_row *death_row,
|
|
|
|
struct sock *sk, u32 port_offset,
|
|
|
|
int (*check_established)(struct inet_timewait_death_row *,
|
|
|
|
struct sock *, __u16,
|
|
|
|
struct inet_timewait_sock **),
|
|
|
|
int (*hash)(struct sock *sk,
|
|
|
|
struct inet_timewait_sock *twp));
|
2009-12-03 20:46:54 -07:00
|
|
|
|
2013-09-21 11:22:41 -06:00
|
|
|
int inet_hash_connect(struct inet_timewait_death_row *death_row,
|
|
|
|
struct sock *sk);
|
2005-08-09 20:59:20 -06:00
|
|
|
#endif /* _INET_HASHTABLES_H */
|