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

inet: get rid of central tcp/dccp listener timer 



One of the major issue for TCP is the SYNACK rtx handling,
done by inet_csk_reqsk_queue_prune(), fired by the keepalive
timer of a TCP_LISTEN socket.

This function runs for awful long times, with socket lock held,
meaning that other cpus needing this lock have to spin for hundred of ms.

SYNACK are sent in huge bursts, likely to cause severe drops anyway.

This model was OK 15 years ago when memory was very tight.

We now can afford to have a timer per request sock.

Timer invocations no longer need to lock the listener,
and can be run from all cpus in parallel.

With following patch increasing somaxconn width to 32 bits,
I tested a listener with more than 4 million active request sockets,
and a steady SYNFLOOD of ~200,000 SYN per second.
Host was sending ~830,000 SYNACK per second.

This is ~100 times more what we could achieve before this patch.

Later, we will get rid of the listener hash and use ehash instead.

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

include/net/inet6_connection_sock.h

+1 −1
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ int inet6_csk_bind_conflict(const struct sock *sk, 
struct dst_entry *inet6_csk_route_req(struct sock *sk, struct flowi6 *fl6,

				      const struct request_sock *req);



struct request_sock *inet6_csk_search_req(const struct sock *sk,

struct request_sock *inet6_csk_search_req(struct sock *sk,

					  const __be16 rport,

					  const struct in6_addr *raddr,

					  const struct in6_addr *laddr,

include/net/inet_connection_sock.h

+4 −11
Original line number Diff line number Diff line
@@ -256,7 +256,7 @@ inet_csk_rto_backoff(const struct inet_connection_sock *icsk, 


struct sock *inet_csk_accept(struct sock *sk, int flags, int *err);



struct request_sock *inet_csk_search_req(const struct sock *sk,

struct request_sock *inet_csk_search_req(struct sock *sk,

					 const __be16 rport,

					 const __be32 raddr,

					 const __be32 laddr);
@@ -282,15 +282,13 @@ void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req, 
static inline void inet_csk_reqsk_queue_removed(struct sock *sk,

						struct request_sock *req)

{

	if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)

		inet_csk_delete_keepalive_timer(sk);

	reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req);

}



static inline void inet_csk_reqsk_queue_added(struct sock *sk,

					      const unsigned long timeout)

{

	if (reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue) == 0)

		inet_csk_reset_keepalive_timer(sk, timeout);

	reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue);

}



static inline int inet_csk_reqsk_queue_len(const struct sock *sk)
@@ -319,14 +317,9 @@ static inline void inet_csk_reqsk_queue_drop(struct sock *sk, 
{

	inet_csk_reqsk_queue_unlink(sk, req);

	inet_csk_reqsk_queue_removed(sk, req);

	reqsk_free(req);

	reqsk_put(req);

}



void inet_csk_reqsk_queue_prune(struct sock *parent,

				const unsigned long interval,

				const unsigned long timeout,

				const unsigned long max_rto);



void inet_csk_destroy_sock(struct sock *sk);

void inet_csk_prepare_forced_close(struct sock *sk);

include/net/request_sock.h

+41 −46
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ struct request_sock { 
	u32				window_clamp; /* window clamp at creation time */

	u32				rcv_wnd;	  /* rcv_wnd offered first time */

	u32				ts_recent;

	unsigned long			expires;

	struct timer_list		rsk_timer;

	const struct request_sock_ops	*rsk_ops;

	struct sock			*sk;

	u32				secid;
@@ -110,9 +110,6 @@ static inline void reqsk_free(struct request_sock *req) 


static inline void reqsk_put(struct request_sock *req)

{

	/* temporary debugging, until req sock are put into ehash table */

	WARN_ON_ONCE(atomic_read(&req->rsk_refcnt) != 1);



	if (atomic_dec_and_test(&req->rsk_refcnt))

		reqsk_free(req);

}
@@ -124,12 +121,16 @@ extern int sysctl_max_syn_backlog; 
 * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs

 */

struct listen_sock {

	u8			max_qlen_log;

	int			qlen_inc; /* protected by listener lock */

	int			young_inc;/* protected by listener lock */



	/* following fields can be updated by timer */

	atomic_t		qlen_dec; /* qlen = qlen_inc - qlen_dec */

	atomic_t		young_dec;



	u8			max_qlen_log ____cacheline_aligned_in_smp;

	u8			synflood_warned;

	/* 2 bytes hole, try to use */

	int			qlen;

	int			qlen_young;

	int			clock_hand;

	u32			hash_rnd;

	u32			nr_table_entries;

	struct request_sock	*syn_table[0];
@@ -182,9 +183,7 @@ struct fastopen_queue { 
struct request_sock_queue {

	struct request_sock	*rskq_accept_head;

	struct request_sock	*rskq_accept_tail;

	rwlock_t		syn_wait_lock;

	u8			rskq_defer_accept;

	/* 3 bytes hole, try to pack */

	struct listen_sock	*listen_opt;

	struct fastopen_queue	*fastopenq; /* This is non-NULL iff TFO has been

					     * enabled on this listener. Check
@@ -192,6 +191,9 @@ struct request_sock_queue { 
					     * to determine if TFO is enabled

					     * right at this moment.

					     */



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

	rwlock_t		syn_wait_lock ____cacheline_aligned_in_smp;

};



int reqsk_queue_alloc(struct request_sock_queue *queue,
@@ -223,11 +225,15 @@ static inline void reqsk_queue_unlink(struct request_sock_queue *queue, 
	struct request_sock **prev;



	write_lock(&queue->syn_wait_lock);



	prev = &lopt->syn_table[req->rsk_hash];

	while (*prev != req)

		prev = &(*prev)->dl_next;

	*prev = req->dl_next;



	write_unlock(&queue->syn_wait_lock);

	if (del_timer(&req->rsk_timer))

		reqsk_put(req);

}



static inline void reqsk_queue_add(struct request_sock_queue *queue,
@@ -260,64 +266,53 @@ static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue 
	return req;

}



static inline int reqsk_queue_removed(struct request_sock_queue *queue,

				      struct request_sock *req)

static inline void reqsk_queue_removed(struct request_sock_queue *queue,

				       const struct request_sock *req)

{

	struct listen_sock *lopt = queue->listen_opt;



	if (req->num_timeout == 0)

		--lopt->qlen_young;



	return --lopt->qlen;

		atomic_inc(&lopt->young_dec);

	atomic_inc(&lopt->qlen_dec);

}



static inline int reqsk_queue_added(struct request_sock_queue *queue)

static inline void reqsk_queue_added(struct request_sock_queue *queue)

{

	struct listen_sock *lopt = queue->listen_opt;

	const int prev_qlen = lopt->qlen;



	lopt->qlen_young++;

	lopt->qlen++;

	return prev_qlen;

	lopt->young_inc++;

	lopt->qlen_inc++;

}



static inline int listen_sock_qlen(const struct listen_sock *lopt)

{

	return lopt->qlen_inc - atomic_read(&lopt->qlen_dec);

}



static inline int listen_sock_young(const struct listen_sock *lopt)

{

	return lopt->young_inc - atomic_read(&lopt->young_dec);

}



static inline int reqsk_queue_len(const struct request_sock_queue *queue)

{

	return queue->listen_opt != NULL ? queue->listen_opt->qlen : 0;

	const struct listen_sock *lopt = queue->listen_opt;



	return lopt ? listen_sock_qlen(lopt) : 0;

}



static inline int reqsk_queue_len_young(const struct request_sock_queue *queue)

{

	return queue->listen_opt->qlen_young;

	return listen_sock_young(queue->listen_opt);

}



static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)

{

	return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;

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

}



static inline void reqsk_queue_hash_req(struct request_sock_queue *queue,

void reqsk_queue_hash_req(struct request_sock_queue *queue,

			  u32 hash, struct request_sock *req,

					unsigned long timeout)

{

	struct listen_sock *lopt = queue->listen_opt;



	req->expires = jiffies + timeout;

	req->num_retrans = 0;

	req->num_timeout = 0;

	req->sk = NULL;



	/* before letting lookups find us, make sure all req fields

	 * are committed to memory and refcnt initialized.

	 */

	smp_wmb();

	atomic_set(&req->rsk_refcnt, 1);



	req->rsk_hash = hash;

	write_lock(&queue->syn_wait_lock);

	req->dl_next = lopt->syn_table[hash];

	lopt->syn_table[hash] = req;

	write_unlock(&queue->syn_wait_lock);

}

			  unsigned long timeout);



#endif /* _REQUEST_SOCK_H */

net/core/request_sock.c

+9 −4
Original line number Diff line number Diff line
@@ -94,21 +94,26 @@ void reqsk_queue_destroy(struct request_sock_queue *queue) 
	/* make all the listen_opt local to us */

	struct listen_sock *lopt = reqsk_queue_yank_listen_sk(queue);



	if (lopt->qlen != 0) {

	if (listen_sock_qlen(lopt) != 0) {

		unsigned int i;



		for (i = 0; i < lopt->nr_table_entries; i++) {

			struct request_sock *req;



			write_lock_bh(&queue->syn_wait_lock);

			while ((req = lopt->syn_table[i]) != NULL) {

				lopt->syn_table[i] = req->dl_next;

				lopt->qlen--;

				atomic_inc(&lopt->qlen_dec);

				if (del_timer(&req->rsk_timer))

					reqsk_put(req);

				reqsk_put(req);

			}

			write_unlock_bh(&queue->syn_wait_lock);

		}

	}



	WARN_ON(lopt->qlen != 0);

	if (WARN_ON(listen_sock_qlen(lopt) != 0))

		pr_err("qlen %u\n", listen_sock_qlen(lopt));

	kvfree(lopt);

}
@@ -187,7 +192,7 @@ void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req, 
	 *

	 * For more details see CoNext'11 "TCP Fast Open" paper.

	 */

	req->expires = jiffies + 60*HZ;

	req->rsk_timer.expires = jiffies + 60*HZ;

	if (fastopenq->rskq_rst_head == NULL)

		fastopenq->rskq_rst_head = req;

	else

net/core/sock.c

+1 −1
Original line number Diff line number Diff line
@@ -2739,7 +2739,7 @@ static int req_prot_init(const struct proto *prot) 


	rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,

					   rsk_prot->obj_size, 0,

					   SLAB_HWCACHE_ALIGN, NULL);

					   0, NULL);



	if (!rsk_prot->slab) {

		pr_crit("%s: Can't create request sock SLAB cache!\n",

CRA Git | Maintained and supported by SUSTech CRA and CCSE