Quelle tcp.h
Sprache: 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 the TCP module . * * Version : @ ( # ) tcp . h 1 . 0 . 5 05 / 23 / 93 * * Authors : Ross Biro * Fred N . van Kempen , < waltje @ uWalt . NL . Mugnet . ORG > #ifndef _TCP_H#define _TCP_H#define FASTRETRANS_DEBUG 1 #include <linux/list.h>#include <linux/tcp.h>#include <linux/bug.h>#include <linux/slab.h>#include <linux/cache.h>#include <linux/percpu.h>#include <linux/skbuff.h>#include <linux/kref.h>#include <linux/ktime.h>#include <linux/indirect_call_wrapper.h>#include <linux/bits.h>#include <net/inet_connection_sock.h>#include <net/inet_timewait_sock.h>#include <net/inet_hashtables.h>#include <net/checksum.h>#include <net/request_sock.h>#include <net/sock_reuseport.h>#include <net/sock.h>#include <net/snmp.h>#include <net/ip.h>#include <net/tcp_states.h>#include <net/tcp_ao.h>#include <net/inet_ecn.h>#include <net/dst.h>#include <net/mptcp.h>#include <net/xfrm.h>#include <linux/seq_file.h>#include <linux/memcontrol.h>#include <linux/bpf-cgroup.h>#include <linux/siphash.h>extern struct inet_hashinfo tcp_hashinfo;unsigned int , tcp_orphan_count);int tcp_orphan_count_sum(void );void tcp_time_wait(struct sock *sk, int state, int timeo);#define MAX_TCP_HEADER L1_CACHE_ALIGN(128 + MAX_HEADER)#define MAX_TCP_OPTION_SPACE 40 #define TCP_MIN_SND_MSS 48 #define TCP_MIN_GSO_SIZE (TCP_MIN_SND_MSS - MAX_TCP_OPTION_SPACE)/* * Never offer a window over 32767 without using window scaling . Some * poor stacks do signed 16 bit maths ! #define MAX_TCP_WINDOW 32767 U/* Minimal accepted MSS. It is (60+60+8) - (20+20). */ #define TCP_MIN_MSS 88 U/* The initial MTU to use for probing */ #define TCP_BASE_MSS 1024 /* probing interval, default to 10 minutes as per RFC4821 */ #define TCP_PROBE_INTERVAL 600 /* Specify interval when tcp mtu probing will stop */ #define TCP_PROBE_THRESHOLD 8 /* After receiving this amount of duplicate ACKs fast retransmit starts. */ #define TCP_FASTRETRANS_THRESH 3 /* Maximal number of ACKs sent quickly to accelerate slow-start. */ #define TCP_MAX_QUICKACKS 16 U/* Maximal number of window scale according to RFC1323 */ #define TCP_MAX_WSCALE 14 U/* urg_data states */ #define TCP_URG_VALID 0 x0100#define TCP_URG_NOTYET 0 x0200#define TCP_URG_READ 0 x0400#define TCP_RETR1 3 /* * This is how many retries it does before it * tries to figure out if the gateway is * down . Minimal RFC value is 3 ; it corresponds * to ~ 3 sec - 8 min depending on RTO . #define TCP_RETR2 15 /* * This should take at least * 90 minutes to time out . * RFC1122 says that the limit is 100 sec . * 15 is ~ 13 - 30 min depending on RTO . #define TCP_SYN_RETRIES 6 /* This is how many retries are done * when active opening a connection . * RFC1122 says the minimum retry MUST * be at least 180 secs . Nevertheless * this value is corresponding to * 63 secs of retransmission with the * current initial RTO . #define TCP_SYNACK_RETRIES 5 /* This is how may retries are done * when passive opening a connection . * This is corresponding to 31 secs of * retransmission with the current * initial RTO . #define TCP_TIMEWAIT_LEN (60 *HZ) /* how long to wait to destroy TIME-WAIT #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN/* BSD style FIN_WAIT2 deadlock breaker. * It used to be 3 min , new value is 60 sec , * to combine FIN - WAIT - 2 timeout with * TIME - WAIT timer . #define TCP_FIN_TIMEOUT_MAX (120 * HZ) /* max TCP_LINGER2 value (two minutes) */ #define TCP_DELACK_MAX ((unsigned )(HZ/5 )) /* maximal time to delay before sending an ACK */ 1 << ATO_BITS) > TCP_DELACK_MAX);#if HZ >= 100 #define TCP_DELACK_MIN ((unsigned )(HZ/25 )) /* minimal time to delay before sending an ACK */ #define TCP_ATO_MIN ((unsigned )(HZ/25 ))#else #define TCP_DELACK_MIN 4 U#define TCP_ATO_MIN 4 U#endif #define TCP_RTO_MAX_SEC 120 #define TCP_RTO_MAX ((unsigned )(TCP_RTO_MAX_SEC * HZ))#define TCP_RTO_MIN ((unsigned )(HZ / 5 ))#define TCP_TIMEOUT_MIN (2 U) /* Min timeout for TCP timers in jiffies */ #define TCP_TIMEOUT_MIN_US (2 *USEC_PER_MSEC) /* Min TCP timeout in microsecs */ #define TCP_TIMEOUT_INIT ((unsigned )(1 *HZ)) /* RFC6298 2.1 initial RTO value */ #define TCP_TIMEOUT_FALLBACK ((unsigned )(3 *HZ)) /* RFC 1122 initial RTO value, now * used as a fallback RTO for the * initial data transmission if no * valid RTT sample has been acquired , * most likely due to retrans in 3 WHS . #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned )(HZ/2 U)) /* Maximal interval between probes * for local resources . #define TCP_KEEPALIVE_TIME (120 *60 *HZ) /* two hours */ #define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ #define TCP_KEEPALIVE_INTVL (75 *HZ)#define MAX_TCP_KEEPIDLE 32767 #define MAX_TCP_KEEPINTVL 32767 #define MAX_TCP_KEEPCNT 127 #define MAX_TCP_SYNCNT 127 /* Ensure that TCP PAWS checks are relaxed after ~2147 seconds * to avoid overflows . This assumes a clock smaller than 1 Mhz . * Default clock is 1 Khz , tcp_usec_ts uses 1 Mhz . #define TCP_PAWS_WRAP (INT_MAX / USEC_PER_SEC)#define TCP_PAWS_MSL 60 /* Per-host timestamps are invalidated * after this time . It should be equal * ( or greater than ) TCP_TIMEWAIT_LEN * to provide reliability equal to one * provided by timewait state . #define TCP_PAWS_WINDOW 1 /* Replay window for per-host * timestamps . It must be less than * minimal timewait lifetime . /* * TCP option #define TCPOPT_NOP 1 /* Padding */ #define TCPOPT_EOL 0 /* End of options */ #define TCPOPT_MSS 2 /* Segment size negotiating */ #define TCPOPT_WINDOW 3 /* Window scaling */ #define TCPOPT_SACK_PERM 4 /* SACK Permitted */ #define TCPOPT_SACK 5 /* SACK Block */ #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ #define TCPOPT_MD5SIG 19 /* MD5 Signature (RFC2385) */ #define TCPOPT_AO 29 /* Authentication Option (RFC5925) */ #define TCPOPT_MPTCP 30 /* Multipath TCP (RFC6824) */ #define TCPOPT_FASTOPEN 34 /* Fast open (RFC7413) */ #define TCPOPT_EXP 254 /* Experimental */ /* Magic number to be after the option value for sharing TCP * experimental options . See draft - ietf - tcpm - experimental - options - 00 . txt #define TCPOPT_FASTOPEN_MAGIC 0 xF989#define TCPOPT_SMC_MAGIC 0 xE2D4C3D9/* * TCP option lengths #define TCPOLEN_MSS 4 #define TCPOLEN_WINDOW 3 #define TCPOLEN_SACK_PERM 2 #define TCPOLEN_TIMESTAMP 10 #define TCPOLEN_MD5SIG 18 #define TCPOLEN_FASTOPEN_BASE 2 #define TCPOLEN_EXP_FASTOPEN_BASE 4 #define TCPOLEN_EXP_SMC_BASE 6 /* But this is what stacks really send out. */ #define TCPOLEN_TSTAMP_ALIGNED 12 #define TCPOLEN_WSCALE_ALIGNED 4 #define TCPOLEN_SACKPERM_ALIGNED 4 #define TCPOLEN_SACK_BASE 2 #define TCPOLEN_SACK_BASE_ALIGNED 4 #define TCPOLEN_SACK_PERBLOCK 8 #define TCPOLEN_MD5SIG_ALIGNED 20 #define TCPOLEN_MSS_ALIGNED 4 #define TCPOLEN_EXP_SMC_BASE_ALIGNED 8 /* Flags in tp->nonagle */ #define TCP_NAGLE_OFF 1 /* Nagle's algo is disabled */ #define TCP_NAGLE_CORK 2 /* Socket is corked */ #define TCP_NAGLE_PUSH 4 /* Cork is overridden for already queued data */ /* TCP thin-stream limits */ #define TCP_THIN_LINEAR_RETRIES 6 /* After 6 linear retries, do exp. backoff */ /* TCP initial congestion window as per rfc6928 */ #define TCP_INIT_CWND 10 /* Bit Flags for sysctl_tcp_fastopen */ #define TFO_CLIENT_ENABLE 1 #define TFO_SERVER_ENABLE 2 #define TFO_CLIENT_NO_COOKIE 4 /* Data in SYN w/o cookie option */ /* Accept SYN data w/o any cookie option */ #define TFO_SERVER_COOKIE_NOT_REQD 0 x200/* Force enable TFO on all listeners, i.e., not requiring the * TCP_FASTOPEN socket option . #define TFO_SERVER_WO_SOCKOPT1 0 x400/* sysctl variables for tcp */ extern int sysctl_tcp_max_orphans;extern long sysctl_tcp_mem[3 ];#define TCP_RACK_LOSS_DETECTION 0 x1 /* Use RACK to detect losses */ #define TCP_RACK_STATIC_REO_WND 0 x2 /* Use static RACK reo wnd */ #define TCP_RACK_NO_DUPTHRESH 0 x4 /* Do not use DUPACK threshold in RACK */ int , tcp_memory_per_cpu_fw_alloc);extern struct percpu_counter tcp_sockets_allocated;extern unsigned long tcp_memory_pressure;/* optimized version of sk_under_memory_pressure() for TCP sockets */ static inline bool tcp_under_memory_pressure(const struct sock *sk)if (mem_cgroup_sockets_enabled && sk->sk_memcg &&return true ;return READ_ONCE(tcp_memory_pressure);/* * The next routines deal with comparing 32 bit unsigned ints * and worry about wraparound ( automatic with unsigned arithmetic ) . static inline bool before(__u32 seq1, __u32 seq2)return (__s32)(seq1-seq2) < 0 ;#define after(seq2, seq1) before(seq1, seq2)/* is s2<=s1<=s3 ? */ static inline bool between(__u32 seq1, __u32 seq2, __u32 seq3)return seq3 - seq2 >= seq1 - seq2;static inline void tcp_wmem_free_skb(struct sock *sk, struct sk_buff *skb)if (!skb_zcopy_pure(skb))else void sk_forced_mem_schedule(struct sock *sk, int size);bool tcp_check_oom(const struct sock *sk, int shift);extern struct proto tcp_prot;#define TCP_INC_STATS(net, field) SNMP_INC_STATS((net)->mib.tcp_statistics, field)#define __TCP_INC_STATS(net, field) __SNMP_INC_STATS((net)->mib.tcp_statistics, field)#define TCP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->mib.tcp_statistics, field)#define TCP_ADD_STATS(net, field, val) SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)void tcp_tsq_work_init(void );int tcp_v4_err(struct sk_buff *skb, u32);void tcp_shutdown(struct sock *sk, int how);int tcp_v4_early_demux(struct sk_buff *skb);int tcp_v4_rcv(struct sk_buff *skb);void tcp_remove_empty_skb(struct sock *sk);int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size);int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size);int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg, int *copied,struct ubuf_info *uarg);void tcp_splice_eof(struct socket *sock);int tcp_send_mss(struct sock *sk, int *size_goal, int flags);int tcp_wmem_schedule(struct sock *sk, int copy);void tcp_push(struct sock *sk, int flags, int mss_now, int nonagle,int size_goal);void tcp_release_cb(struct sock *sk);void tcp_wfree(struct sk_buff *skb);void tcp_write_timer_handler(struct sock *sk);void tcp_delack_timer_handler(struct sock *sk);int tcp_ioctl(struct sock *sk, int cmd, int *karg);enum skb_drop_reason tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb);void tcp_rcv_established(struct sock *sk, struct sk_buff *skb);void tcp_rcv_space_adjust(struct sock *sk);int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp);void tcp_twsk_destructor(struct sock *sk);void tcp_twsk_purge(struct list_head *net_exit_list);struct socket *sk, loff_t *ppos,struct pipe_inode_info *pipe, size_t len,unsigned int flags);struct sk_buff *tcp_stream_alloc_skb(struct sock *sk, gfp_t gfp,bool force_schedule);static inline void tcp_dec_quickack_mode(struct sock *sk)struct inet_connection_sock *icsk = inet_csk(sk);if (icsk->icsk_ack.quick) {/* How many ACKs S/ACKing new data have we sent? */ const unsigned int pkts = inet_csk_ack_scheduled(sk) ? 1 : 0 ;if (pkts >= icsk->icsk_ack.quick) {0 ;/* Leaving quickack mode we deflate ATO. */ else #define TCP_ECN_MODE_RFC3168 BIT(0 )#define TCP_ECN_QUEUE_CWR BIT(1 )#define TCP_ECN_DEMAND_CWR BIT(2 )#define TCP_ECN_SEEN BIT(3 )#define TCP_ECN_MODE_ACCECN BIT(4 )#define TCP_ECN_DISABLED 0 #define TCP_ECN_MODE_PENDING (TCP_ECN_MODE_RFC3168 | TCP_ECN_MODE_ACCECN)#define TCP_ECN_MODE_ANY (TCP_ECN_MODE_RFC3168 | TCP_ECN_MODE_ACCECN)static inline bool tcp_ecn_mode_any(const struct tcp_sock *tp)return tp->ecn_flags & TCP_ECN_MODE_ANY;static inline bool tcp_ecn_mode_rfc3168(const struct tcp_sock *tp)return (tp->ecn_flags & TCP_ECN_MODE_ANY) == TCP_ECN_MODE_RFC3168;static inline bool tcp_ecn_mode_accecn(const struct tcp_sock *tp)return (tp->ecn_flags & TCP_ECN_MODE_ANY) == TCP_ECN_MODE_ACCECN;static inline bool tcp_ecn_disabled(const struct tcp_sock *tp)return !tcp_ecn_mode_any(tp);static inline bool tcp_ecn_mode_pending(const struct tcp_sock *tp)return (tp->ecn_flags & TCP_ECN_MODE_PENDING) == TCP_ECN_MODE_PENDING;static inline void tcp_ecn_mode_set(struct tcp_sock *tp, u8 mode)enum tcp_tw_status {0 ,1 ,2 ,3 ,4 enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,struct sk_buff *skb,const struct tcphdr *th,enum skb_drop_reason *drop_reason);struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,struct request_sock *req, bool fastopen,bool *lost_race, enum skb_drop_reason *drop_reason);enum skb_drop_reason tcp_child_process(struct sock *parent, struct sock *child,struct sk_buff *skb);void tcp_enter_loss(struct sock *sk);void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int newly_lost, int flag);void tcp_clear_retrans(struct tcp_sock *tp);void tcp_update_metrics(struct sock *sk);void tcp_init_metrics(struct sock *sk);void tcp_metrics_init(void );bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst);void __tcp_close(struct sock *sk, long timeout);void tcp_close(struct sock *sk, long timeout);void tcp_init_sock(struct sock *sk);void tcp_init_transfer(struct sock *sk, int bpf_op, struct sk_buff *skb);struct file *file, struct socket *sock,struct poll_table_struct *wait);int do_tcp_getsockopt(struct sock *sk, int level,int optname, sockptr_t optval, sockptr_t optlen);int tcp_getsockopt(struct sock *sk, int level, int optname,char __user *optval, int __user *optlen);bool tcp_bpf_bypass_getsockopt(int level, int optname);int do_tcp_setsockopt(struct sock *sk, int level, int optname,unsigned int optlen);int tcp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,unsigned int optlen);void tcp_reset_keepalive_timer(struct sock *sk, unsigned long timeout);void tcp_set_keepalive(struct sock *sk, int val);void tcp_syn_ack_timeout(const struct request_sock *req);int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,int flags, int *addr_len);int tcp_set_rcvlowat(struct sock *sk, int val);int tcp_set_window_clamp(struct sock *sk, int val);void tcp_update_recv_tstamps(struct sk_buff *skb,struct scm_timestamping_internal *tss);void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,struct scm_timestamping_internal *tss);void tcp_data_ready(struct sock *sk);#ifdef CONFIG_MMUint tcp_mmap(struct file *file, struct socket *sock,struct vm_area_struct *vma);#endif void tcp_parse_options(const struct net *net, const struct sk_buff *skb,struct tcp_options_received *opt_rx,int estab, struct tcp_fastopen_cookie *foc);/* * BPF SKB - less helpers struct sock *sk, struct iphdr *iph,struct tcphdr *th, u32 *cookie);struct sock *sk, struct ipv6hdr *iph,struct tcphdr *th, u32 *cookie);const struct tcphdr *th, u16 user_mss);struct request_sock_ops *rsk_ops,const struct tcp_request_sock_ops *af_ops,struct sock *sk, struct tcphdr *th);/* * TCP v4 functions exported for the inet6 API void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb);void tcp_v4_mtu_reduced(struct sock *sk);void tcp_req_err(struct sock *sk, u32 seq, bool abort);void tcp_ld_RTO_revert(struct sock *sk, u32 seq);int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb);struct sock *tcp_create_openreq_child(const struct sock *sk,struct request_sock *req,struct sk_buff *skb);void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst);struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,struct request_sock *req,struct dst_entry *dst,struct request_sock *req_unhash,bool *own_req);int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);int tcp_connect(struct sock *sk);enum tcp_synack_type {struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,struct request_sock *req,struct tcp_fastopen_cookie *foc,enum tcp_synack_type synack_type,struct sk_buff *syn_skb);int tcp_disconnect(struct sock *sk, int flags);void tcp_finish_connect(struct sock *sk, struct sk_buff *skb);int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size);void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb);/* From syncookies.c */ struct sock *tcp_get_cookie_sock(struct sock *sk, struct sk_buff *skb,struct request_sock *req,struct dst_entry *dst);int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th);struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb);struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops,struct sock *sk, struct sk_buff *skb,struct tcp_options_received *tcp_opt,int mss, u32 tsoff);#if IS_ENABLED(CONFIG_BPF)struct bpf_tcp_req_attrs {3 ];#endif #ifdef CONFIG_SYN_COOKIES/* Syncookies use a monotonic timer which increments every 60 seconds. * This counter is used both as a hash input and partially encoded into * the cookie value . A cookie is only validated further if the delta * between the current counter value and the encoded one is less than this , * i . e . a sent cookie is valid only at most for 2 * 60 seconds ( or less if * the counter advances immediately after a cookie is generated ) . #define MAX_SYNCOOKIE_AGE 2 #define TCP_SYNCOOKIE_PERIOD (60 * HZ)#define TCP_SYNCOOKIE_VALID (MAX_SYNCOOKIE_AGE * TCP_SYNCOOKIE_PERIOD)/* syncookies: remember time of last synqueue overflow * But do not dirty this field too often ( once per second is enough ) * It is racy as we do not hold a lock , but race is very minor . static inline void tcp_synq_overflow(const struct sock *sk)unsigned int last_overflow;unsigned int now = jiffies;if (sk->sk_reuseport) {struct sock_reuseport *reuse;if (likely(reuse)) {if (!time_between32(now, last_overflow,return ;if (!time_between32(now, last_overflow, last_overflow + HZ))/* syncookies: no recent synqueue overflow on this listening socket? */ static inline bool tcp_synq_no_recent_overflow(const struct sock *sk)unsigned int last_overflow;unsigned int now = jiffies;if (sk->sk_reuseport) {struct sock_reuseport *reuse;if (likely(reuse)) {return !time_between32(now, last_overflow - HZ,/* If last_overflow <= jiffies <= last_overflow + TCP_SYNCOOKIE_VALID, * then we ' re under synflood . However , we have to use * ' last_overflow - HZ ' as lower bound . That ' s because a concurrent * tcp_synq_overflow ( ) could update . ts_recent_stamp after we read * jiffies but before we store . ts_recent_stamp into last_overflow , * which could lead to rejecting a valid syncookie . return !time_between32(now, last_overflow - HZ,static inline u32 tcp_cookie_time(void )return val;/* Convert one nsec 64bit timestamp to ts (ms or usec resolution) */ static inline u64 tcp_ns_to_ts(bool usec_ts, u64 val)if (usec_ts)return div_u64(val, NSEC_PER_USEC);return div_u64(val, NSEC_PER_MSEC);const struct iphdr *iph, const struct tcphdr *th,const struct sk_buff *skb, __u16 *mss);struct request_sock *req, u64 now);bool cookie_timestamp_decode(const struct net *net,struct tcp_options_received *opt);static inline bool cookie_ecn_ok(const struct net *net, const struct dst_entry *dst)return READ_ONCE(net->ipv4.sysctl_tcp_ecn) ||#if IS_ENABLED(CONFIG_BPF)static inline bool cookie_bpf_ok(struct sk_buff *skb)return skb->sk;struct request_sock *cookie_bpf_check(struct sock *sk, struct sk_buff *skb);#else static inline bool cookie_bpf_ok(struct sk_buff *skb)return false ;static inline struct request_sock *cookie_bpf_check(struct net *net, struct sock *sk,struct sk_buff *skb)return NULL;#endif /* From net/ipv6/syncookies.c */ int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th);struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);const struct ipv6hdr *iph,const struct tcphdr *th, u16 *mssp);const struct sk_buff *skb, __u16 *mss);#endif /* tcp_output.c */ void tcp_skb_entail(struct sock *sk, struct sk_buff *skb);void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb);void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,int nonagle);int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs);int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs);void tcp_retransmit_timer(struct sock *sk);void tcp_xmit_retransmit_queue(struct sock *);void tcp_simple_retransmit(struct sock *);void tcp_enter_recovery(struct sock *sk, bool ece_ack);int tcp_trim_head(struct sock *, struct sk_buff *, u32);enum tcp_queue {int tcp_fragment(struct sock *sk, enum tcp_queue tcp_queue,struct sk_buff *skb, u32 len,unsigned int mss_now, gfp_t gfp);void tcp_send_probe0(struct sock *);int tcp_write_wakeup(struct sock *, int mib);void tcp_send_fin(struct sock *sk);void tcp_send_active_reset(struct sock *sk, gfp_t priority,enum sk_rst_reason reason);int tcp_send_synack(struct sock *);void tcp_push_one(struct sock *, unsigned int mss_now);void __tcp_send_ack(struct sock *sk, u32 rcv_nxt, u16 flags);void tcp_send_ack(struct sock *sk);void tcp_send_delayed_ack(struct sock *sk);void tcp_send_loss_probe(struct sock *sk);bool tcp_schedule_loss_probe(struct sock *sk, bool advancing_rto);void tcp_skb_collapse_tstamp(struct sk_buff *skb,const struct sk_buff *next_skb);/* tcp_input.c */ void tcp_rearm_rto(struct sock *sk);void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req);void tcp_done_with_error(struct sock *sk, int err);void tcp_reset(struct sock *sk, struct sk_buff *skb);void tcp_fin(struct sock *sk);void tcp_check_space(struct sock *sk);void tcp_sack_compress_send_ack(struct sock *sk);static inline void tcp_cleanup_skb(struct sk_buff *skb)static inline void tcp_add_receive_queue(struct sock *sk, struct sk_buff *skb)/* tcp_timer.c */ void tcp_init_xmit_timers(struct sock *);static inline void tcp_clear_xmit_timers(struct sock *sk)if (hrtimer_try_to_cancel(&tcp_sk(sk)->pacing_timer) == 1 )if (hrtimer_try_to_cancel(&tcp_sk(sk)->compressed_ack_timer) == 1 )unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);unsigned int tcp_current_mss(struct sock *sk);const struct sock *sk, u32 when);/* Bound MSS / TSO packet size with the half of the window */ static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)int cutoff;/* When peer uses tiny windows, there is no use in packetizing * to sub - MSS pieces for the sake of SWS or making sure there * are enough packets in the pipe for fast recovery . * * On the other hand , for extremely large MSS devices , handling * smaller than MSS windows in this way does make sense . if (tp->max_window > TCP_MSS_DEFAULT)1 );else if (cutoff && pktsize > cutoff)return max_t(int , cutoff, 68 U - tp->tcp_header_len);else return pktsize;/* tcp.c */ void tcp_get_info(struct sock *, struct tcp_info *);/* Read 'sendfile()'-style from a TCP socket */ int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,int tcp_read_sock_noack(struct sock *sk, read_descriptor_t *desc,bool noack,int tcp_read_skb(struct sock *sk, skb_read_actor_t recv_actor);struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off);void tcp_read_done(struct sock *sk, size_t len);void tcp_initialize_rcv_mss(struct sock *sk);int tcp_mtu_to_mss(struct sock *sk, int pmtu);int tcp_mss_to_mtu(struct sock *sk, int mss);void tcp_mtup_init(struct sock *sk);static inline unsigned int tcp_rto_max(const struct sock *sk)return READ_ONCE(inet_csk(sk)->icsk_rto_max);static inline void tcp_bound_rto(struct sock *sk)static inline u32 __tcp_set_rto(const struct tcp_sock *tp)return usecs_to_jiffies((tp->srtt_us >> 3 ) + tp->rttvar_us);static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)/* mptcp hooks are only on the slow path */ if (sk_is_mptcp((struct sock *)tp))return ;26 ) |static inline void tcp_fast_path_on(struct tcp_sock *tp)static inline void tcp_fast_path_check(struct sock *sk)struct tcp_sock *tp = tcp_sk(sk);if (RB_EMPTY_ROOT(&tp->out_of_order_queue) &&const struct sock *sk);/* Compute the actual rto_min value */ static inline u32 tcp_rto_min(const struct sock *sk)const struct dst_entry *dst = __sk_dst_get(sk);if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))return rto_min;static inline u32 tcp_rto_min_us(const struct sock *sk)return jiffies_to_usecs(tcp_rto_min(sk));static inline bool tcp_ca_dst_locked(const struct dst_entry *dst)return dst_metric_locked(dst, RTAX_CC_ALGO);/* Minimum RTT in usec. ~0 means not available. */ static inline u32 tcp_min_rtt(const struct tcp_sock *tp)return minmax_get(&tp->rtt_min);/* Compute the actual receive window we are currently advertising. * Rcv_nxt can be after the window if our peer push more data * than the offered window . static inline u32 tcp_receive_window(const struct tcp_sock *tp)if (win < 0 )0 ;return (u32) win;/* Choose a new window, without checks for shrinking, and without * scaling applied to the result . The caller does these things * if necessary . This is a " raw " window selection . struct sock *sk);void tcp_send_window_probe(struct sock *sk);/* TCP uses 32bit jiffies to save some space. * Note that this is different from tcp_time_stamp , which * historically has been the same until linux - 4 . 13 . #define tcp_jiffies32 ((u32)jiffies)/* * Deliver a 32 bit value for TCP timestamp option ( RFC 7323 ) * It is no longer tied to jiffies , but to 1 ms clock . * Note : double check if you want to use tcp_jiffies32 instead of this . #define TCP_TS_HZ 1000 static inline u64 tcp_clock_ns(void )return ktime_get_ns();static inline u64 tcp_clock_us(void )return div_u64(tcp_clock_ns(), NSEC_PER_USEC);static inline u64 tcp_clock_ms(void )return div_u64(tcp_clock_ns(), NSEC_PER_MSEC);/* TCP Timestamp included in TS option (RFC 1323) can either use ms * or usec resolution . Each socket carries a flag to select one or other * resolution , as the route attribute could change anytime . * Each flow must stick to initial resolution . static inline u32 tcp_clock_ts(bool usec_ts)return usec_ts ? tcp_clock_us() : tcp_clock_ms();static inline u32 tcp_time_stamp_ms(const struct tcp_sock *tp)return div_u64(tp->tcp_mstamp, USEC_PER_MSEC);static inline u32 tcp_time_stamp_ts(const struct tcp_sock *tp)if (tp->tcp_usec_ts)return tp->tcp_mstamp;return tcp_time_stamp_ms(tp);void tcp_mstamp_refresh(struct tcp_sock *tp);static inline u32 tcp_stamp_us_delta(u64 t1, u64 t0)return max_t(s64, t1 - t0, 0 );/* provide the departure time in us unit */ static inline u64 tcp_skb_timestamp_us(const struct sk_buff *skb)return div_u64(skb->skb_mstamp_ns, NSEC_PER_USEC);/* Provide skb TSval in usec or ms unit */ static inline u32 tcp_skb_timestamp_ts(bool usec_ts, const struct sk_buff *skb)if (usec_ts)return tcp_skb_timestamp_us(skb);return div_u64(skb->skb_mstamp_ns, NSEC_PER_MSEC);static inline u32 tcp_tw_tsval(const struct tcp_timewait_sock *tcptw)return tcp_clock_ts(tcptw->tw_sk.tw_usec_ts) + tcptw->tw_ts_offset;static inline u32 tcp_rsk_tsval(const struct tcp_request_sock *treq)return tcp_clock_ts(treq->req_usec_ts) + treq->ts_off;#define tcp_flag_byte(th) (((u_int8_t *)th)[13 ])#define TCPHDR_FIN BIT(0 )#define TCPHDR_SYN BIT(1 )#define TCPHDR_RST BIT(2 )#define TCPHDR_PSH BIT(3 )#define TCPHDR_ACK BIT(4 )#define TCPHDR_URG BIT(5 )#define TCPHDR_ECE BIT(6 )#define TCPHDR_CWR BIT(7 )#define TCPHDR_AE BIT(8 )#define TCPHDR_FLAGS_MASK (TCPHDR_FIN | TCPHDR_SYN | TCPHDR_RST | \#define tcp_flags_ntohs(th) (ntohs(*(__be16 *)&tcp_flag_word(th)) & \#define TCPHDR_ACE (TCPHDR_ECE | TCPHDR_CWR | TCPHDR_AE)#define TCPHDR_SYN_ECN (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)/* State flags for sacked in struct tcp_skb_cb */ enum tcp_skb_cb_sacked_flags {1 << 0 ), /* SKB ACK'd by a SACK block */ 1 << 1 ), /* SKB retransmitted */ 1 << 2 ), /* SKB is lost */ /* All tag bits */ 1 << 4 ), /* SKB repaired (no skb_mstamp_ns) */ 1 << 7 ), /* Ever retransmitted frame */ /* This is what the send packet queuing engine uses to pass * TCP per - packet control information to the transmission code . * We also store the host - order sequence numbers in here too . * This is 44 bytes if IPV6 is enabled . * If this grows please adjust skbuff . h : skbuff - > cb [ xxx ] size appropriately . struct tcp_skb_cb {/* Starting sequence number */ /* SEQ + FIN + SYN + datalen */ union {/* Note : * tcp_gso_segs / size are used in write queue only , * cf tcp_skb_pcount ( ) / tcp_skb_mss ( ) struct {/* TCP header flags (tcp[12-13])*/ /* State flags for SACK. */ /* IPv4 tos or IPv6 dsfield */ #define TSTAMP_ACK_SK 0 x1#define TSTAMP_ACK_BPF 0 x22 , /* Record TX timestamp for ack? */ 1 , /* Is skb MSG_EOR marked? */ 1 , /* SKB has a RX timestamp */ 4 ;/* Sequence number ACK'd */ union {struct {#define TCPCB_DELIVERED_CE_MASK ((1 U<<20 ) - 1 )/* There is space for up to 24 bytes */ 1 , /* cwnd not fully used? */ 20 ,11 ;/* pkts S/ACKed so far upon tx of skb, incl retrans: */ /* start of send pipeline phase */ /* when we reached the "delivered" count */ /* only used for outgoing skbs */ union {struct inet_skb_parm h4;#if IS_ENABLED(CONFIG_IPV6)struct inet6_skb_parm h6;#endif /* For incoming skbs */ #define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0 ]))extern const struct inet_connection_sock_af_ops ipv4_specific;#if IS_ENABLED(CONFIG_IPV6)/* This is the variant of inet6_iif() that must be used by TCP, * as TCP moves IP6CB into a different location in skb - > cb [ ] static inline int tcp_v6_iif(const struct sk_buff *skb)return TCP_SKB_CB(skb)->header.h6.iif;static inline int tcp_v6_iif_l3_slave(const struct sk_buff *skb)bool l3_slave = ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags);return l3_slave ? skb->skb_iif : TCP_SKB_CB(skb)->header.h6.iif;/* TCP_SKB_CB reference means this can not be used from early demux */ static inline int tcp_v6_sdif(const struct sk_buff *skb)#if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)if (skb && ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags))return TCP_SKB_CB(skb)->header.h6.iif;#endif return 0 ;extern const struct inet_connection_sock_af_ops ipv6_specific;void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb));int tcp_v6_rcv(struct sk_buff *skb));void tcp_v6_early_demux(struct sk_buff *skb);#endif /* TCP_SKB_CB reference means this can not be used from early demux */ static inline int tcp_v4_sdif(struct sk_buff *skb)#if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)if (skb && ipv4_l3mdev_skb(TCP_SKB_CB(skb)->header.h4.flags))return TCP_SKB_CB(skb)->header.h4.iif;#endif return 0 ;/* Due to TSO, an SKB can be composed of multiple actual * packets . To keep these tracked properly , we use this . static inline int tcp_skb_pcount(const struct sk_buff *skb)return TCP_SKB_CB(skb)->tcp_gso_segs;static inline void tcp_skb_pcount_set(struct sk_buff *skb, int segs)static inline void tcp_skb_pcount_add(struct sk_buff *skb, int segs)/* This is valid iff skb is in write queue and tcp_skb_pcount() > 1. */ static inline int tcp_skb_mss(const struct sk_buff *skb)return TCP_SKB_CB(skb)->tcp_gso_size;static inline bool tcp_skb_can_collapse_to(const struct sk_buff *skb)return likely(!TCP_SKB_CB(skb)->eor);static inline bool tcp_skb_can_collapse(const struct sk_buff *to,const struct sk_buff *from)/* skb_cmp_decrypted() not needed, use tcp_write_collapse_fence() */ return likely(tcp_skb_can_collapse_to(to) &&static inline bool tcp_skb_can_collapse_rx(const struct sk_buff *to,const struct sk_buff *from)return likely(mptcp_skb_can_collapse(to, from) &&/* Events passed to congestion control interface */ enum tcp_ca_event {/* first transmit when no packets in flight */ /* congestion window restart */ /* end of congestion recovery */ /* loss timeout */ /* ECT set, but not CE marked */ /* received CE marked IP packet */ /* Information about inbound ACK, passed to cong_ops->in_ack_event() */ enum tcp_ca_ack_event_flags {1 << 0 ), /* In slow path processing */ 1 << 1 ), /* ACK updated window */ 1 << 2 ), /* ECE bit is set on ack */ /* * Interface for adding new TCP congestion control handlers #define TCP_CA_NAME_MAX 16 #define TCP_CA_MAX 128 #define TCP_CA_BUF_MAX (TCP_CA_NAME_MAX*TCP_CA_MAX)#define TCP_CA_UNSPEC 0 /* Algorithm can be set on socket without CAP_NET_ADMIN privileges */ #define TCP_CONG_NON_RESTRICTED BIT(0 )/* Requires ECN/ECT set on all packets */ #define TCP_CONG_NEEDS_ECN BIT(1 )#define TCP_CONG_MASK (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN)union tcp_cc_info;struct ack_sample {/* A rate sample measures the number of (original/retransmitted) data * packets delivered " delivered " over an interval of time " interval_us " . * The tcp_rate . c code fills in the rate sample , and congestion * control modules that define a cong_control function to run at the end * of ACK processing can optionally chose to consult this sample when * setting cwnd and pacing rate . * A sample is invalid if " delivered " or " interval_us " is negative . struct rate_sample {/* starting timestamp for interval */ /* tp->delivered at "prior_mstamp" */ /* tp->delivered_ce at "prior_mstamp" */ /* number of packets delivered over interval */ /* number of packets delivered w/ CE marks*/ long interval_us; /* time for tp->delivered to incr "delivered" */ /* snd interval for delivered packets */ /* rcv interval for delivered packets */ long rtt_us; /* RTT of last (S)ACKed packet (or -1) */ int losses; /* number of packets marked lost upon ACK */ /* number of packets newly (S)ACKed upon ACK */ /* in flight before this ACK */ /* end_seq of most recently ACKed packet */ bool is_app_limited; /* is sample from packet with bubble in pipe? */ bool is_retrans; /* is sample from retransmission? */ bool is_ack_delayed; /* is this (likely) a delayed ACK? */ struct tcp_congestion_ops {/* fast path fields are put first to fill one cache line */ /* return slow start threshold (required) */ struct sock *sk);/* do new cwnd calculation (required) */ void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked);/* call before changing ca_state (optional) */ void (*set_state)(struct sock *sk, u8 new_state);/* call when cwnd event occurs (optional) */ void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);/* call when ack arrives (optional) */ void (*in_ack_event)(struct sock *sk, u32 flags);/* hook for packet ack accounting (optional) */ void (*pkts_acked)(struct sock *sk, const struct ack_sample *sample);/* override sysctl_tcp_min_tso_segs */ struct sock *sk);/* call when packets are delivered to update cwnd and pacing rate, * after all the ca_state processing . ( optional ) void (*cong_control)(struct sock *sk, u32 ack, int flag, const struct rate_sample *rs);/* new value of cwnd after loss (required) */ struct sock *sk);/* returns the multiplier used in tcp_sndbuf_expand (optional) */ struct sock *sk);/* control/slow paths put last */ /* get info for inet_diag (optional) */ struct sock *sk, u32 ext, int *attr,union tcp_cc_info *info);char name[TCP_CA_NAME_MAX];struct module *owner;struct list_head list;/* initialize private data (optional) */ void (*init)(struct sock *sk);/* cleanup private data (optional) */ void (*release)(struct sock *sk);int tcp_register_congestion_control(struct tcp_congestion_ops *type);void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);int tcp_update_congestion_control(struct tcp_congestion_ops *type,struct tcp_congestion_ops *old_type);int tcp_validate_congestion_control(struct tcp_congestion_ops *ca);void tcp_assign_congestion_control(struct sock *sk);void tcp_init_congestion_control(struct sock *sk);void tcp_cleanup_congestion_control(struct sock *sk);int tcp_set_default_congestion_control(struct net *net, const char *name);void tcp_get_default_congestion_control(struct net *net, char *name);void tcp_get_available_congestion_control(char *buf, size_t len);void tcp_get_allowed_congestion_control(char *buf, size_t len);int tcp_set_allowed_congestion_control(char *allowed);int tcp_set_congestion_control(struct sock *sk, const char *name, bool load,bool cap_net_admin);struct tcp_sock *tp, u32 acked);void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w, u32 acked);struct sock *sk);struct sock *sk);void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked);extern struct tcp_congestion_ops tcp_reno;struct tcp_congestion_ops *tcp_ca_find(const char *name);struct tcp_congestion_ops *tcp_ca_find_key(u32 key);const char *name, bool *ecn_ca);#ifdef CONFIG_INETchar *tcp_ca_get_name_by_key(u32 key, char *buffer);#else static inline char *tcp_ca_get_name_by_key(u32 key, char *buffer)return NULL;#endif static inline bool tcp_ca_needs_ecn(const struct sock *sk)const struct inet_connection_sock *icsk = inet_csk(sk);return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ECN;static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)const struct inet_connection_sock *icsk = inet_csk(sk);if (icsk->icsk_ca_ops->cwnd_event)/* From tcp_cong.c */ void tcp_set_ca_state(struct sock *sk, const u8 ca_state);/* From tcp_rate.c */ void tcp_rate_skb_sent(struct sock *sk, struct sk_buff *skb);void tcp_rate_skb_delivered(struct sock *sk, struct sk_buff *skb,struct rate_sample *rs);void tcp_rate_gen(struct sock *sk, u32 delivered, u32 lost,bool is_sack_reneg, struct rate_sample *rs);void tcp_rate_check_app_limited(struct sock *sk);static inline bool tcp_skb_sent_after(u64 t1, u64 t2, u32 seq1, u32 seq2)return t1 > t2 || (t1 == t2 && after(seq1, seq2));/* These functions determine how the current flow behaves in respect of SACK * handling . SACK is negotiated with the peer , and therefore it can vary * between different flows . * * tcp_is_sack - SACK enabled * tcp_is_reno - No SACK static inline int tcp_is_sack(const struct tcp_sock *tp)return likely(tp->rx_opt.sack_ok);static inline bool tcp_is_reno(const struct tcp_sock *tp)return !tcp_is_sack(tp);static inline unsigned int tcp_left_out(const struct tcp_sock *tp)return tp->sacked_out + tp->lost_out;/* This determines how many packets are "in the network" to the best * of our knowledge . In many cases it is conservative , but where * detailed information is available from the receiver ( via SACK * blocks etc . ) we can make more aggressive calculations . * * Use this for decisions involving congestion control , use just * tp - > packets_out to determine if the send queue is empty or not . * * Read this equation as : * * " Packets sent once on transmission queue " MINUS * " Packets left network , but not honestly ACKed yet " PLUS * " Packets fast retransmitted " static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;#define TCP_INFINITE_SSTHRESH 0 x7fffffffstatic inline u32 tcp_snd_cwnd(const struct tcp_sock *tp)return tp->snd_cwnd;static inline void tcp_snd_cwnd_set(struct tcp_sock *tp, u32 val)int )val <= 0 );static inline bool tcp_in_slow_start(const struct tcp_sock *tp)return tcp_snd_cwnd(tp) < tp->snd_ssthresh;static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp)return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;static inline bool tcp_in_cwnd_reduction(const struct sock *sk)return (TCPF_CA_CWR | TCPF_CA_Recovery) &1 << inet_csk(sk)->icsk_ca_state);/* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd. * The exception is cwnd reduction phase , when cwnd is decreasing towards * ssthresh . static inline __u32 tcp_current_ssthresh(const struct sock *sk)const struct tcp_sock *tp = tcp_sk(sk);if (tcp_in_cwnd_reduction(sk))return tp->snd_ssthresh;else return max(tp->snd_ssthresh,1 ) +2 )));/* Use define here intentionally to get WARN_ON location shown at the caller */ #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out)void tcp_enter_cwr(struct sock *sk);const struct tcp_sock *tp, const struct dst_entry *dst);/* The maximum number of MSS of available cwnd for which TSO defers * sending if not using sysctl_tcp_tso_win_divisor . static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp)return 3 ;/* Returns end sequence number of the receiver's advertised window */ static inline u32 tcp_wnd_end(const struct tcp_sock *tp)return tp->snd_una + tp->snd_wnd;/* We follow the spirit of RFC2861 to validate cwnd but implement a more * flexible approach . The RFC suggests cwnd should not be raised unless * it was fully used previously . And that ' s exactly what we do in * congestion avoidance mode . But in slow start we allow cwnd to grow * as long as the application has used half the cwnd . * Example : * cwnd is 10 ( IW10 ) , but application sends 9 frames . * We allow cwnd to reach 18 when all frames are ACKed . * This check is safe because it ' s as aggressive as slow start which already * risks 100 % overshoot . The advantage is that we discourage application to * either send more filler packets or data to artificially blow up the cwnd * usage , and allow application - limited process to probe bw more aggressively . static inline bool tcp_is_cwnd_limited(const struct sock *sk)const struct tcp_sock *tp = tcp_sk(sk);if (tp->is_cwnd_limited)return true ;/* If in slow start, ensure cwnd grows to twice what was ACKed. */ if (tcp_in_slow_start(tp))return tcp_snd_cwnd(tp) < 2 * tp->max_packets_out;return false ;/* BBR congestion control needs pacing. * Same remark for SO_MAX_PACING_RATE . * sch_fq packet scheduler is efficiently handling pacing , * but is not always installed / used . * Return true if TCP stack should pace packets itself . static inline bool tcp_needs_internal_pacing(const struct sock *sk)return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED;/* Estimates in how many jiffies next packet for this flow can be sent. * Scheduling a retransmit timer too early would be silly . static inline unsigned long tcp_pacing_delay(const struct sock *sk)return delay > 0 ? nsecs_to_jiffies(delay) : 0 ;static inline void tcp_reset_xmit_timer(struct sock *sk,const int what,unsigned long when,bool pace_delay)if (pace_delay)/* Something is really bad, we could not queue an additional packet, * because qdisc is full or receiver sent a 0 window , or we are paced . * We do not want to add fuel to the fire , or abort too early , * so make sure the timer we arm now is at least 200 ms in the future , * regardless of current icsk_rto value ( as it could be ~ 2 ms ) static inline unsigned long tcp_probe0_base(const struct sock *sk)return max_t(unsigned long , inet_csk(sk)->icsk_rto, TCP_RTO_MIN);/* Variant of inet_csk_rto_backoff() used for zero window probes */ static inline unsigned long tcp_probe0_when(const struct sock *sk,unsigned long max_when)1 ,return (unsigned long )min_t(u64, when, max_when);static inline void tcp_check_probe_timer(struct sock *sk)if (!tcp_sk(sk)->packets_out && !inet_csk(sk)->icsk_pending)true );static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq)static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq)/* * Calculate ( / check ) TCP checksum static inline __sum16 tcp_v4_check(int len, __be32 saddr,return csum_tcpudp_magic(saddr, daddr, len, IPPROTO_TCP, base);static inline bool tcp_checksum_complete(struct sk_buff *skb)return !skb_csum_unnecessary(skb) &&bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb,enum skb_drop_reason *reason);int tcp_filter(struct sock *sk, struct sk_buff *skb, enum skb_drop_reason *reason);void tcp_set_state(struct sock *sk, int state);void tcp_done(struct sock *sk);int tcp_abort(struct sock *sk, int err);static inline void tcp_sack_reset(struct tcp_options_received *rx_opt)0 ;0 ;void tcp_cwnd_restart(struct sock *sk, s32 delta);static inline void tcp_slow_start_after_idle_check(struct sock *sk)const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;struct tcp_sock *tp = tcp_sk(sk);if (!READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_slow_start_after_idle) ||return ;if (delta > inet_csk(sk)->icsk_rto)/* Determine a window scaling and initial window to offer. */ void tcp_select_initial_window(const struct sock *sk, int __space,int wscale_ok,static inline int __tcp_win_from_space(u8 scaling_ratio, int space)return scaled_space >> TCP_RMEM_TO_WIN_SCALE;static inline int tcp_win_from_space(const struct sock *sk, int space)return __tcp_win_from_space(tcp_sk(sk)->scaling_ratio, space);/* inverse of __tcp_win_from_space() */ static inline int __tcp_space_from_win(u8 scaling_ratio, int win)return val;static inline int tcp_space_from_win(const struct sock *sk, int win)return __tcp_space_from_win(tcp_sk(sk)->scaling_ratio, win);/* Assume a 50% default for skb->len/skb->truesize ratio. * This may be adjusted later in tcp_measure_rcv_mss ( ) . #define TCP_DEFAULT_SCALING_RATIO (1 << (TCP_RMEM_TO_WIN_SCALE - 1 ))static inline void tcp_scaling_ratio_init(struct sock *sk)/* Note: caller must be prepared to deal with negative returns */ static inline int tcp_space(const struct sock *sk)return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf) -static inline int tcp_full_space(const struct sock *sk)return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf));static inline void __tcp_adjust_rcv_ssthresh(struct sock *sk, u32 new_ssthresh)int unused_mem = sk_unused_reserved_mem(sk);struct tcp_sock *tp = tcp_sk(sk);if (unused_mem)static inline void tcp_adjust_rcv_ssthresh(struct sock *sk)4 U * tcp_sk(sk)->advmss);void tcp_cleanup_rbuf(struct sock *sk, int copied);void __tcp_cleanup_rbuf(struct sock *sk, int copied);/* We provision sk_rcvbuf around 200% of sk_rcvlowat. * If 87 . 5 % ( 7 / 8 ) of the space has been consumed , we want to override * SO_RCVLOWAT constraint , since we are receiving skbs with too small * len / truesize ratio . static inline bool tcp_rmem_pressure(const struct sock *sk)int rcvbuf, threshold;if (tcp_under_memory_pressure(sk))return true ;3 );return atomic_read(&sk->sk_rmem_alloc) > threshold;static inline bool tcp_epollin_ready(const struct sock *sk, int target)const struct tcp_sock *tp = tcp_sk(sk);int avail = READ_ONCE(tp->rcv_nxt) - READ_ONCE(tp->copied_seq);if (avail <= 0 )return false ;return (avail >= target) || tcp_rmem_pressure(sk) ||extern void tcp_openreq_init_rwin(struct request_sock *req,const struct sock *sk_listener,const struct dst_entry *dst);void tcp_enter_memory_pressure(struct sock *sk);void tcp_leave_memory_pressure(struct sock *sk);static inline int keepalive_intvl_when(const struct tcp_sock *tp)struct net *net = sock_net((struct sock *)tp);int val;/* Paired with WRITE_ONCE() in tcp_sock_set_keepintvl() * and do_tcp_setsockopt ( ) . return val ? : READ_ONCE(net->ipv4.sysctl_tcp_keepalive_intvl);static inline int keepalive_time_when(const struct tcp_sock *tp)struct net *net = sock_net((struct sock *)tp);int val;/* Paired with WRITE_ONCE() in tcp_sock_set_keepidle_locked() */ return val ? : READ_ONCE(net->ipv4.sysctl_tcp_keepalive_time);static inline int keepalive_probes(const struct tcp_sock *tp)struct net *net = sock_net((struct sock *)tp);int val;/* Paired with WRITE_ONCE() in tcp_sock_set_keepcnt() * and do_tcp_setsockopt ( ) . return val ? : READ_ONCE(net->ipv4.sysctl_tcp_keepalive_probes);static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)const struct inet_connection_sock *icsk = &tp->inet_conn;return min_t(u32, tcp_jiffies32 - icsk->icsk_ack.lrcvtime,static inline int tcp_fin_time(const struct sock *sk)int fin_timeout = tcp_sk(sk)->linger2 ? :const int rto = inet_csk(sk)->icsk_rto;if (fin_timeout < (rto << 2 ) - (rto >> 1 ))2 ) - (rto >> 1 );return fin_timeout;static inline bool tcp_paws_check(const struct tcp_options_received *rx_opt,int paws_win)if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win)return true ;if (unlikely(!time_before32(ktime_get_seconds(),return true ;/* * Some OSes send SYN and SYNACK messages with tsval = 0 tsecr = 0 , * then following tcp messages have valid values . Ignore 0 value , * or else ' negative ' tsval might forbid us to accept their packets . if (!rx_opt->ts_recent)return true ;return false ;static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt,int rst)if (tcp_paws_check(rx_opt, 0 ))return false ;/* RST segments are not recommended to carry timestamp, and , if they do , it is recommended to ignore PAWS because " their cleanup function should take precedence over timestamps . " Certainly , it is mistake . It is necessary to understand the reasons of this constraint to relax it : if peer reboots , clock may go out - of - sync and half - open connections will not be reset . Actually , the problem would be not existing if all the implementations followed draft about maintaining clock via reboots . Linux - 2 . 2 DOES NOT ! However , we can relax time bounds for RST segments to MSL . if (rst && !time_before32(ktime_get_seconds(),return false ;return true ;bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,int mib_idx, u32 *last_oow_ack_time);static inline void tcp_mib_init(struct net *net)/* See RFC 2012 */ 1 );1000 /HZ);1000 /HZ);1 );/* from STCP */ static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)#define tcp_md5_addr tcp_ao_addr/* - key database */ struct tcp_md5sig_key {struct hlist_node node;/* AF_INET or AF_INET6 */ union tcp_md5_addr addr;int l3index; /* set if key added with L3 scope */ struct rcu_head rcu;/* - sock block */ struct tcp_md5sig_info {struct hlist_head head;struct rcu_head rcu;/* - pseudo header */ struct tcp4_pseudohdr {struct tcp6_pseudohdr {struct in6_addr saddr;struct in6_addr daddr;/* including padding */ union tcp_md5sum_block {struct tcp4_pseudohdr ip4;#if IS_ENABLED(CONFIG_IPV6)struct tcp6_pseudohdr ip6;#endif /* * struct tcp_sigpool - per - CPU pool of ahash_requests * @ scratch : per - CPU temporary area , that can be used between * tcp_sigpool_start ( ) and tcp_sigpool_end ( ) to perform * crypto request * @ req : pre - allocated ahash request struct tcp_sigpool {void *scratch;struct ahash_request *req;int tcp_sigpool_alloc_ahash(const char *alg, size_t scratch_size);void tcp_sigpool_get(unsigned int id);void tcp_sigpool_release(unsigned int id);int tcp_sigpool_hash_skb_data(struct tcp_sigpool *hp,const struct sk_buff *skb,unsigned int header_len);/** * tcp_sigpool_start - disable bh and start using tcp_sigpool_ahash * @ id : tcp_sigpool that was previously allocated by tcp_sigpool_alloc_ahash ( ) * @ c : returned tcp_sigpool for usage ( uninitialized on failure ) * * Returns : 0 on success , error otherwise . int tcp_sigpool_start(unsigned int id, struct tcp_sigpool *c);/** * tcp_sigpool_end - enable bh and stop using tcp_sigpool * @ c : tcp_sigpool context that was returned by tcp_sigpool_start ( ) void tcp_sigpool_end(struct tcp_sigpool *c);unsigned int id, char *buf, size_t buf_len);/* - functions */ int tcp_v4_md5_hash_skb(char *md5_hash, const struct tcp_md5sig_key *key,const struct sock *sk, const struct sk_buff *skb);int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,int family, u8 prefixlen, int l3index, u8 flags,const u8 *newkey, u8 newkeylen);int tcp_md5_key_copy(struct sock *sk, const union tcp_md5_addr *addr,int family, u8 prefixlen, int l3index,struct tcp_md5sig_key *key);int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr,int family, u8 prefixlen, int l3index, u8 flags);void tcp_clear_md5_list(struct sock *sk);struct tcp_md5sig_key *tcp_v4_md5_lookup(const struct sock *sk,const struct sock *addr_sk);#ifdef CONFIG_TCP_MD5SIGstruct tcp_md5sig_key *__tcp_md5_do_lookup(const struct sock *sk, int l3index,const union tcp_md5_addr *addr,int family, bool any_l3index);static inline struct tcp_md5sig_key *const struct sock *sk, int l3index,const union tcp_md5_addr *addr, int family)if (!static_branch_unlikely(&tcp_md5_needed.key))return NULL;return __tcp_md5_do_lookup(sk, l3index, addr, family, false );static inline struct tcp_md5sig_key *const struct sock *sk,const union tcp_md5_addr *addr, int family)if (!static_branch_unlikely(&tcp_md5_needed.key))return NULL;return __tcp_md5_do_lookup(sk, 0 , addr, family, true );#define tcp_twsk_md5_key(twsk) ((twsk)->tw_md5_key)#else static inline struct tcp_md5sig_key *const struct sock *sk, int l3index,const union tcp_md5_addr *addr, int family)return NULL;static inline struct tcp_md5sig_key *const struct sock *sk,const union tcp_md5_addr *addr, int family)return NULL;#define tcp_twsk_md5_key(twsk) NULL#endif int tcp_md5_alloc_sigpool(void );void tcp_md5_release_sigpool(void );void tcp_md5_add_sigpool(void );extern int tcp_md5_sigpool_id;int tcp_md5_hash_key(struct tcp_sigpool *hp,const struct tcp_md5sig_key *key);/* From tcp_fastopen.c */ void tcp_fastopen_cache_get(struct sock *sk, u16 *mss,struct tcp_fastopen_cookie *cookie);void tcp_fastopen_cache_set(struct sock *sk, u16 mss,struct tcp_fastopen_cookie *cookie, bool syn_lost,struct tcp_fastopen_request {/* Fast Open cookie. Size 0 means a cookie request */ struct tcp_fastopen_cookie cookie;struct msghdr *data; /* data in MSG_FASTOPEN */ int copied; /* queued in tcp_connect() */ struct ubuf_info *uarg;void tcp_free_fastopen_req(struct tcp_sock *tp);void tcp_fastopen_destroy_cipher(struct sock *sk);void tcp_fastopen_ctx_destroy(struct net *net);int tcp_fastopen_reset_cipher(struct net *net, struct sock *sk,void *primary_key, void *backup_key);int tcp_fastopen_get_cipher(struct net *net, struct inet_connection_sock *icsk,void tcp_fastopen_add_skb(struct sock *sk, struct sk_buff *skb);struct sock *tcp_try_fastopen(struct sock *sk, struct sk_buff *skb,struct request_sock *req,struct tcp_fastopen_cookie *foc,const struct dst_entry *dst);void tcp_fastopen_init_key_once(struct net *net);bool tcp_fastopen_cookie_check(struct sock *sk, u16 *mss,struct tcp_fastopen_cookie *cookie);bool tcp_fastopen_defer_connect(struct sock *sk, int *err);#define TCP_FASTOPEN_KEY_LENGTH sizeof (siphash_key_t)#define TCP_FASTOPEN_KEY_MAX 2 #define TCP_FASTOPEN_KEY_BUF_LENGTH \/* Fastopen key context */ struct tcp_fastopen_context {int num;struct rcu_head rcu;void tcp_fastopen_active_disable(struct sock *sk);bool tcp_fastopen_active_should_disable(struct sock *sk);void tcp_fastopen_active_disable_ofo_check(struct sock *sk);void tcp_fastopen_active_detect_blackhole(struct sock *sk, bool expired);/* Caller needs to wrap with rcu_read_(un)lock() */ static inline struct tcp_fastopen_context *tcp_fastopen_get_ctx(const struct sock *sk)struct tcp_fastopen_context *ctx;if (!ctx)return ctx;static inline bool tcp_fastopen_cookie_match(const struct tcp_fastopen_cookie *foc,const struct tcp_fastopen_cookie *orig)if (orig->len == TCP_FASTOPEN_COOKIE_SIZE &&return true ;return false ;static inline int tcp_fastopen_context_len(const struct tcp_fastopen_context *ctx)return ctx->num;/* Latencies incurred by various limits for a sender. They are * chronograph - like stats that are mutually exclusive . enum tcp_chrono {/* Actively sending data (non-empty write queue) */ /* Stalled by insufficient receive window */ /* Stalled by insufficient send buffer */ void tcp_chrono_start(struct sock *sk, const enum tcp_chrono type);void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type);/* This helper is needed, because skb->tcp_tsorted_anchor uses * the same memory storage than skb - > destructor / _ skb_refdst static inline void tcp_skb_tsorted_anchor_cleanup(struct sk_buff *skb)0 UL;#define tcp_skb_tsorted_save(skb) { \unsigned long _save = skb->_skb_refdst; \0 UL;#define tcp_skb_tsorted_restore(skb) \void tcp_write_queue_purge(struct sock *sk);static inline struct sk_buff *tcp_rtx_queue_head(const struct sock *sk)return skb_rb_first(&sk->tcp_rtx_queue);static inline struct sk_buff *tcp_rtx_queue_tail(const struct sock *sk)return skb_rb_last(&sk->tcp_rtx_queue);static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk)return skb_peek_tail(&sk->sk_write_queue);#define tcp_for_write_queue_from_safe(skb, tmp, sk) \static inline struct sk_buff *tcp_send_head(const struct sock *sk)return skb_peek(&sk->sk_write_queue);static inline bool tcp_skb_is_last(const struct sock *sk,const struct sk_buff *skb)return skb_queue_is_last(&sk->sk_write_queue, skb);/** * tcp_write_queue_empty - test if any payload ( or FIN ) is available in write queue * @ sk : socket * * Since the write queue can have a temporary empty skb in it , * we must not use " return skb_queue_empty ( & sk - > sk_write_queue ) " static inline bool tcp_write_queue_empty(const struct sock *sk)const struct tcp_sock *tp = tcp_sk(sk);return tp->write_seq == tp->snd_nxt;static inline bool tcp_rtx_queue_empty(const struct sock *sk)return RB_EMPTY_ROOT(&sk->tcp_rtx_queue);static inline bool tcp_rtx_and_write_queues_empty(const struct sock *sk)return tcp_rtx_queue_empty(sk) && tcp_write_queue_empty(sk);static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)/* Queue it, remembering where we must start sending. */ if (sk->sk_write_queue.next == skb)/* Insert new before skb on the write queue of sk. */ static inline void tcp_insert_write_queue_before(struct sk_buff *new ,struct sk_buff *skb,struct sock *sk)new );static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk)void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb);static inline void tcp_rtx_queue_unlink(struct sk_buff *skb, struct sock *sk)static inline void tcp_rtx_queue_unlink_and_free(struct sk_buff *skb, struct sock *sk)static inline void tcp_write_collapse_fence(struct sock *sk)struct sk_buff *skb = tcp_write_queue_tail(sk);if (skb)1 ;static inline void tcp_push_pending_frames(struct sock *sk)if (tcp_send_head(sk)) {struct tcp_sock *tp = tcp_sk(sk);/* Start sequence of the skb just after the highest skb with SACKed * bit , valid only if sacked_out > 0 or when the caller has ensured * validity by itself . static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp)if (!tp->sacked_out)return tp->snd_una;if (tp->highest_sack == NULL)return tp->snd_nxt;return TCP_SKB_CB(tp->highest_sack)->seq;static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb)static inline struct sk_buff *tcp_highest_sack(struct sock *sk)return tcp_sk(sk)->highest_sack;static inline void tcp_highest_sack_reset(struct sock *sk)/* Called when old skb is about to be deleted and replaced by new skb */ static inline void tcp_highest_sack_replace(struct sock *sk,struct sk_buff *old,struct sk_buff *new )if (old == tcp_highest_sack(sk))new ;/* This helper checks if socket has IP_TRANSPARENT set */ static inline bool inet_sk_transparent(const struct sock *sk)switch (sk->sk_state) {case TCP_TIME_WAIT:return inet_twsk(sk)->tw_transparent;case TCP_NEW_SYN_RECV:return inet_rsk(inet_reqsk(sk))->no_srccheck;return inet_test_bit(TRANSPARENT, sk);/* Determines whether this is a thin stream (which may suffer from * increased latency ) . Used to trigger latency - reducing mechanisms . static inline bool tcp_stream_is_thin(struct tcp_sock *tp)return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp);/* /proc */ enum tcp_seq_states {void *tcp_seq_start(struct seq_file *seq, loff_t *pos);void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos);void tcp_seq_stop(struct seq_file *seq, void *v);struct tcp_seq_afinfo {struct tcp_iter_state {struct seq_net_private p;enum tcp_seq_states state;struct sock *syn_wait_sk;int bucket, offset, sbucket, num;extern struct request_sock_ops tcp_request_sock_ops;extern struct request_sock_ops tcp6_request_sock_ops;void tcp_v4_destroy_sock(struct sock *sk);struct sk_buff *tcp_gso_segment(struct sk_buff *skb,struct tcphdr *tcp_gro_pull_header(struct sk_buff *skb);struct sk_buff *tcp_gro_lookup(struct list_head *head, struct tcphdr *th);struct sk_buff *tcp_gro_receive(struct list_head *head, struct sk_buff *skb,struct tcphdr *th);int tcp4_gro_complete(struct sk_buff *skb, int thoff));struct sk_buff *tcp4_gro_receive(struct list_head *head, struct sk_buff *skb));int tcp6_gro_complete(struct sk_buff *skb, int thoff));struct sk_buff *tcp6_gro_receive(struct list_head *head, struct sk_buff *skb));#ifdef CONFIG_INETvoid tcp_gro_complete(struct sk_buff *skb);#else static inline void tcp_gro_complete(struct sk_buff *skb) { }#endif void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr);static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp)struct net *net = sock_net((struct sock *)tp);return val ?: READ_ONCE(net->ipv4.sysctl_tcp_notsent_lowat);bool tcp_stream_memory_free(const struct sock *sk, int wake);#ifdef CONFIG_PROC_FSint tcp4_proc_init(void );void tcp4_proc_exit(void );#endif int tcp_rtx_synack(const struct sock *sk, struct request_sock *req);int tcp_conn_request(struct request_sock_ops *rsk_ops,const struct tcp_request_sock_ops *af_ops,struct sock *sk, struct sk_buff *skb);/* TCP af-specific functions */ struct tcp_sock_af_ops {#ifdef CONFIG_TCP_MD5SIGstruct tcp_md5sig_key *(*md5_lookup) (const struct sock *sk,const struct sock *addr_sk);int (*calc_md5_hash)(char *location,const struct tcp_md5sig_key *md5,const struct sock *sk,const struct sk_buff *skb);int (*md5_parse)(struct sock *sk,int optname,int optlen);#endif #ifdef CONFIG_TCP_AOint (*ao_parse)(struct sock *sk, int optname, sockptr_t optval, int optlen);struct tcp_ao_key *(*ao_lookup)(const struct sock *sk,struct sock *addr_sk,int sndid, int rcvid);int (*ao_calc_key_sk)(struct tcp_ao_key *mkt, u8 *key,const struct sock *sk,bool send);int (*calc_ao_hash)(char *location, struct tcp_ao_key *ao,const struct sock *sk, const struct sk_buff *skb,const u8 *tkey, int hash_offset, u32 sne);#endif struct tcp_request_sock_ops {#ifdef CONFIG_TCP_MD5SIGstruct tcp_md5sig_key *(*req_md5_lookup)(const struct sock *sk,const struct sock *addr_sk);int (*calc_md5_hash) (char *location,const struct tcp_md5sig_key *md5,const struct sock *sk,const struct sk_buff *skb);#endif #ifdef CONFIG_TCP_AOstruct tcp_ao_key *(*ao_lookup)(const struct sock *sk,struct request_sock *req,int sndid, int rcvid);int (*ao_calc_key)(struct tcp_ao_key *mkt, u8 *key, struct request_sock *sk);int (*ao_synack_hash)(char *ao_hash, struct tcp_ao_key *mkt,struct request_sock *req, const struct sk_buff *skb,int hash_offset, u32 sne);#endif #ifdef CONFIG_SYN_COOKIESconst struct sk_buff *skb,#endif struct dst_entry *(*route_req)(const struct sock *sk,struct sk_buff *skb,struct flowi *fl,struct request_sock *req,const struct sk_buff *skb);const struct net *net, const struct sk_buff *skb);int (*send_synack)(const struct sock *sk, struct dst_entry *dst,struct flowi *fl, struct request_sock *req,struct tcp_fastopen_cookie *foc,enum tcp_synack_type synack_type,struct sk_buff *syn_skb);extern const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops;#if IS_ENABLED(CONFIG_IPV6)extern const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops;#endif #ifdef CONFIG_SYN_COOKIESstatic inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops,const struct sock *sk, struct sk_buff *skb,return ops->cookie_init_seq(skb, mss);#else static inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops,const struct sock *sk, struct sk_buff *skb,return 0 ;#endif struct tcp_key {union {struct {struct tcp_ao_key *ao_key;char *traffic_key;struct tcp_md5sig_key *md5_key;enum {0 ,static inline void tcp_get_current_key(const struct sock *sk,struct tcp_key *out)#if defined (CONFIG_TCP_AO) || defined (CONFIG_TCP_MD5SIG)const struct tcp_sock *tp = tcp_sk(sk);#endif #ifdef CONFIG_TCP_AOif (static_branch_unlikely(&tcp_ao_needed.key)) {struct tcp_ao_info *ao;if (ao) {return ;#endif #ifdef CONFIG_TCP_MD5SIGif (static_branch_unlikely(&tcp_md5_needed.key) &&if (out->md5_key) {return ;#endif static inline bool tcp_key_is_md5(const struct tcp_key *key)if (static_branch_tcp_md5())return key->type == TCP_KEY_MD5;return false ;static inline bool tcp_key_is_ao(const struct tcp_key *key)if (static_branch_tcp_ao())return key->type == TCP_KEY_AO;return false ;int tcpv4_offload_init(void );void tcp_v4_init(void );void tcp_init(void );/* tcp_recovery.c */ void tcp_mark_skb_lost(struct sock *sk, struct sk_buff *skb);void tcp_newreno_mark_lost(struct sock *sk, bool snd_una_advanced);extern s32 tcp_rack_skb_timeout(struct tcp_sock *tp, struct sk_buff *skb,extern bool tcp_rack_mark_lost(struct sock *sk);extern void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq,extern void tcp_rack_reo_timeout(struct sock *sk);extern void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs);/* tcp_plb.c */ /* * Scaling factor for fractions in PLB . For example , tcp_plb_update_state * expects cong_ratio which represents fraction of traffic that experienced * congestion over a single RTT . In order to avoid floating point operations , * this fraction should be mapped to ( 1 < < TCP_PLB_SCALE ) and passed in . #define TCP_PLB_SCALE 8 /* State for PLB (Protective Load Balancing) for a single TCP connection. */ struct tcp_plb_state {5 , /* consecutive congested rounds */ 3 ;/* jiffies32 when PLB can resume rerouting */ static inline void tcp_plb_init(const struct sock *sk,struct tcp_plb_state *plb)0 ;0 ;void tcp_plb_update_state(const struct sock *sk, struct tcp_plb_state *plb,const int cong_ratio);void tcp_plb_check_rehash(struct sock *sk, struct tcp_plb_state *plb);void tcp_plb_update_state_upon_rto(struct sock *sk, struct tcp_plb_state *plb);static inline void tcp_warn_once(const struct sock *sk, bool cond, const char *str)"%scwn:%u out:%u sacked:%u lost:%u retrans:%u tlp_high_seq:%u sk_state:%u ca_state:%u advmss:%u mss_cache:%u pmtu:%u\n" ,/* At how many usecs into the future should the RTO fire? */ static inline s64 tcp_rto_delta_us(const struct sock *sk)const struct sk_buff *skb = tcp_rtx_queue_head(sk);if (likely(skb)) {return rto_time_stamp_us - tcp_sk(sk)->tcp_mstamp;else {1 , "rtx queue empty: " );return jiffies_to_usecs(rto);/* * Save and compile IPv4 options , return a pointer to it static inline struct ip_options_rcu *tcp_v4_save_options(struct net *net,struct sk_buff *skb)const struct ip_options *opt = &TCP_SKB_CB(skb)->header.h4.opt;struct ip_options_rcu *dopt = NULL;if (opt->optlen) {int opt_size = sizeof (*dopt) + opt->optlen;if (dopt && __ip_options_echo(net, &dopt->opt, skb, opt)) {return dopt;/* locally generated TCP pure ACKs have skb->truesize == 2 * ( check tcp_send_ack ( ) in net / ipv4 / tcp_output . c ) * This is much faster than dissecting the packet to find out . * ( Think of GRE encapsulations , IPv4 , IPv6 , . . . ) static inline bool skb_is_tcp_pure_ack(const struct sk_buff *skb)return skb->truesize == 2 ;static inline void skb_set_tcp_pure_ack(struct sk_buff *skb)2 ;static inline int tcp_inq(struct sock *sk)struct tcp_sock *tp = tcp_sk(sk);int answ;if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {0 ;else if (sock_flag(sk, SOCK_URGINLINE) ||/* Subtract 1, if FIN was received */ if (answ && sock_flag(sk, SOCK_DONE))else {return answ;int tcp_peek_len(struct socket *sock);static inline void tcp_segs_in(struct tcp_sock *tp, const struct sk_buff *skb)1 , skb_shinfo(skb)->gso_segs);/* We update these fields while other threads might * read them from tcp_get_info ( ) if (skb->len > tcp_hdrlen(skb))/* * TCP listen path runs lockless . * We forced " struct sock " to be const qualified to make sure * we don ' t modify one of its field by mistake . * Here , we increment sk_drops which is an atomic_t , so we can safely * make sock writable again . static inline void tcp_listendrop(const struct sock *sk)struct sock *)sk)->sk_drops);enum hrtimer_restart tcp_pace_kick(struct hrtimer *timer);/* * Interface for adding Upper Level Protocols over TCP #define TCP_ULP_NAME_MAX 16 #define TCP_ULP_MAX 128 #define TCP_ULP_BUF_MAX (TCP_ULP_NAME_MAX*TCP_ULP_MAX)struct tcp_ulp_ops {struct list_head list;/* initialize ulp */ int (*init)(struct sock *sk);/* update ulp */ void (*update)(struct sock *sk, struct proto *p,void (*write_space)(struct sock *sk));/* cleanup ulp */ void (*release)(struct sock *sk);/* diagnostic */ int (*get_info)(struct sock *sk, struct sk_buff *skb, bool net_admin);const struct sock *sk, bool net_admin);/* clone ulp */ void (*clone)(const struct request_sock *req, struct sock *newsk,const gfp_t priority);char name[TCP_ULP_NAME_MAX];struct module *owner;int tcp_register_ulp(struct tcp_ulp_ops *type);void tcp_unregister_ulp(struct tcp_ulp_ops *type);int tcp_set_ulp(struct sock *sk, const char *name);void tcp_get_available_ulp(char *buf, size_t len);void tcp_cleanup_ulp(struct sock *sk);void tcp_update_ulp(struct sock *sk, struct proto *p,void (*write_space)(struct sock *sk));#define MODULE_ALIAS_TCP_ULP(name) \"tcp-ulp-" name)#ifdef CONFIG_NET_SOCK_MSGstruct sk_msg;struct sk_psock;#ifdef CONFIG_BPF_SYSCALLint tcp_bpf_update_proto(struct sock *sk, struct sk_psock *psock, bool restore);void tcp_bpf_clone(const struct sock *sk, struct sock *newsk);#ifdef CONFIG_BPF_STREAM_PARSERstruct strparser;int tcp_bpf_strp_read_sock(struct strparser *strp, read_descriptor_t *desc,#endif /* CONFIG_BPF_STREAM_PARSER */ #endif /* CONFIG_BPF_SYSCALL */ #ifdef CONFIG_INETvoid tcp_eat_skb(struct sock *sk, struct sk_buff *skb);#else static inline void tcp_eat_skb(struct sock *sk, struct sk_buff *skb)#endif int tcp_bpf_sendmsg_redir(struct sock *sk, bool ingress,struct sk_msg *msg, u32 bytes, int flags);#endif /* CONFIG_NET_SOCK_MSG */ #if !defined (CONFIG_BPF_SYSCALL) || !defined (CONFIG_NET_SOCK_MSG)static inline void tcp_bpf_clone(const struct sock *sk, struct sock *newsk)#endif #ifdef CONFIG_CGROUP_BPFstatic inline void bpf_skops_init_skb(struct bpf_sock_ops_kern *skops,struct sk_buff *skb,unsigned int end_offset)#else static inline void bpf_skops_init_skb(struct bpf_sock_ops_kern *skops,struct sk_buff *skb,unsigned int end_offset)#endif /* Call BPF_SOCK_OPS program that returns an int. If the return value * is < 0 , then the BPF op failed ( for example if the loaded BPF * program does not support the chosen operation or there is no BPF * program loaded ) . #ifdef CONFIG_BPFstatic inline int tcp_call_bpf(struct sock *sk, int op, u32 nargs, u32 *args)struct bpf_sock_ops_kern sock_ops;int ret;0 , offsetof(struct bpf_sock_ops_kern, temp));if (sk_fullsock(sk)) {1 ;1 ;if (nargs > 0 )sizeof (*args));if (ret == 0 )else 1 ;return ret;static inline int tcp_call_bpf_2arg(struct sock *sk, int op, u32 arg1, u32 arg2)2 ] = {arg1, arg2};return tcp_call_bpf(sk, op, 2 , args);static inline int tcp_call_bpf_3arg(struct sock *sk, int op, u32 arg1, u32 arg2,3 ] = {arg1, arg2, arg3};return tcp_call_bpf(sk, op, 3 , args);#else static inline int tcp_call_bpf(struct sock *sk, int op, u32 nargs, u32 *args)return -EPERM;static inline int tcp_call_bpf_2arg(struct sock *sk, int op, u32 arg1, u32 arg2)return -EPERM;static inline int tcp_call_bpf_3arg(struct sock *sk, int op, u32 arg1, u32 arg2,return -EPERM;#endif static inline u32 tcp_timeout_init(struct sock *sk)int timeout;0 , NULL);if (timeout <= 0 )return min_t(int , timeout, TCP_RTO_MAX);static inline u32 tcp_rwnd_init_bpf(struct sock *sk)int rwnd;0 , NULL);if (rwnd < 0 )0 ;return rwnd;static inline bool tcp_bpf_ca_needs_ecn(struct sock *sk)return (tcp_call_bpf(sk, BPF_SOCK_OPS_NEEDS_ECN, 0 , NULL) == 1 );static inline void tcp_bpf_rtt(struct sock *sk, long mrtt, u32 srtt)if (BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk), BPF_SOCK_OPS_RTT_CB_FLAG))#if IS_ENABLED(CONFIG_SMC)extern struct static_key_false tcp_have_smc;#endif #if IS_ENABLED(CONFIG_TLS_DEVICE)void clean_acked_data_enable(struct tcp_sock *tp,void (*cad)(struct sock *sk, u32 ack_seq));void clean_acked_data_disable(struct tcp_sock *tp);void clean_acked_data_flush(void );#endif static inline void tcp_add_tx_delay(struct sk_buff *skb,const struct tcp_sock *tp)if (static_branch_unlikely(&tcp_tx_delay_enabled))/* Compute Earliest Departure Time for some control packets * like ACK or RST for TIME_WAIT or non ESTABLISHED sockets . static inline u64 tcp_transmit_time(const struct sock *sk)if (static_branch_unlikely(&tcp_tx_delay_enabled)) {return tcp_clock_ns() + (u64)delay * NSEC_PER_USEC;return 0 ;static inline int tcp_parse_auth_options(const struct tcphdr *th,const u8 **md5_hash, const struct tcp_ao_hdr **aoh)const u8 *md5_tmp, *ao_tmp;int ret;if (ret)return ret;if (md5_hash)if (aoh) {if (!ao_tmp)else struct tcp_ao_hdr *)(ao_tmp - 2 );return 0 ;static inline bool tcp_ao_required(struct sock *sk, const void *saddr,int family, int l3index, bool stat_inc)#ifdef CONFIG_TCP_AOstruct tcp_ao_info *ao_info;struct tcp_ao_key *ao_key;if (!static_branch_unlikely(&tcp_ao_needed.key))return false ;if (!ao_info)return false ;1 , -1 );if (ao_info->ao_required || ao_key) {if (stat_inc) {return true ;#endif return false ;enum skb_drop_reason tcp_inbound_hash(struct sock *sk,const struct request_sock *req, const struct sk_buff *skb,const void *saddr, const void *daddr,int family, int dif, int sdif);#endif /* _TCP_H */
Messung V0.5 in Prozent C=92 H=100 G=95
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.58Bemerkung:
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-28)
¤ *Eine klare Vorstellung vom Zielzustand
2026-10-10
Neuigkeiten Aktuelles Motto des Tages letze Version des Elbe Quellennavigators
Jenseits des Üblichen ....
Besucher
Statistik #Sources=1126438 #Domains=1897691
