mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git
synced 2024-12-28 16:52:18 +00:00
19ce8cd304
Prepare ground for TIME-WAIT socket reuse with subsecond delay. Today the last TS.Recent update timestamp, recorded in seconds and stored tp->ts_recent_stamp and tw->tw_ts_recent_stamp fields, has two purposes. Firstly, it is used to track the age of the last recorded TS.Recent value to detect when that value becomes outdated due to potential wrap-around of the other TCP timestamp clock (RFC 7323, section 5.5). For this purpose a second-based timestamp is completely sufficient as even in the worst case scenario of a peer using a high resolution microsecond timestamp, the wrap-around interval is ~36 minutes long. Secondly, it serves as a threshold value for allowing TIME-WAIT socket reuse. A TIME-WAIT socket can be reused only once the virtual 1 Hz clock, ktime_get_seconds, is past the TS.Recent update timestamp. The purpose behind delaying the TIME-WAIT socket reuse is to wait for the other TCP timestamp clock to tick at least once before reusing the connection. It is only then that the PAWS mechanism for the reopened connection can detect old duplicate segments from the previous connection incarnation (RFC 7323, appendix B.2). In this case using a timestamp with second resolution not only blocks the way toward allowing faster TIME-WAIT reuse after shorter subsecond delay, but also makes it impossible to reliably delay TW reuse by one second. As Eric Dumazet has pointed out [1], due to timestamp rounding, the TW reuse delay will actually be between (0, 1] seconds, and 0.5 seconds on average. We delay TW reuse for one full second only when last TS.Recent update coincides with our virtual 1 Hz clock tick. Considering the above, introduce a dedicated field to store a millisecond timestamp of transition into the TIME-WAIT state. Place it in an existing 4-byte hole inside inet_timewait_sock structure to avoid an additional memory cost. Use the new timestamp to (i) reliably delay TIME-WAIT reuse by one second, and (ii) prepare for configurable subsecond reuse delay in the subsequent change. We assume here that a full one second delay was the original intention in [2] because it accounts for the worst case scenario of the other TCP using the slowest recommended 1 Hz timestamp clock. A more involved alternative would be to change the resolution of the last TS.Recent update timestamp, tw->tw_ts_recent_stamp, to milliseconds. [1] https://lore.kernel.org/netdev/CANn89iKB4GFd8sVzCbRttqw_96o3i2wDhX-3DraQtsceNGYwug@mail.gmail.com/ [2] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b8439924316d5bcb266d165b93d632a4b4b859af Signed-off-by: Jakub Sitnicki <jakub@cloudflare.com> Reviewed-by: Eric Dumazet <edumazet@google.com> Reviewed-by: Jason Xing <kerneljasonxing@gmail.com> Link: https://patch.msgid.link/20241209-jakub-krn-909-poc-msec-tw-tstamp-v2-1-66aca0eed03e@cloudflare.com Signed-off-by: Jakub Kicinski <kuba@kernel.org>
131 lines
3.8 KiB
C
131 lines
3.8 KiB
C
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
/*
|
|
* 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.
|
|
*
|
|
* Definitions for a generic INET TIMEWAIT sock
|
|
*
|
|
* From code originally in net/tcp.h
|
|
*/
|
|
#ifndef _INET_TIMEWAIT_SOCK_
|
|
#define _INET_TIMEWAIT_SOCK_
|
|
|
|
#include <linux/list.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/types.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <net/inet_sock.h>
|
|
#include <net/sock.h>
|
|
#include <net/tcp_states.h>
|
|
#include <net/timewait_sock.h>
|
|
|
|
#include <linux/atomic.h>
|
|
|
|
struct inet_bind_bucket;
|
|
|
|
/*
|
|
* This is a TIME_WAIT sock. It works around the memory consumption
|
|
* problems of sockets in such a state on heavily loaded servers, but
|
|
* without violating the protocol specification.
|
|
*/
|
|
struct inet_timewait_sock {
|
|
/*
|
|
* Now struct sock also uses sock_common, so please just
|
|
* don't add nothing before this first member (__tw_common) --acme
|
|
*/
|
|
struct sock_common __tw_common;
|
|
#define tw_family __tw_common.skc_family
|
|
#define tw_state __tw_common.skc_state
|
|
#define tw_reuse __tw_common.skc_reuse
|
|
#define tw_reuseport __tw_common.skc_reuseport
|
|
#define tw_ipv6only __tw_common.skc_ipv6only
|
|
#define tw_bound_dev_if __tw_common.skc_bound_dev_if
|
|
#define tw_node __tw_common.skc_nulls_node
|
|
#define tw_bind_node __tw_common.skc_bind_node
|
|
#define tw_refcnt __tw_common.skc_refcnt
|
|
#define tw_tx_queue_mapping __tw_common.skc_tx_queue_mapping
|
|
#define tw_rx_queue_mapping __tw_common.skc_rx_queue_mapping
|
|
#define tw_hash __tw_common.skc_hash
|
|
#define tw_prot __tw_common.skc_prot
|
|
#define tw_net __tw_common.skc_net
|
|
#define tw_daddr __tw_common.skc_daddr
|
|
#define tw_v6_daddr __tw_common.skc_v6_daddr
|
|
#define tw_rcv_saddr __tw_common.skc_rcv_saddr
|
|
#define tw_v6_rcv_saddr __tw_common.skc_v6_rcv_saddr
|
|
#define tw_dport __tw_common.skc_dport
|
|
#define tw_num __tw_common.skc_num
|
|
#define tw_cookie __tw_common.skc_cookie
|
|
#define tw_dr __tw_common.skc_tw_dr
|
|
|
|
__u32 tw_mark;
|
|
unsigned char tw_substate;
|
|
unsigned char tw_rcv_wscale;
|
|
|
|
/* Socket demultiplex comparisons on incoming packets. */
|
|
/* these three are in inet_sock */
|
|
__be16 tw_sport;
|
|
/* And these are ours. */
|
|
unsigned int tw_transparent : 1,
|
|
tw_flowlabel : 20,
|
|
tw_usec_ts : 1,
|
|
tw_pad : 2, /* 2 bits hole */
|
|
tw_tos : 8;
|
|
u32 tw_txhash;
|
|
u32 tw_priority;
|
|
/**
|
|
* @tw_reuse_stamp: Time of entry into %TCP_TIME_WAIT state in msec.
|
|
*/
|
|
u32 tw_entry_stamp;
|
|
struct timer_list tw_timer;
|
|
struct inet_bind_bucket *tw_tb;
|
|
struct inet_bind2_bucket *tw_tb2;
|
|
};
|
|
#define tw_tclass tw_tos
|
|
|
|
static inline struct inet_timewait_sock *inet_twsk(const struct sock *sk)
|
|
{
|
|
return (struct inet_timewait_sock *)sk;
|
|
}
|
|
|
|
void inet_twsk_free(struct inet_timewait_sock *tw);
|
|
void inet_twsk_put(struct inet_timewait_sock *tw);
|
|
|
|
void inet_twsk_bind_unhash(struct inet_timewait_sock *tw,
|
|
struct inet_hashinfo *hashinfo);
|
|
|
|
struct inet_timewait_sock *inet_twsk_alloc(const struct sock *sk,
|
|
struct inet_timewait_death_row *dr,
|
|
const int state);
|
|
|
|
void inet_twsk_hashdance_schedule(struct inet_timewait_sock *tw,
|
|
struct sock *sk,
|
|
struct inet_hashinfo *hashinfo,
|
|
int timeo);
|
|
|
|
void __inet_twsk_schedule(struct inet_timewait_sock *tw, int timeo,
|
|
bool rearm);
|
|
|
|
static inline void inet_twsk_reschedule(struct inet_timewait_sock *tw, int timeo)
|
|
{
|
|
__inet_twsk_schedule(tw, timeo, true);
|
|
}
|
|
|
|
void inet_twsk_deschedule_put(struct inet_timewait_sock *tw);
|
|
|
|
void inet_twsk_purge(struct inet_hashinfo *hashinfo);
|
|
|
|
static inline
|
|
struct net *twsk_net(const struct inet_timewait_sock *twsk)
|
|
{
|
|
return read_pnet(&twsk->tw_net);
|
|
}
|
|
|
|
static inline
|
|
void twsk_net_set(struct inet_timewait_sock *twsk, struct net *net)
|
|
{
|
|
write_pnet(&twsk->tw_net, net);
|
|
}
|
|
#endif /* _INET_TIMEWAIT_SOCK_ */
|