1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  * NET		Generic infrastructure for INET connection oriented protocols.
4  *
5  *		Definitions for inet_connection_sock
6  *
7  * Authors:	Many people, see the TCP sources
8  *
9  * 		From code originally in TCP
10  */
11 #ifndef _INET_CONNECTION_SOCK_H
12 #define _INET_CONNECTION_SOCK_H
13 
14 #include <linux/compiler.h>
15 #include <linux/string.h>
16 #include <linux/timer.h>
17 #include <linux/poll.h>
18 #include <linux/kernel.h>
19 #include <linux/sockptr.h>
20 
21 #include <net/inet_sock.h>
22 #include <net/request_sock.h>
23 
24 /* Cancel timers, when they are not required. */
25 #undef INET_CSK_CLEAR_TIMERS
26 
27 struct inet_bind_bucket;
28 struct tcp_congestion_ops;
29 
30 /*
31  * Pointers to address related TCP functions
32  * (i.e. things that depend on the address family)
33  */
34 struct inet_connection_sock_af_ops {
35 	int	    (*queue_xmit)(struct sock *sk, struct sk_buff *skb, struct flowi *fl);
36 	void	    (*send_check)(struct sock *sk, struct sk_buff *skb);
37 	int	    (*rebuild_header)(struct sock *sk);
38 	void	    (*sk_rx_dst_set)(struct sock *sk, const struct sk_buff *skb);
39 	int	    (*conn_request)(struct sock *sk, struct sk_buff *skb);
40 	struct sock *(*syn_recv_sock)(const struct sock *sk, struct sk_buff *skb,
41 				      struct request_sock *req,
42 				      struct dst_entry *dst,
43 				      struct request_sock *req_unhash,
44 				      bool *own_req);
45 	u16	    net_header_len;
46 	u16	    net_frag_header_len;
47 	u16	    sockaddr_len;
48 	int	    (*setsockopt)(struct sock *sk, int level, int optname,
49 				  sockptr_t optval, unsigned int optlen);
50 	int	    (*getsockopt)(struct sock *sk, int level, int optname,
51 				  char __user *optval, int __user *optlen);
52 	void	    (*addr2sockaddr)(struct sock *sk, struct sockaddr *);
53 	void	    (*mtu_reduced)(struct sock *sk);
54 };
55 
56 /** inet_connection_sock - INET connection oriented sock
57  *
58  * @icsk_accept_queue:	   FIFO of established children
59  * @icsk_bind_hash:	   Bind node
60  * @icsk_timeout:	   Timeout
61  * @icsk_retransmit_timer: Resend (no ack)
62  * @icsk_rto:		   Retransmit timeout
63  * @icsk_pmtu_cookie	   Last pmtu seen by socket
64  * @icsk_ca_ops		   Pluggable congestion control hook
65  * @icsk_af_ops		   Operations which are AF_INET{4,6} specific
66  * @icsk_ulp_ops	   Pluggable ULP control hook
67  * @icsk_ulp_data	   ULP private data
68  * @icsk_clean_acked	   Clean acked data hook
69  * @icsk_ca_state:	   Congestion control state
70  * @icsk_retransmits:	   Number of unrecovered [RTO] timeouts
71  * @icsk_pending:	   Scheduled timer event
72  * @icsk_backoff:	   Backoff
73  * @icsk_syn_retries:      Number of allowed SYN (or equivalent) retries
74  * @icsk_probes_out:	   unanswered 0 window probes
75  * @icsk_ext_hdr_len:	   Network protocol overhead (IP/IPv6 options)
76  * @icsk_ack:		   Delayed ACK control data
77  * @icsk_mtup;		   MTU probing control data
78  * @icsk_probes_tstamp:    Probe timestamp (cleared by non-zero window ack)
79  * @icsk_user_timeout:	   TCP_USER_TIMEOUT value
80  */
81 struct inet_connection_sock {
82 	/* inet_sock has to be the first member! */
83 	struct inet_sock	  icsk_inet;
84 	struct request_sock_queue icsk_accept_queue;
85 	struct inet_bind_bucket	  *icsk_bind_hash;
86 	unsigned long		  icsk_timeout;
87  	struct timer_list	  icsk_retransmit_timer;
88  	struct timer_list	  icsk_delack_timer;
89 	__u32			  icsk_rto;
90 	__u32                     icsk_rto_min;
91 	__u32                     icsk_delack_max;
92 	__u32			  icsk_pmtu_cookie;
93 	const struct tcp_congestion_ops *icsk_ca_ops;
94 	const struct inet_connection_sock_af_ops *icsk_af_ops;
95 	const struct tcp_ulp_ops  *icsk_ulp_ops;
96 	void __rcu		  *icsk_ulp_data;
97 	void (*icsk_clean_acked)(struct sock *sk, u32 acked_seq);
98 	unsigned int		  (*icsk_sync_mss)(struct sock *sk, u32 pmtu);
99 	__u8			  icsk_ca_state:5,
100 				  icsk_ca_initialized:1,
101 				  icsk_ca_setsockopt:1,
102 				  icsk_ca_dst_locked:1;
103 	__u8			  icsk_retransmits;
104 	__u8			  icsk_pending;
105 	__u8			  icsk_backoff;
106 	__u8			  icsk_syn_retries;
107 	__u8			  icsk_probes_out;
108 	__u16			  icsk_ext_hdr_len;
109 	struct {
110 		__u8		  pending;	 /* ACK is pending			   */
111 		__u8		  quick;	 /* Scheduled number of quick acks	   */
112 		__u8		  pingpong;	 /* The session is interactive		   */
113 		__u8		  retry;	 /* Number of attempts			   */
114 		__u32		  ato;		 /* Predicted tick of soft clock	   */
115 		unsigned long	  timeout;	 /* Currently scheduled timeout		   */
116 		__u32		  lrcvtime;	 /* timestamp of last received data packet */
117 		__u16		  last_seg_size; /* Size of last incoming segment	   */
118 		__u16		  rcv_mss;	 /* MSS used for delayed ACK decisions	   */
119 	} icsk_ack;
120 	struct {
121 		/* Range of MTUs to search */
122 		int		  search_high;
123 		int		  search_low;
124 
125 		/* Information on the current probe. */
126 		u32		  probe_size:31,
127 		/* Is the MTUP feature enabled for this connection? */
128 				  enabled:1;
129 
130 		u32		  probe_timestamp;
131 	} icsk_mtup;
132 	u32			  icsk_probes_tstamp;
133 	u32			  icsk_user_timeout;
134 
135 	u64			  icsk_ca_priv[104 / sizeof(u64)];
136 #define ICSK_CA_PRIV_SIZE	  sizeof_field(struct inet_connection_sock, icsk_ca_priv)
137 };
138 
139 #define ICSK_TIME_RETRANS	1	/* Retransmit timer */
140 #define ICSK_TIME_DACK		2	/* Delayed ack timer */
141 #define ICSK_TIME_PROBE0	3	/* Zero window probe timer */
142 #define ICSK_TIME_LOSS_PROBE	5	/* Tail loss probe timer */
143 #define ICSK_TIME_REO_TIMEOUT	6	/* Reordering timer */
144 
145 static inline struct inet_connection_sock *inet_csk(const struct sock *sk)
146 {
147 	return (struct inet_connection_sock *)sk;
148 }
149 
150 static inline void *inet_csk_ca(const struct sock *sk)
151 {
152 	return (void *)inet_csk(sk)->icsk_ca_priv;
153 }
154 
155 struct sock *inet_csk_clone_lock(const struct sock *sk,
156 				 const struct request_sock *req,
157 				 const gfp_t priority);
158 
159 enum inet_csk_ack_state_t {
160 	ICSK_ACK_SCHED	= 1,
161 	ICSK_ACK_TIMER  = 2,
162 	ICSK_ACK_PUSHED = 4,
163 	ICSK_ACK_PUSHED2 = 8,
164 	ICSK_ACK_NOW = 16	/* Send the next ACK immediately (once) */
165 };
166 
167 void inet_csk_init_xmit_timers(struct sock *sk,
168 			       void (*retransmit_handler)(struct timer_list *),
169 			       void (*delack_handler)(struct timer_list *),
170 			       void (*keepalive_handler)(struct timer_list *));
171 void inet_csk_clear_xmit_timers(struct sock *sk);
172 
173 static inline void inet_csk_schedule_ack(struct sock *sk)
174 {
175 	inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_SCHED;
176 }
177 
178 static inline int inet_csk_ack_scheduled(const struct sock *sk)
179 {
180 	return inet_csk(sk)->icsk_ack.pending & ICSK_ACK_SCHED;
181 }
182 
183 static inline void inet_csk_delack_init(struct sock *sk)
184 {
185 	memset(&inet_csk(sk)->icsk_ack, 0, sizeof(inet_csk(sk)->icsk_ack));
186 }
187 
188 void inet_csk_delete_keepalive_timer(struct sock *sk);
189 void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long timeout);
190 
191 static inline void inet_csk_clear_xmit_timer(struct sock *sk, const int what)
192 {
193 	struct inet_connection_sock *icsk = inet_csk(sk);
194 
195 	if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
196 		icsk->icsk_pending = 0;
197 #ifdef INET_CSK_CLEAR_TIMERS
198 		sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
199 #endif
200 	} else if (what == ICSK_TIME_DACK) {
201 		icsk->icsk_ack.pending = 0;
202 		icsk->icsk_ack.retry = 0;
203 #ifdef INET_CSK_CLEAR_TIMERS
204 		sk_stop_timer(sk, &icsk->icsk_delack_timer);
205 #endif
206 	} else {
207 		pr_debug("inet_csk BUG: unknown timer value\n");
208 	}
209 }
210 
211 /*
212  *	Reset the retransmission timer
213  */
214 static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
215 					     unsigned long when,
216 					     const unsigned long max_when)
217 {
218 	struct inet_connection_sock *icsk = inet_csk(sk);
219 
220 	if (when > max_when) {
221 		pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
222 			 sk, what, when, (void *)_THIS_IP_);
223 		when = max_when;
224 	}
225 
226 	if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0 ||
227 	    what == ICSK_TIME_LOSS_PROBE || what == ICSK_TIME_REO_TIMEOUT) {
228 		icsk->icsk_pending = what;
229 		icsk->icsk_timeout = jiffies + when;
230 		sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
231 	} else if (what == ICSK_TIME_DACK) {
232 		icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
233 		icsk->icsk_ack.timeout = jiffies + when;
234 		sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
235 	} else {
236 		pr_debug("inet_csk BUG: unknown timer value\n");
237 	}
238 }
239 
240 static inline unsigned long
241 inet_csk_rto_backoff(const struct inet_connection_sock *icsk,
242 		     unsigned long max_when)
243 {
244         u64 when = (u64)icsk->icsk_rto << icsk->icsk_backoff;
245 
246         return (unsigned long)min_t(u64, when, max_when);
247 }
248 
249 struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern);
250 
251 int inet_csk_get_port(struct sock *sk, unsigned short snum);
252 
253 struct dst_entry *inet_csk_route_req(const struct sock *sk, struct flowi4 *fl4,
254 				     const struct request_sock *req);
255 struct dst_entry *inet_csk_route_child_sock(const struct sock *sk,
256 					    struct sock *newsk,
257 					    const struct request_sock *req);
258 
259 struct sock *inet_csk_reqsk_queue_add(struct sock *sk,
260 				      struct request_sock *req,
261 				      struct sock *child);
262 void inet_csk_reqsk_queue_hash_add(struct sock *sk, struct request_sock *req,
263 				   unsigned long timeout);
264 struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child,
265 					 struct request_sock *req,
266 					 bool own_req);
267 
268 static inline void inet_csk_reqsk_queue_added(struct sock *sk)
269 {
270 	reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue);
271 }
272 
273 static inline int inet_csk_reqsk_queue_len(const struct sock *sk)
274 {
275 	return reqsk_queue_len(&inet_csk(sk)->icsk_accept_queue);
276 }
277 
278 static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk)
279 {
280 	return inet_csk_reqsk_queue_len(sk) >= sk->sk_max_ack_backlog;
281 }
282 
283 bool inet_csk_reqsk_queue_drop(struct sock *sk, struct request_sock *req);
284 void inet_csk_reqsk_queue_drop_and_put(struct sock *sk, struct request_sock *req);
285 
286 static inline unsigned long
287 reqsk_timeout(struct request_sock *req, unsigned long max_timeout)
288 {
289 	u64 timeout = (u64)req->timeout << req->num_timeout;
290 
291 	return (unsigned long)min_t(u64, timeout, max_timeout);
292 }
293 
294 static inline void inet_csk_prepare_for_destroy_sock(struct sock *sk)
295 {
296 	/* The below has to be done to allow calling inet_csk_destroy_sock */
297 	sock_set_flag(sk, SOCK_DEAD);
298 	this_cpu_inc(*sk->sk_prot->orphan_count);
299 }
300 
301 void inet_csk_destroy_sock(struct sock *sk);
302 void inet_csk_prepare_forced_close(struct sock *sk);
303 
304 /*
305  * LISTEN is a special case for poll..
306  */
307 static inline __poll_t inet_csk_listen_poll(const struct sock *sk)
308 {
309 	return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ?
310 			(EPOLLIN | EPOLLRDNORM) : 0;
311 }
312 
313 int inet_csk_listen_start(struct sock *sk);
314 void inet_csk_listen_stop(struct sock *sk);
315 
316 void inet_csk_addr2sockaddr(struct sock *sk, struct sockaddr *uaddr);
317 
318 /* update the fast reuse flag when adding a socket */
319 void inet_csk_update_fastreuse(struct inet_bind_bucket *tb,
320 			       struct sock *sk);
321 
322 struct dst_entry *inet_csk_update_pmtu(struct sock *sk, u32 mtu);
323 
324 #define TCP_PINGPONG_THRESH	1
325 
326 static inline void inet_csk_enter_pingpong_mode(struct sock *sk)
327 {
328 	inet_csk(sk)->icsk_ack.pingpong = TCP_PINGPONG_THRESH;
329 }
330 
331 static inline void inet_csk_exit_pingpong_mode(struct sock *sk)
332 {
333 	inet_csk(sk)->icsk_ack.pingpong = 0;
334 }
335 
336 static inline bool inet_csk_in_pingpong_mode(struct sock *sk)
337 {
338 	return inet_csk(sk)->icsk_ack.pingpong >= TCP_PINGPONG_THRESH;
339 }
340 
341 static inline bool inet_csk_has_ulp(struct sock *sk)
342 {
343 	return inet_sk(sk)->is_icsk && !!inet_csk(sk)->icsk_ulp_ops;
344 }
345 
346 #endif /* _INET_CONNECTION_SOCK_H */
347