Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 10cbc8f1 authored by Eric Dumazet's avatar Eric Dumazet Committed by David S. Miller
Browse files

tcp/dccp: remove struct listen_sock 



It is enough to check listener sk_state, no need for an extra
condition.

max_qlen_log can be moved into struct request_sock_queue

We can remove syn_wait_lock and the alignment it enforced.

Signed-off-by: default avatarEric Dumazet <edumazet@google.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent ca6fb065

include/net/request_sock.h

+4 −22
Original line number Diff line number Diff line
@@ -119,14 +119,6 @@ static inline void reqsk_put(struct request_sock *req) 


extern int sysctl_max_syn_backlog;



/** struct listen_sock - listen state

 *

 * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs

 */

struct listen_sock {

	u32			max_qlen_log;

};



/*

 * For a TCP Fast Open listener -

 *	lock - protects the access to all the reqsk, which is co-owned by
@@ -160,36 +152,26 @@ struct fastopen_queue { 
 * @rskq_accept_head - FIFO head of established children

 * @rskq_accept_tail - FIFO tail of established children

 * @rskq_defer_accept - User waits for some data after accept()

 * @syn_wait_lock - serializer

 *

 * %syn_wait_lock is necessary only to avoid proc interface having to grab the main

 * lock sock while browsing the listening hash (otherwise it's deadlock prone).

 *

 */

struct request_sock_queue {

	spinlock_t		rskq_lock;

	u8			rskq_defer_accept;

	u8			max_qlen_log;

	u32			synflood_warned;



	atomic_t		qlen;

	atomic_t		young;



	struct request_sock	*rskq_accept_head;

	struct request_sock	*rskq_accept_tail;

	struct listen_sock	*listen_opt;

	struct fastopen_queue	fastopenq;  /* Check max_qlen != 0 to determine

					     * if TFO is enabled.

					     */



	/* temporary alignment, our goal is to get rid of this lock */

	spinlock_t		syn_wait_lock ____cacheline_aligned_in_smp;

};



int reqsk_queue_alloc(struct request_sock_queue *queue,

void reqsk_queue_alloc(struct request_sock_queue *queue,

		       unsigned int nr_table_entries);



void __reqsk_queue_destroy(struct request_sock_queue *queue);

void reqsk_queue_destroy(struct request_sock_queue *queue);

void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,

			   bool reset);
@@ -260,7 +242,7 @@ static inline int reqsk_queue_len_young(const struct request_sock_queue *queue) 


static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)

{

	return reqsk_queue_len(queue) >> queue->listen_opt->max_qlen_log;

	return reqsk_queue_len(queue) >> queue->max_qlen_log;

}



#endif /* _REQUEST_SOCK_H */

net/core/request_sock.c

+3 −44
Original line number Diff line number Diff line
@@ -37,22 +37,14 @@ 
int sysctl_max_syn_backlog = 256;

EXPORT_SYMBOL(sysctl_max_syn_backlog);



int reqsk_queue_alloc(struct request_sock_queue *queue,

void reqsk_queue_alloc(struct request_sock_queue *queue,

		       unsigned int nr_table_entries)

{

	size_t lopt_size = sizeof(struct listen_sock);

	struct listen_sock *lopt = NULL;



	nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);

	nr_table_entries = max_t(u32, nr_table_entries, 8);

	nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);



	lopt = kzalloc(lopt_size, GFP_KERNEL);

	if (!lopt)

		return -ENOMEM;



	spin_lock_init(&queue->rskq_lock);

	spin_lock_init(&queue->syn_wait_lock);



	spin_lock_init(&queue->fastopenq.lock);

	queue->fastopenq.rskq_rst_head = NULL;
@@ -61,40 +53,7 @@ int reqsk_queue_alloc(struct request_sock_queue *queue, 
	queue->fastopenq.max_qlen = 0;



	queue->rskq_accept_head = NULL;

	lopt->max_qlen_log = ilog2(nr_table_entries);



	spin_lock_bh(&queue->syn_wait_lock);

	queue->listen_opt = lopt;

	spin_unlock_bh(&queue->syn_wait_lock);



	return 0;

}



void __reqsk_queue_destroy(struct request_sock_queue *queue)

{

	/* This is an error recovery path only, no locking needed */

	kfree(queue->listen_opt);

}



static inline struct listen_sock *reqsk_queue_yank_listen_sk(

		struct request_sock_queue *queue)

{

	struct listen_sock *lopt;



	spin_lock_bh(&queue->syn_wait_lock);

	lopt = queue->listen_opt;

	queue->listen_opt = NULL;

	spin_unlock_bh(&queue->syn_wait_lock);



	return lopt;

}



void reqsk_queue_destroy(struct request_sock_queue *queue)

{

	struct listen_sock *lopt = reqsk_queue_yank_listen_sk(queue);



	/* cleaning is done by req timers */

	kfree(lopt);

	queue->max_qlen_log = ilog2(nr_table_entries);

}



/*

net/ipv4/inet_connection_sock.c

+4 −10
Original line number Diff line number Diff line
@@ -552,12 +552,11 @@ static void reqsk_timer_handler(unsigned long data) 
	struct sock *sk_listener = req->rsk_listener;

	struct inet_connection_sock *icsk = inet_csk(sk_listener);

	struct request_sock_queue *queue = &icsk->icsk_accept_queue;

	struct listen_sock *lopt = queue->listen_opt;

	int qlen, expire = 0, resend = 0;

	int max_retries, thresh;

	u8 defer_accept;



	if (sk_listener->sk_state != TCP_LISTEN || !lopt)

	if (sk_listener->sk_state != TCP_LISTEN)

		goto drop;



	max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;
@@ -580,7 +579,7 @@ static void reqsk_timer_handler(unsigned long data) 
	 * ones are about to clog our table.

	 */

	qlen = reqsk_queue_len(queue);

	if (qlen >> (lopt->max_qlen_log - 1)) {

	if (qlen >> (queue->max_qlen_log - 1)) {

		int young = reqsk_queue_len_young(queue) << 1;



		while (thresh > 2) {
@@ -730,12 +729,10 @@ EXPORT_SYMBOL(inet_csk_prepare_forced_close); 


int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)

{

	struct inet_sock *inet = inet_sk(sk);

	struct inet_connection_sock *icsk = inet_csk(sk);

	int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);

	struct inet_sock *inet = inet_sk(sk);



	if (rc != 0)

		return rc;

	reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);



	sk->sk_max_ack_backlog = 0;

	sk->sk_ack_backlog = 0;
@@ -757,7 +754,6 @@ int inet_csk_listen_start(struct sock *sk, const int nr_table_entries) 
	}



	sk->sk_state = TCP_CLOSE;

	__reqsk_queue_destroy(&icsk->icsk_accept_queue);

	return -EADDRINUSE;

}

EXPORT_SYMBOL_GPL(inet_csk_listen_start);
@@ -780,8 +776,6 @@ void inet_csk_listen_stop(struct sock *sk) 
	 * To be honest, we are not able to make either

	 * of the variants now.			--ANK

	 */

	reqsk_queue_destroy(queue);



	while ((req = reqsk_queue_remove(queue, sk)) != NULL) {

		struct sock *child = req->sk;