[INET]: Move the TCP hashtable functions/structs to inet_hashtables.[ch] (77d8bf9c) · Commits · 方亚芬 / raspberrypi_linux

include/net/inet_common.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,11 @@ extern struct proto_ops inet_dgram_ops;
		* INET4 prototypes used by INET6
		*/

		struct msghdr;
		struct sock;
		struct sockaddr;
		struct socket;

		extern void inet_remove_sock(struct sock *sk1);
		extern void inet_put_sock(unsigned short num,
		struct sock *sk);

include/net/inet_hashtables.h

+122 −0

Original line number	Diff line number	Diff line
		@@ -14,8 +14,107 @@
		#ifndef _INET_HASHTABLES_H
		#define _INET_HASHTABLES_H

		#include <linux/ip.h>
		#include <linux/list.h>
		#include <linux/slab.h>
		#include <linux/spinlock.h>
		#include <linux/types.h>

		/* This is for all connections with a full identity, no wildcards.
		* New scheme, half the table is for TIME_WAIT, the other half is
		* for the rest. I'll experiment with dynamic table growth later.
		*/
		struct inet_ehash_bucket {
		rwlock_t lock;
		struct hlist_head chain;
		} __attribute__((__aligned__(8)));

		/* 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 {
		unsigned short port;
		signed short fastreuse;
		struct hlist_node node;
		struct hlist_head owners;
		};

		#define inet_bind_bucket_for_each(tb, node, head) \
		hlist_for_each_entry(tb, node, head, node)

		struct inet_bind_hashbucket {
		spinlock_t lock;
		struct hlist_head chain;
		};

		/* 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
		*
		* First half of the table is for sockets not in TIME_WAIT, second half
		* is for TIME_WAIT sockets only.
		*/
		struct inet_ehash_bucket *ehash;

		/* 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;

		int bhash_size;
		int ehash_size;

		/* 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.
		*/
		struct hlist_head listening_hash[INET_LHTABLE_SIZE];

		/* 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
		* are often dirty.
		*/
		rwlock_t lhash_lock ____cacheline_aligned;
		atomic_t lhash_users;
		wait_queue_head_t lhash_wait;
		spinlock_t portalloc_lock;
		};

		static inline int inet_ehashfn(const __u32 laddr, const __u16 lport,
		const __u32 faddr, const __u16 fport,
		const int ehash_size)
		@@ -37,4 +136,27 @@ static inline int inet_sk_ehashfn(const struct sock *sk, const int ehash_size)
		return inet_ehashfn(laddr, lport, faddr, fport, ehash_size);
		}

		extern struct inet_bind_bucket *
		inet_bind_bucket_create(kmem_cache_t *cachep,
		struct inet_bind_hashbucket *head,
		const unsigned short snum);
		extern void inet_bind_bucket_destroy(kmem_cache_t *cachep,
		struct inet_bind_bucket *tb);

		static inline int inet_bhashfn(const __u16 lport, const int bhash_size)
		{
		return lport & (bhash_size - 1);
		}

		/* These can have wildcards, don't try too hard. */
		static inline int inet_lhashfn(const unsigned short num)
		{
		return num & (INET_LHTABLE_SIZE - 1);
		}

		static inline int inet_sk_listen_hashfn(const struct sock *sk)
		{
		return inet_lhashfn(inet_sk(sk)->num);
		}

		#endif /* _INET_HASHTABLES_H */

include/net/tcp.h

+2 −118

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@
		#include <linux/slab.h>
		#include <linux/cache.h>
		#include <linux/percpu.h>
		#include <net/inet_hashtables.h>
		#include <net/checksum.h>
		#include <net/request_sock.h>
		#include <net/sock.h>
		@@ -40,101 +41,6 @@
		#endif
		#include <linux/seq_file.h>

		/* This is for all connections with a full identity, no wildcards.
		* New scheme, half the table is for TIME_WAIT, the other half is
		* for the rest. I'll experiment with dynamic table growth later.
		*/
		struct inet_ehash_bucket {
		rwlock_t lock;
		struct hlist_head chain;
		} __attribute__((__aligned__(8)));

		/* This is for listening sockets, thus all sockets which possess wildcards. */
		#define INET_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */

		/* 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 {
		unsigned short port;
		signed short fastreuse;
		struct hlist_node node;
		struct hlist_head owners;
		};

		#define inet_bind_bucket_for_each(tb, node, head) \
		hlist_for_each_entry(tb, node, head, node)

		struct inet_bind_hashbucket {
		spinlock_t lock;
		struct hlist_head chain;
		};

		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
		*
		* First half of the table is for sockets not in TIME_WAIT, second half
		* is for TIME_WAIT sockets only.
		*/
		struct inet_ehash_bucket *ehash;

		/* 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;

		int bhash_size;
		int ehash_size;

		/* 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.
		*/
		struct hlist_head listening_hash[INET_LHTABLE_SIZE];

		/* 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
		* are often dirty.
		*/
		rwlock_t lhash_lock ____cacheline_aligned;
		atomic_t lhash_users;
		wait_queue_head_t lhash_wait;
		spinlock_t portalloc_lock;
		};

		extern struct inet_hashinfo tcp_hashinfo;
		#define tcp_ehash (tcp_hashinfo.ehash)
		#define tcp_bhash (tcp_hashinfo.bhash)
		@@ -147,19 +53,8 @@ extern struct inet_hashinfo tcp_hashinfo;
		#define tcp_portalloc_lock (tcp_hashinfo.portalloc_lock)

		extern kmem_cache_t *tcp_bucket_cachep;
		extern struct inet_bind_bucket *
		inet_bind_bucket_create(kmem_cache_t *cachep,
		struct inet_bind_hashbucket *head,
		const unsigned short snum);
		extern void inet_bind_bucket_destroy(kmem_cache_t *cachep,
		struct inet_bind_bucket *tb);
		extern int tcp_port_rover;

		/* These are AF independent. */
		static inline int inet_bhashfn(const __u16 lport, const int bhash_size)
		{
		return lport & (bhash_size - 1);
		}
		extern int tcp_port_rover;

		extern void tcp_bind_hash(struct sock sk, struct inet_bind_bucket tb,
		unsigned short snum);
		@@ -359,17 +254,6 @@ extern void tcp_tw_deschedule(struct tcp_tw_bucket *tw);
		ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr)) && \
		(!((__sk)->sk_bound_dev_if) \|\| ((__sk)->sk_bound_dev_if == (__dif))))

		/* These can have wildcards, don't try too hard. */
		static inline int inet_lhashfn(const unsigned short num)
		{
		return num & (INET_LHTABLE_SIZE - 1);
		}

		static inline int inet_sk_listen_hashfn(const struct sock *sk)
		{
		return inet_lhashfn(inet_sk(sk)->num);
		}

		#define MAX_TCP_HEADER (128 + MAX_HEADER)

		/*

net/ipv4/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@

		obj-y := route.o inetpeer.o protocol.o \
		ip_input.o ip_fragment.o ip_forward.o ip_options.o \
		ip_output.o ip_sockglue.o \
		ip_output.o ip_sockglue.o inet_hashtables.o \
		tcp.o tcp_input.o tcp_output.o tcp_timer.o tcp_ipv4.o \
		tcp_minisocks.o tcp_cong.o \
		datagram.o raw.o udp.o arp.o icmp.o devinet.o af_inet.o igmp.o \

net/ipv4/inet_hashtables.c

0 → 100644

+51 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*
		* Generic INET transport hashtables
		*
		* 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.
		*/

		#include <linux/config.h>
		#include <linux/slab.h>

		#include <net/inet_hashtables.h>

		/*
		* Allocate and initialize a new local port bind bucket.
		* The bindhash mutex for snum's hash chain must be held here.
		*/
		struct inet_bind_bucket inet_bind_bucket_create(kmem_cache_t cachep,
		struct inet_bind_hashbucket *head,
		const unsigned short snum)
		{
		struct inet_bind_bucket *tb = kmem_cache_alloc(cachep, SLAB_ATOMIC);

		if (tb != NULL) {
		tb->port = snum;
		tb->fastreuse = 0;
		INIT_HLIST_HEAD(&tb->owners);
		hlist_add_head(&tb->node, &head->chain);
		}
		return tb;
		}

		EXPORT_SYMBOL(inet_bind_bucket_create);

		/*
		* Caller must hold hashbucket lock for this tb with local BH disabled
		*/
		void inet_bind_bucket_destroy(kmem_cache_t cachep, struct inet_bind_bucket tb)
		{
		if (hlist_empty(&tb->owners)) {
		__hlist_del(&tb->node);
		kmem_cache_free(cachep, tb);
		}
		}