xref: /titanic_52/usr/src/uts/common/inet/tcp_impl.h (revision a725189c0accbf47b39f735d1f32a7b54ae91c6d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright (c) 2011, Joyent Inc. All rights reserved.
24  * Copyright (c) 2013, OmniTI Computer Consulting, Inc. All rights reserved.
25  * Copyright (c) 2013, 2014 by Delphix. All rights reserved.
26  */
27 
28 #ifndef	_INET_TCP_IMPL_H
29 #define	_INET_TCP_IMPL_H
30 
31 /*
32  * TCP implementation private declarations.  These interfaces are
33  * used to build the IP module and are not meant to be accessed
34  * by any modules except IP itself.  They are undocumented and are
35  * subject to change without notice.
36  */
37 
38 #ifdef	__cplusplus
39 extern "C" {
40 #endif
41 
42 #ifdef _KERNEL
43 
44 #include <sys/cpuvar.h>
45 #include <sys/clock_impl.h>	/* For LBOLT_FASTPATH{,64} */
46 #include <inet/optcom.h>
47 #include <inet/tcp.h>
48 #include <inet/tunables.h>
49 
50 #define	TCP_MOD_ID	5105
51 
52 extern struct qinit	tcp_sock_winit;
53 extern struct qinit	tcp_winit;
54 
55 extern sock_downcalls_t sock_tcp_downcalls;
56 
57 /*
58  * Note that by default, the _snd_lowat_fraction tunable controls the value of
59  * the transmit low water mark.  TCP_XMIT_LOWATER (and thus the _xmit_lowat
60  * property) is only used if the administrator has disabled _snd_lowat_fraction
61  * by setting it to 0.
62  */
63 #define	TCP_XMIT_LOWATER	4096
64 #define	TCP_XMIT_HIWATER	49152
65 #define	TCP_RECV_LOWATER	2048
66 #define	TCP_RECV_HIWATER	128000
67 
68 /*
69  * Bind hash list size and has function.  It has to be a power of 2 for
70  * hashing.
71  */
72 #define	TCP_BIND_FANOUT_SIZE	1024
73 #define	TCP_BIND_HASH(lport) (ntohs(lport) & (TCP_BIND_FANOUT_SIZE - 1))
74 
75 /*
76  * This implementation follows the 4.3BSD interpretation of the urgent
77  * pointer and not RFC 1122. Switching to RFC 1122 behavior would cause
78  * incompatible changes in protocols like telnet and rlogin.
79  */
80 #define	TCP_OLD_URP_INTERPRETATION	1
81 
82 /* TCP option length */
83 #define	TCPOPT_NOP_LEN		1
84 #define	TCPOPT_MAXSEG_LEN	4
85 #define	TCPOPT_WS_LEN		3
86 #define	TCPOPT_REAL_WS_LEN	(TCPOPT_WS_LEN+1)
87 #define	TCPOPT_TSTAMP_LEN	10
88 #define	TCPOPT_REAL_TS_LEN	(TCPOPT_TSTAMP_LEN+2)
89 #define	TCPOPT_SACK_OK_LEN	2
90 #define	TCPOPT_REAL_SACK_OK_LEN	(TCPOPT_SACK_OK_LEN+2)
91 #define	TCPOPT_REAL_SACK_LEN	4
92 #define	TCPOPT_MAX_SACK_LEN	36
93 #define	TCPOPT_HEADER_LEN	2
94 
95 /* Round up the value to the nearest mss. */
96 #define	MSS_ROUNDUP(value, mss)		((((value) - 1) / (mss) + 1) * (mss))
97 
98 /*
99  * Was this tcp created via socket() interface?
100  */
101 #define	TCP_IS_SOCKET(tcp)	((tcp)->tcp_issocket)
102 
103 /*
104  * Is this tcp not attached to any upper client?
105  */
106 #define	TCP_IS_DETACHED(tcp)	((tcp)->tcp_detached)
107 
108 /* TCP timers related data strucutres.  Refer to tcp_timers.c. */
109 typedef struct tcp_timer_s {
110 	conn_t	*connp;
111 	void 	(*tcpt_proc)(void *);
112 	callout_id_t   tcpt_tid;
113 } tcp_timer_t;
114 
115 extern kmem_cache_t *tcp_timercache;
116 
117 /*
118  * Macro for starting various timers.  Retransmission timer has its own macro,
119  * TCP_TIMER_RESTART().  tim is in millisec.
120  */
121 #define	TCP_TIMER(tcp, f, tim)		\
122 	tcp_timeout(tcp->tcp_connp, f, tim)
123 #define	TCP_TIMER_CANCEL(tcp, id)	\
124 	tcp_timeout_cancel(tcp->tcp_connp, id)
125 
126 /*
127  * To restart the TCP retransmission timer.  intvl is in millisec.
128  */
129 #define	TCP_TIMER_RESTART(tcp, intvl) {					\
130 	if ((tcp)->tcp_timer_tid != 0)					\
131 		(void) TCP_TIMER_CANCEL((tcp), (tcp)->tcp_timer_tid);	\
132 	(tcp)->tcp_timer_tid = TCP_TIMER((tcp), tcp_timer, (intvl));	\
133 }
134 
135 /*
136  * For scalability, we must not run a timer for every TCP connection
137  * in TIME_WAIT state.  To see why, consider (for time wait interval of
138  * 1 minutes):
139  *	10,000 connections/sec * 60 seconds/time wait = 600,000 active conn's
140  *
141  * This list is ordered by time, so you need only delete from the head
142  * until you get to entries which aren't old enough to delete yet.
143  * The list consists of only the detached TIME_WAIT connections.
144  *
145  * When a tcp_t enters TIME_WAIT state, a timer is started (timeout is
146  * tcps_time_wait_interval).  When the tcp_t is detached (upper layer closes
147  * the end point), it is moved to the time wait list and another timer is
148  * started (expiry time is set at tcp_time_wait_expire, which is
149  * also calculated using tcps_time_wait_interval).  This means that the
150  * TIME_WAIT state can be extended (up to doubled) if the tcp_t doesn't
151  * become detached for a long time.
152  *
153  * The list manipulations (including tcp_time_wait_next/prev)
154  * are protected by the tcp_time_wait_lock. The content of the
155  * detached TIME_WAIT connections is protected by the normal perimeters.
156  *
157  * This list is per squeue and squeues are shared across the tcp_stack_t's.
158  * Things on tcp_time_wait_head remain associated with the tcp_stack_t
159  * and conn_netstack.
160  * The tcp_t's that are added to tcp_free_list are disassociated and
161  * have NULL tcp_tcps and conn_netstack pointers.
162  */
163 typedef struct tcp_squeue_priv_s {
164 	kmutex_t	tcp_time_wait_lock;
165 	callout_id_t	tcp_time_wait_tid;
166 	tcp_t		*tcp_time_wait_head;
167 	tcp_t		*tcp_time_wait_tail;
168 	tcp_t		*tcp_free_list;
169 	uint_t		tcp_free_list_cnt;
170 #ifdef DEBUG
171 	/*
172 	 * For debugging purpose, true when tcp_time_wait_collector() is
173 	 * running.
174 	 */
175 	boolean_t	tcp_time_wait_running;
176 #endif
177 } tcp_squeue_priv_t;
178 
179 /*
180  * Parameters for TCP Initial Send Sequence number (ISS) generation.  When
181  * tcp_strong_iss is set to 1, which is the default, the ISS is calculated
182  * by adding three components: a time component which grows by 1 every 4096
183  * nanoseconds (versus every 4 microseconds suggested by RFC 793, page 27);
184  * a per-connection component which grows by 125000 for every new connection;
185  * and an "extra" component that grows by a random amount centered
186  * approximately on 64000.  This causes the ISS generator to cycle every
187  * 4.89 hours if no TCP connections are made, and faster if connections are
188  * made.
189  *
190  * When tcp_strong_iss is set to 0, ISS is calculated by adding two
191  * components: a time component which grows by 250000 every second; and
192  * a per-connection component which grows by 125000 for every new connections.
193  *
194  * A third method, when tcp_strong_iss is set to 2, for generating ISS is
195  * prescribed by Steve Bellovin.  This involves adding time, the 125000 per
196  * connection, and a one-way hash (MD5) of the connection ID <sport, dport,
197  * src, dst>, a "truly" random (per RFC 1750) number, and a console-entered
198  * password.
199  */
200 #define	ISS_INCR	250000
201 #define	ISS_NSEC_SHT	12
202 
203 /* Macros for timestamp comparisons */
204 #define	TSTMP_GEQ(a, b)	((int32_t)((a)-(b)) >= 0)
205 #define	TSTMP_LT(a, b)	((int32_t)((a)-(b)) < 0)
206 
207 /*
208  * Initialize cwnd according to RFC 3390.  def_max_init_cwnd is
209  * either tcp_slow_start_initial or tcp_slow_start_after idle
210  * depending on the caller.  If the upper layer has not used the
211  * TCP_INIT_CWND option to change the initial cwnd, tcp_init_cwnd
212  * should be 0 and we use the formula in RFC 3390 to set tcp_cwnd.
213  * If the upper layer has changed set the tcp_init_cwnd, just use
214  * it to calculate the tcp_cwnd.
215  *
216  * "An Argument for Increasing TCP's Initial Congestion Window"
217  * ACM SIGCOMM Computer Communications Review, vol. 40 (2010), pp. 27-33
218  *  -- Nandita Dukkipati, Tiziana Refice, Yuchung Cheng,
219  *     Hsiao-keng Jerry Chu, Tom Herbert, Amit Agarwal,
220  *     Arvind Jain, Natalia Sutin
221  *
222  *   "Based on the results from our experiments, we believe the
223  *    initial congestion window should be at least ten segments
224  *    and the same be investigated for standardization by the IETF."
225  *
226  * As such, the def_max_init_cwnd argument with which this macro is
227  * invoked is either the tcps_slow_start_initial or
228  * tcps_slow_start_after_idle which both default to 0 and will respect
229  * RFC 3390 exactly.  If the tunables are explicitly set by the operator,
230  * then the initial congestion window should be set as the operator
231  * demands, within reason. We shall arbitrarily define reason as a
232  * maximum of 16 (same as used by the TCP_INIT_CWND setsockopt).
233  */
234 
235 /* Maximum TCP initial cwin (start/restart). */
236 #define	TCP_MAX_INIT_CWND	16
237 
238 #define	TCP_SET_INIT_CWND(tcp, mss, def_max_init_cwnd)			\
239 {									\
240 	if ((tcp)->tcp_init_cwnd == 0) {				\
241 		if (def_max_init_cwnd == 0) {				\
242 			(tcp)->tcp_cwnd = MIN(4 * (mss),		\
243 			    MAX(2 * (mss), 4380 / (mss) * (mss)));	\
244 		} else {						\
245 			(tcp)->tcp_cwnd = MIN(TCP_MAX_INIT_CWND * (mss),\
246 			    def_max_init_cwnd * (mss));			\
247 		}							\
248 	} else {							\
249 		(tcp)->tcp_cwnd = (tcp)->tcp_init_cwnd * (mss);		\
250 	}								\
251 	tcp->tcp_cwnd_cnt = 0;						\
252 }
253 
254 /*
255  * Set ECN capable transport (ECT) code point in IP header.
256  *
257  * Note that there are 2 ECT code points '01' and '10', which are called
258  * ECT(1) and ECT(0) respectively.  Here we follow the original ECT code
259  * point ECT(0) for TCP as described in RFC 2481.
260  */
261 #define	TCP_SET_ECT(tcp, iph) \
262 	if ((tcp)->tcp_connp->conn_ipversion == IPV4_VERSION) { \
263 		/* We need to clear the code point first. */ \
264 		((ipha_t *)(iph))->ipha_type_of_service &= 0xFC; \
265 		((ipha_t *)(iph))->ipha_type_of_service |= IPH_ECN_ECT0; \
266 	} else { \
267 		((ip6_t *)(iph))->ip6_vcf &= htonl(0xFFCFFFFF); \
268 		((ip6_t *)(iph))->ip6_vcf |= htonl(IPH_ECN_ECT0 << 20); \
269 	}
270 
271 /*
272  * Set tcp_rto with boundary checking.
273  */
274 #define	TCP_SET_RTO(tcp, rto) \
275 	if ((rto) < (tcp)->tcp_rto_min)			\
276 		(tcp)->tcp_rto = (tcp)->tcp_rto_min;	\
277 	else if ((rto) > (tcp)->tcp_rto_max)		\
278 		(tcp)->tcp_rto = (tcp)->tcp_rto_max;	\
279 	else						\
280 		(tcp)->tcp_rto = (rto);
281 
282 /*
283  * TCP options struct returned from tcp_parse_options.
284  */
285 typedef struct tcp_opt_s {
286 	uint32_t	tcp_opt_mss;
287 	uint32_t	tcp_opt_wscale;
288 	uint32_t	tcp_opt_ts_val;
289 	uint32_t	tcp_opt_ts_ecr;
290 	tcp_t		*tcp;
291 } tcp_opt_t;
292 
293 /*
294  * Flags returned from tcp_parse_options.
295  */
296 #define	TCP_OPT_MSS_PRESENT	1
297 #define	TCP_OPT_WSCALE_PRESENT	2
298 #define	TCP_OPT_TSTAMP_PRESENT	4
299 #define	TCP_OPT_SACK_OK_PRESENT	8
300 #define	TCP_OPT_SACK_PRESENT	16
301 
302 /*
303  * Write-side flow-control is implemented via the per instance STREAMS
304  * write-side Q by explicitly setting QFULL to stop the flow of mblk_t(s)
305  * and clearing QFULL and calling qbackenable() to restart the flow based
306  * on the number of TCP unsent bytes (i.e. those not on the wire waiting
307  * for a remote ACK).
308  *
309  * This is different than a standard STREAMS kmod which when using the
310  * STREAMS Q the framework would automatictly flow-control based on the
311  * defined hiwat/lowat values as mblk_t's are enqueued/dequeued.
312  *
313  * As of FireEngine TCP write-side flow-control needs to take into account
314  * both the unsent tcp_xmit list bytes but also any squeue_t enqueued bytes
315  * (i.e. from tcp_wput() -> tcp_output()).
316  *
317  * This is accomplished by adding a new tcp_t fields, tcp_squeue_bytes, to
318  * count the number of bytes enqueued by tcp_wput() and the number of bytes
319  * dequeued and processed by tcp_output().
320  *
321  * So, the total number of bytes unsent is (squeue_bytes + unsent) with all
322  * flow-control uses of unsent replaced with the macro TCP_UNSENT_BYTES.
323  */
324 extern void	tcp_clrqfull(tcp_t *);
325 extern void	tcp_setqfull(tcp_t *);
326 
327 #define	TCP_UNSENT_BYTES(tcp) \
328 	((tcp)->tcp_squeue_bytes + (tcp)->tcp_unsent)
329 
330 /*
331  * Linked list struct to store listener connection limit configuration per
332  * IP stack.  The list is stored at tcps_listener_conf in tcp_stack_t.
333  *
334  * tl_port: the listener port of this limit configuration
335  * tl_ratio: the maximum amount of memory consumed by all concurrent TCP
336  *           connections created by a listener does not exceed 1/tl_ratio
337  *           of the total system memory.  Note that this is only an
338  *           approximation.
339  * tl_link: linked list struct
340  */
341 typedef struct tcp_listener_s {
342 	in_port_t	tl_port;
343 	uint32_t	tl_ratio;
344 	list_node_t	tl_link;
345 } tcp_listener_t;
346 
347 /*
348  * If there is a limit set on the number of connections allowed per each
349  * listener, the following struct is used to store that counter.  It keeps
350  * the number of TCP connection created by a listener.  Note that this needs
351  * to be separated from the listener since the listener can go away before
352  * all the connections are gone.
353  *
354  * When the struct is allocated, tlc_cnt is set to 1.  When a new connection
355  * is created by the listener, tlc_cnt is incremented by 1.  When a connection
356  * created by the listener goes away, tlc_count is decremented by 1.  When the
357  * listener itself goes away, tlc_cnt is decremented  by one.  The last
358  * connection (or the listener) which decrements tlc_cnt to zero frees the
359  * struct.
360  *
361  * tlc_max is the maximum number of concurrent TCP connections created from a
362  * listner.  It is calculated when the tcp_listen_cnt_t is allocated.
363  *
364  * tlc_report_time stores the time when cmn_err() is called to report that the
365  * max has been exceeeded.  Report is done at most once every
366  * TCP_TLC_REPORT_INTERVAL mins for a listener.
367  *
368  * tlc_drop stores the number of connection attempt dropped because the
369  * limit has reached.
370  */
371 typedef struct tcp_listen_cnt_s {
372 	uint32_t	tlc_max;
373 	uint32_t	tlc_cnt;
374 	int64_t		tlc_report_time;
375 	uint32_t	tlc_drop;
376 } tcp_listen_cnt_t;
377 
378 #define	TCP_TLC_REPORT_INTERVAL	(30 * MINUTES)
379 
380 #define	TCP_DECR_LISTEN_CNT(tcp)					\
381 {									\
382 	ASSERT((tcp)->tcp_listen_cnt->tlc_cnt > 0);			\
383 	if (atomic_dec_32_nv(&(tcp)->tcp_listen_cnt->tlc_cnt) == 0) \
384 		kmem_free((tcp)->tcp_listen_cnt, sizeof (tcp_listen_cnt_t)); \
385 	(tcp)->tcp_listen_cnt = NULL;					\
386 }
387 
388 /* Increment and decrement the number of connections in tcp_stack_t. */
389 #define	TCPS_CONN_INC(tcps)						\
390 	atomic_inc_64(							\
391 	    (uint64_t *)&(tcps)->tcps_sc[CPU->cpu_seqid]->tcp_sc_conn_cnt)
392 
393 #define	TCPS_CONN_DEC(tcps)						\
394 	atomic_dec_64(							\
395 	    (uint64_t *)&(tcps)->tcps_sc[CPU->cpu_seqid]->tcp_sc_conn_cnt)
396 
397 /*
398  * When the system is under memory pressure, stack variable tcps_reclaim is
399  * true, we shorten the connection timeout abort interval to tcp_early_abort
400  * seconds.  Defined in tcp.c.
401  */
402 extern uint32_t tcp_early_abort;
403 
404 /*
405  * To reach to an eager in Q0 which can be dropped due to an incoming
406  * new SYN request when Q0 is full, a new doubly linked list is
407  * introduced. This list allows to select an eager from Q0 in O(1) time.
408  * This is needed to avoid spending too much time walking through the
409  * long list of eagers in Q0 when tcp_drop_q0() is called. Each member of
410  * this new list has to be a member of Q0.
411  * This list is headed by listener's tcp_t. When the list is empty,
412  * both the pointers - tcp_eager_next_drop_q0 and tcp_eager_prev_drop_q0,
413  * of listener's tcp_t point to listener's tcp_t itself.
414  *
415  * Given an eager in Q0 and a listener, MAKE_DROPPABLE() puts the eager
416  * in the list. MAKE_UNDROPPABLE() takes the eager out of the list.
417  * These macros do not affect the eager's membership to Q0.
418  */
419 #define	MAKE_DROPPABLE(listener, eager)					\
420 	if ((eager)->tcp_eager_next_drop_q0 == NULL) {			\
421 		(listener)->tcp_eager_next_drop_q0->tcp_eager_prev_drop_q0\
422 		    = (eager);						\
423 		(eager)->tcp_eager_prev_drop_q0 = (listener);		\
424 		(eager)->tcp_eager_next_drop_q0 =			\
425 		    (listener)->tcp_eager_next_drop_q0;			\
426 		(listener)->tcp_eager_next_drop_q0 = (eager);		\
427 	}
428 
429 #define	MAKE_UNDROPPABLE(eager)						\
430 	if ((eager)->tcp_eager_next_drop_q0 != NULL) {			\
431 		(eager)->tcp_eager_next_drop_q0->tcp_eager_prev_drop_q0	\
432 		    = (eager)->tcp_eager_prev_drop_q0;			\
433 		(eager)->tcp_eager_prev_drop_q0->tcp_eager_next_drop_q0	\
434 		    = (eager)->tcp_eager_next_drop_q0;			\
435 		(eager)->tcp_eager_prev_drop_q0 = NULL;			\
436 		(eager)->tcp_eager_next_drop_q0 = NULL;			\
437 	}
438 
439 /*
440  * The format argument to pass to tcp_display().
441  * DISP_PORT_ONLY means that the returned string has only port info.
442  * DISP_ADDR_AND_PORT means that the returned string also contains the
443  * remote and local IP address.
444  */
445 #define	DISP_PORT_ONLY		1
446 #define	DISP_ADDR_AND_PORT	2
447 
448 #define	IP_ADDR_CACHE_SIZE	2048
449 #define	IP_ADDR_CACHE_HASH(faddr)					\
450 	(ntohl(faddr) & (IP_ADDR_CACHE_SIZE -1))
451 
452 /*
453  * TCP reassembly macros.  We hide starting and ending sequence numbers in
454  * b_next and b_prev of messages on the reassembly queue.  The messages are
455  * chained using b_cont.  These macros are used in tcp_reass() so we don't
456  * have to see the ugly casts and assignments.
457  */
458 #define	TCP_REASS_SEQ(mp)		((uint32_t)(uintptr_t)((mp)->b_next))
459 #define	TCP_REASS_SET_SEQ(mp, u)	((mp)->b_next = \
460 					(mblk_t *)(uintptr_t)(u))
461 #define	TCP_REASS_END(mp)		((uint32_t)(uintptr_t)((mp)->b_prev))
462 #define	TCP_REASS_SET_END(mp, u)	((mp)->b_prev = \
463 					(mblk_t *)(uintptr_t)(u))
464 
465 #define	tcps_time_wait_interval		tcps_propinfo_tbl[0].prop_cur_uval
466 #define	tcps_conn_req_max_q		tcps_propinfo_tbl[1].prop_cur_uval
467 #define	tcps_conn_req_max_q0		tcps_propinfo_tbl[2].prop_cur_uval
468 #define	tcps_conn_req_min		tcps_propinfo_tbl[3].prop_cur_uval
469 #define	tcps_conn_grace_period		tcps_propinfo_tbl[4].prop_cur_uval
470 #define	tcps_cwnd_max_			tcps_propinfo_tbl[5].prop_cur_uval
471 #define	tcps_dbg			tcps_propinfo_tbl[6].prop_cur_uval
472 #define	tcps_smallest_nonpriv_port	tcps_propinfo_tbl[7].prop_cur_uval
473 #define	tcps_ip_abort_cinterval		tcps_propinfo_tbl[8].prop_cur_uval
474 #define	tcps_ip_abort_linterval		tcps_propinfo_tbl[9].prop_cur_uval
475 #define	tcps_ip_abort_interval		tcps_propinfo_tbl[10].prop_cur_uval
476 #define	tcps_ip_notify_cinterval	tcps_propinfo_tbl[11].prop_cur_uval
477 #define	tcps_ip_notify_interval		tcps_propinfo_tbl[12].prop_cur_uval
478 #define	tcps_ipv4_ttl			tcps_propinfo_tbl[13].prop_cur_uval
479 #define	tcps_keepalive_interval_high	tcps_propinfo_tbl[14].prop_max_uval
480 #define	tcps_keepalive_interval		tcps_propinfo_tbl[14].prop_cur_uval
481 #define	tcps_keepalive_interval_low	tcps_propinfo_tbl[14].prop_min_uval
482 #define	tcps_maxpsz_multiplier		tcps_propinfo_tbl[15].prop_cur_uval
483 #define	tcps_mss_def_ipv4		tcps_propinfo_tbl[16].prop_cur_uval
484 #define	tcps_mss_max_ipv4		tcps_propinfo_tbl[17].prop_cur_uval
485 #define	tcps_mss_min			tcps_propinfo_tbl[18].prop_cur_uval
486 #define	tcps_naglim_def			tcps_propinfo_tbl[19].prop_cur_uval
487 #define	tcps_rexmit_interval_initial_high	\
488 					tcps_propinfo_tbl[20].prop_max_uval
489 #define	tcps_rexmit_interval_initial	tcps_propinfo_tbl[20].prop_cur_uval
490 #define	tcps_rexmit_interval_initial_low	\
491 					tcps_propinfo_tbl[20].prop_min_uval
492 #define	tcps_rexmit_interval_max_high	tcps_propinfo_tbl[21].prop_max_uval
493 #define	tcps_rexmit_interval_max	tcps_propinfo_tbl[21].prop_cur_uval
494 #define	tcps_rexmit_interval_max_low	tcps_propinfo_tbl[21].prop_min_uval
495 #define	tcps_rexmit_interval_min_high	tcps_propinfo_tbl[22].prop_max_uval
496 #define	tcps_rexmit_interval_min	tcps_propinfo_tbl[22].prop_cur_uval
497 #define	tcps_rexmit_interval_min_low	tcps_propinfo_tbl[22].prop_min_uval
498 #define	tcps_deferred_ack_interval	tcps_propinfo_tbl[23].prop_cur_uval
499 #define	tcps_snd_lowat_fraction		tcps_propinfo_tbl[24].prop_cur_uval
500 #define	tcps_dupack_fast_retransmit	tcps_propinfo_tbl[25].prop_cur_uval
501 #define	tcps_ignore_path_mtu		tcps_propinfo_tbl[26].prop_cur_bval
502 #define	tcps_smallest_anon_port		tcps_propinfo_tbl[27].prop_cur_uval
503 #define	tcps_largest_anon_port		tcps_propinfo_tbl[28].prop_cur_uval
504 #define	tcps_xmit_hiwat			tcps_propinfo_tbl[29].prop_cur_uval
505 #define	tcps_xmit_lowat			tcps_propinfo_tbl[30].prop_cur_uval
506 #define	tcps_recv_hiwat			tcps_propinfo_tbl[31].prop_cur_uval
507 #define	tcps_recv_hiwat_minmss		tcps_propinfo_tbl[32].prop_cur_uval
508 #define	tcps_fin_wait_2_flush_interval_high	\
509 					tcps_propinfo_tbl[33].prop_max_uval
510 #define	tcps_fin_wait_2_flush_interval	tcps_propinfo_tbl[33].prop_cur_uval
511 #define	tcps_fin_wait_2_flush_interval_low	\
512 					tcps_propinfo_tbl[33].prop_min_uval
513 #define	tcps_max_buf			tcps_propinfo_tbl[34].prop_cur_uval
514 #define	tcps_strong_iss			tcps_propinfo_tbl[35].prop_cur_uval
515 #define	tcps_rtt_updates		tcps_propinfo_tbl[36].prop_cur_uval
516 #define	tcps_wscale_always		tcps_propinfo_tbl[37].prop_cur_bval
517 #define	tcps_tstamp_always		tcps_propinfo_tbl[38].prop_cur_bval
518 #define	tcps_tstamp_if_wscale		tcps_propinfo_tbl[39].prop_cur_bval
519 #define	tcps_rexmit_interval_extra	tcps_propinfo_tbl[40].prop_cur_uval
520 #define	tcps_deferred_acks_max		tcps_propinfo_tbl[41].prop_cur_uval
521 #define	tcps_slow_start_after_idle	tcps_propinfo_tbl[42].prop_cur_uval
522 #define	tcps_slow_start_initial		tcps_propinfo_tbl[43].prop_cur_uval
523 #define	tcps_sack_permitted		tcps_propinfo_tbl[44].prop_cur_uval
524 #define	tcps_ipv6_hoplimit		tcps_propinfo_tbl[45].prop_cur_uval
525 #define	tcps_mss_def_ipv6		tcps_propinfo_tbl[46].prop_cur_uval
526 #define	tcps_mss_max_ipv6		tcps_propinfo_tbl[47].prop_cur_uval
527 #define	tcps_rev_src_routes		tcps_propinfo_tbl[48].prop_cur_bval
528 #define	tcps_local_dack_interval	tcps_propinfo_tbl[49].prop_cur_uval
529 #define	tcps_local_dacks_max		tcps_propinfo_tbl[50].prop_cur_uval
530 #define	tcps_ecn_permitted		tcps_propinfo_tbl[51].prop_cur_uval
531 #define	tcps_rst_sent_rate_enabled	tcps_propinfo_tbl[52].prop_cur_bval
532 #define	tcps_rst_sent_rate		tcps_propinfo_tbl[53].prop_cur_uval
533 #define	tcps_push_timer_interval	tcps_propinfo_tbl[54].prop_cur_uval
534 #define	tcps_use_smss_as_mss_opt	tcps_propinfo_tbl[55].prop_cur_bval
535 #define	tcps_keepalive_abort_interval_high \
536 					tcps_propinfo_tbl[56].prop_max_uval
537 #define	tcps_keepalive_abort_interval \
538 					tcps_propinfo_tbl[56].prop_cur_uval
539 #define	tcps_keepalive_abort_interval_low \
540 					tcps_propinfo_tbl[56].prop_min_uval
541 #define	tcps_wroff_xtra			tcps_propinfo_tbl[57].prop_cur_uval
542 #define	tcps_dev_flow_ctl		tcps_propinfo_tbl[58].prop_cur_bval
543 #define	tcps_reass_timeout		tcps_propinfo_tbl[59].prop_cur_uval
544 #define	tcps_iss_incr			tcps_propinfo_tbl[65].prop_cur_uval
545 
546 extern struct qinit tcp_rinitv4, tcp_rinitv6;
547 extern boolean_t do_tcp_fusion;
548 
549 /*
550  * Object to represent database of options to search passed to
551  * {sock,tpi}optcom_req() interface routine to take care of option
552  * management and associated methods.
553  */
554 extern optdb_obj_t	tcp_opt_obj;
555 extern uint_t		tcp_max_optsize;
556 
557 extern int tcp_squeue_flag;
558 
559 extern uint_t tcp_free_list_max_cnt;
560 
561 /*
562  * Functions in tcp.c.
563  */
564 extern void	tcp_acceptor_hash_insert(t_uscalar_t, tcp_t *);
565 extern tcp_t	*tcp_acceptor_hash_lookup(t_uscalar_t, tcp_stack_t *);
566 extern void	tcp_acceptor_hash_remove(tcp_t *);
567 extern mblk_t	*tcp_ack_mp(tcp_t *);
568 extern int	tcp_build_hdrs(tcp_t *);
569 extern void	tcp_cleanup(tcp_t *);
570 extern int	tcp_clean_death(tcp_t *, int);
571 extern void	tcp_clean_death_wrapper(void *, mblk_t *, void *,
572 		    ip_recv_attr_t *);
573 extern void	tcp_close_common(conn_t *, int);
574 extern void	tcp_close_detached(tcp_t *);
575 extern void	tcp_close_mpp(mblk_t **);
576 extern void	tcp_closei_local(tcp_t *);
577 extern sock_lower_handle_t tcp_create(int, int, int, sock_downcalls_t **,
578 		    uint_t *, int *, int, cred_t *);
579 extern conn_t	*tcp_create_common(cred_t *, boolean_t, boolean_t, int *);
580 extern void	tcp_disconnect(tcp_t *, mblk_t *);
581 extern char	*tcp_display(tcp_t *, char *, char);
582 extern int	tcp_do_bind(conn_t *, struct sockaddr *, socklen_t, cred_t *,
583 		    boolean_t);
584 extern int	tcp_do_connect(conn_t *, const struct sockaddr *, socklen_t,
585 		    cred_t *, pid_t);
586 extern int	tcp_do_listen(conn_t *, struct sockaddr *, socklen_t, int,
587 		    cred_t *, boolean_t);
588 extern int	tcp_do_unbind(conn_t *);
589 extern boolean_t	tcp_eager_blowoff(tcp_t *, t_scalar_t);
590 extern void	tcp_eager_cleanup(tcp_t *, boolean_t);
591 extern void	tcp_eager_kill(void *, mblk_t *, void *, ip_recv_attr_t *);
592 extern void	tcp_eager_unlink(tcp_t *);
593 extern void	tcp_init_values(tcp_t *, tcp_t *);
594 extern void	tcp_ipsec_cleanup(tcp_t *);
595 extern int	tcp_maxpsz_set(tcp_t *, boolean_t);
596 extern void	tcp_mss_set(tcp_t *, uint32_t);
597 extern void	tcp_reinput(conn_t *, mblk_t *, ip_recv_attr_t *, ip_stack_t *);
598 extern void	tcp_rsrv(queue_t *);
599 extern uint_t	tcp_rwnd_reopen(tcp_t *);
600 extern int	tcp_rwnd_set(tcp_t *, uint32_t);
601 extern int	tcp_set_destination(tcp_t *);
602 extern void	tcp_set_ws_value(tcp_t *);
603 extern void	tcp_stop_lingering(tcp_t *);
604 extern void	tcp_update_pmtu(tcp_t *, boolean_t);
605 extern mblk_t	*tcp_zcopy_backoff(tcp_t *, mblk_t *, boolean_t);
606 extern boolean_t	tcp_zcopy_check(tcp_t *);
607 extern void	tcp_zcopy_notify(tcp_t *);
608 extern void	tcp_get_proto_props(tcp_t *, struct sock_proto_props *);
609 
610 /*
611  * Bind related functions in tcp_bind.c
612  */
613 extern int	tcp_bind_check(conn_t *, struct sockaddr *, socklen_t,
614 		    cred_t *, boolean_t);
615 extern void	tcp_bind_hash_insert(tf_t *, tcp_t *, int);
616 extern void	tcp_bind_hash_remove(tcp_t *);
617 extern in_port_t	tcp_bindi(tcp_t *, in_port_t, const in6_addr_t *,
618 			    int, boolean_t, boolean_t, boolean_t);
619 extern in_port_t	tcp_update_next_port(in_port_t, const tcp_t *,
620 			    boolean_t);
621 
622 /*
623  * Fusion related functions in tcp_fusion.c.
624  */
625 extern void	tcp_fuse(tcp_t *, uchar_t *, tcpha_t *);
626 extern void	tcp_unfuse(tcp_t *);
627 extern boolean_t tcp_fuse_output(tcp_t *, mblk_t *, uint32_t);
628 extern void	tcp_fuse_output_urg(tcp_t *, mblk_t *);
629 extern boolean_t tcp_fuse_rcv_drain(queue_t *, tcp_t *, mblk_t **);
630 extern size_t	tcp_fuse_set_rcv_hiwat(tcp_t *, size_t);
631 extern int	tcp_fuse_maxpsz(tcp_t *);
632 extern void	tcp_fuse_backenable(tcp_t *);
633 extern void	tcp_iss_key_init(uint8_t *, int, tcp_stack_t *);
634 
635 /*
636  * Output related functions in tcp_output.c.
637  */
638 extern void	tcp_close_output(void *, mblk_t *, void *, ip_recv_attr_t *);
639 extern void	tcp_output(void *, mblk_t *, void *, ip_recv_attr_t *);
640 extern void	tcp_output_urgent(void *, mblk_t *, void *, ip_recv_attr_t *);
641 extern void	tcp_rexmit_after_error(tcp_t *);
642 extern void	tcp_sack_rexmit(tcp_t *, uint_t *);
643 extern void	tcp_send_data(tcp_t *, mblk_t *);
644 extern void	tcp_send_synack(void *, mblk_t *, void *, ip_recv_attr_t *);
645 extern void	tcp_shutdown_output(void *, mblk_t *, void *, ip_recv_attr_t *);
646 extern void	tcp_ss_rexmit(tcp_t *);
647 extern void	tcp_update_xmit_tail(tcp_t *, uint32_t);
648 extern void	tcp_wput(queue_t *, mblk_t *);
649 extern void	tcp_wput_data(tcp_t *, mblk_t *, boolean_t);
650 extern void	tcp_wput_sock(queue_t *, mblk_t *);
651 extern void	tcp_wput_fallback(queue_t *, mblk_t *);
652 extern void	tcp_xmit_ctl(char *, tcp_t *, uint32_t, uint32_t, int);
653 extern void	tcp_xmit_listeners_reset(mblk_t *, ip_recv_attr_t *,
654 		    ip_stack_t *i, conn_t *);
655 extern mblk_t	*tcp_xmit_mp(tcp_t *, mblk_t *, int32_t, int32_t *,
656 		    mblk_t **, uint32_t, boolean_t, uint32_t *, boolean_t);
657 
658 /*
659  * Input related functions in tcp_input.c.
660  */
661 extern void	tcp_icmp_input(void *, mblk_t *, void *, ip_recv_attr_t *);
662 extern void	tcp_input_data(void *, mblk_t *, void *, ip_recv_attr_t *);
663 extern void	tcp_input_listener_unbound(void *, mblk_t *, void *,
664 		    ip_recv_attr_t *);
665 extern boolean_t	tcp_paws_check(tcp_t *, const tcp_opt_t *);
666 extern int	tcp_parse_options(tcpha_t *, tcp_opt_t *);
667 extern uint_t	tcp_rcv_drain(tcp_t *);
668 extern void	tcp_rcv_enqueue(tcp_t *, mblk_t *, uint_t, cred_t *);
669 extern boolean_t	tcp_verifyicmp(conn_t *, void *, icmph_t *, icmp6_t *,
670 			    ip_recv_attr_t *);
671 
672 /*
673  * Kernel socket related functions in tcp_socket.c.
674  */
675 extern int	tcp_fallback(sock_lower_handle_t, queue_t *, boolean_t,
676 		    so_proto_quiesced_cb_t, sock_quiesce_arg_t *);
677 extern boolean_t tcp_newconn_notify(tcp_t *, ip_recv_attr_t *);
678 
679 /*
680  * Timer related functions in tcp_timers.c.
681  */
682 extern void	tcp_ack_timer(void *);
683 extern void	tcp_close_linger_timeout(void *);
684 extern void	tcp_keepalive_timer(void *);
685 extern void	tcp_push_timer(void *);
686 extern void	tcp_reass_timer(void *);
687 extern mblk_t	*tcp_timermp_alloc(int);
688 extern void	tcp_timermp_free(tcp_t *);
689 extern timeout_id_t tcp_timeout(conn_t *, void (*)(void *), hrtime_t);
690 extern clock_t	tcp_timeout_cancel(conn_t *, timeout_id_t);
691 extern void	tcp_timer(void *arg);
692 extern void	tcp_timers_stop(tcp_t *);
693 
694 /*
695  * TCP TPI related functions in tcp_tpi.c.
696  */
697 extern void	tcp_addr_req(tcp_t *, mblk_t *);
698 extern void	tcp_capability_req(tcp_t *, mblk_t *);
699 extern boolean_t	tcp_conn_con(tcp_t *, uchar_t *, mblk_t *,
700 			    mblk_t **, ip_recv_attr_t *);
701 extern void	tcp_err_ack(tcp_t *, mblk_t *, int, int);
702 extern void	tcp_err_ack_prim(tcp_t *, mblk_t *, int, int, int);
703 extern void	tcp_info_req(tcp_t *, mblk_t *);
704 extern void	tcp_send_conn_ind(void *, mblk_t *, void *);
705 extern void	tcp_send_pending(void *, mblk_t *, void *, ip_recv_attr_t *);
706 extern void	tcp_tpi_accept(queue_t *, mblk_t *);
707 extern void	tcp_tpi_bind(tcp_t *, mblk_t *);
708 extern int	tcp_tpi_close(queue_t *, int);
709 extern int	tcp_tpi_close_accept(queue_t *);
710 extern void	tcp_tpi_connect(tcp_t *, mblk_t *);
711 extern int	tcp_tpi_opt_get(queue_t *, t_scalar_t, t_scalar_t, uchar_t *);
712 extern int	tcp_tpi_opt_set(queue_t *, uint_t, int, int, uint_t, uchar_t *,
713 		    uint_t *, uchar_t *, void *, cred_t *);
714 extern void	tcp_tpi_unbind(tcp_t *, mblk_t *);
715 extern void	tcp_tli_accept(tcp_t *, mblk_t *);
716 extern void	tcp_use_pure_tpi(tcp_t *);
717 extern void	tcp_do_capability_ack(tcp_t *, struct T_capability_ack *,
718 		    t_uscalar_t);
719 
720 /*
721  * TCP option processing related functions in tcp_opt_data.c
722  */
723 extern int	tcp_opt_get(conn_t *, int, int, uchar_t *);
724 extern int	tcp_opt_set(conn_t *, uint_t, int, int, uint_t, uchar_t *,
725 		    uint_t *, uchar_t *, void *, cred_t *);
726 
727 /*
728  * TCP time wait processing related functions in tcp_time_wait.c.
729  */
730 extern void		tcp_time_wait_append(tcp_t *);
731 extern void		tcp_time_wait_collector(void *);
732 extern boolean_t	tcp_time_wait_remove(tcp_t *, tcp_squeue_priv_t *);
733 extern void		tcp_time_wait_processing(tcp_t *, mblk_t *, uint32_t,
734 			    uint32_t, int, tcpha_t *, ip_recv_attr_t *);
735 
736 /*
737  * Misc functions in tcp_misc.c.
738  */
739 extern uint32_t	tcp_find_listener_conf(tcp_stack_t *, in_port_t);
740 extern void	tcp_ioctl_abort_conn(queue_t *, mblk_t *);
741 extern void	tcp_listener_conf_cleanup(tcp_stack_t *);
742 extern void	tcp_stack_cpu_add(tcp_stack_t *, processorid_t);
743 
744 #endif	/* _KERNEL */
745 
746 #ifdef	__cplusplus
747 }
748 #endif
749 
750 #endif	/* _INET_TCP_IMPL_H */
751