Lines Matching defs:tcp

69 #include <netinet/tcp.h>
86 #include <inet/tcp.h>
112 * The entire tcp state is contained in tcp_t and conn_t structure
125 * The tcp data structure does not use any kind of lock for protecting
127 * read and write side threads. To access a tcp member, the thread should
130 * can pass any tcp function having prototype of edesc_t as argument
138 * tcp structure doesn't disappear when its needed. When the application
142 * looks at tcp structure after tcp_close_output() returns which could
147 * the tcp connection perimeter, it retrieves the conn/tcp from q->ptr
151 * to make sure that tcp can't disappear before it gets processed. The
158 * work in creating the conn/tcp structure and initializing it. The
181 * via squeue to do the close and mark the tcp as detached if the connection
183 * reference but tcp_close() drop IP's reference always. So if tcp was
186 * we use to determine that its OK to clean up the tcp outside of squeue
203 * putting the tcp in acceptor hash since a sockfs listener can never
280 static int tcp_connect_ipv4(tcp_t *tcp, ipaddr_t *dstaddrp,
282 static int tcp_connect_ipv6(tcp_t *tcp, in6_addr_t *dstaddrp,
285 static void tcp_iss_init(tcp_t *tcp);
286 static void tcp_reinit(tcp_t *tcp);
287 static void tcp_reinit_values(tcp_t *tcp);
290 static void tcp_update_lso(tcp_t *tcp, ip_xmit_attr_t *ixa);
291 static void tcp_update_zcopy(tcp_t *tcp);
316 * We have separate open functions for the /dev/tcp and /dev/tcp6 devices.
353 /* For AF_INET aka /dev/tcp */
422 tcp_set_recv_threshold(tcp_t *tcp, uint32_t new_rcvthresh)
426 if (IPCL_IS_NONSTR(tcp->tcp_connp)) {
427 conn_t *connp = tcp->tcp_connp;
453 tcp_set_ws_value(tcp_t *tcp)
456 uint32_t rwnd = tcp->tcp_rwnd;
461 tcp->tcp_rcv_ws = i;
468 tcp_ipsec_cleanup(tcp_t *tcp)
470 conn_t *connp = tcp->tcp_connp;
498 tcp_cleanup(tcp_t *tcp)
501 conn_t *connp = tcp->tcp_connp;
502 tcp_stack_t *tcps = tcp->tcp_tcps;
506 tcp_bind_hash_remove(tcp);
509 tcp_ipsec_cleanup(tcp);
519 tcp->tcp_ipha = NULL;
520 tcp->tcp_ip6h = NULL;
521 tcp->tcp_tcpha = NULL;
527 tcp_free(tcp);
541 mp = tcp->tcp_timercache;
543 tcp_rsrv_mp = tcp->tcp_rsrv_mp;
561 tcp->tcp_tcps = NULL;
563 bzero(tcp, sizeof (tcp_t));
566 tcp->tcp_timercache = mp;
568 tcp->tcp_rsrv_mp = tcp_rsrv_mp;
570 tcp->tcp_connp = connp;
572 ASSERT(connp->conn_tcp == tcp);
608 tcp_set_destination(tcp_t *tcp)
612 boolean_t tcp_detached = TCP_IS_DETACHED(tcp);
613 conn_t *connp = tcp->tcp_connp;
614 tcp_stack_t *tcps = tcp->tcp_tcps;
629 /* Use conn_lock to satify ASSERT; tcp is already serialized */
636 error = tcp_build_hdrs(tcp);
640 tcp->tcp_localnet = uinfo.iulp_localnet;
645 tcp->tcp_rtt_sa = uinfo.iulp_rtt;
646 tcp->tcp_rtt_sd = uinfo.iulp_rtt_sd;
647 rto = (tcp->tcp_rtt_sa >> 3) + tcp->tcp_rtt_sd +
649 (tcp->tcp_rtt_sa >> 5);
651 TCP_SET_RTO(tcp, rto);
654 tcp->tcp_cwnd_ssthresh = uinfo.iulp_ssthresh;
656 tcp->tcp_cwnd_ssthresh = TCP_MAX_LARGEWIN;
664 (void) tcp_maxpsz_set(tcp, B_TRUE);
674 tcp->tcp_rwnd = MIN(uinfo.iulp_rpipe,
679 tcp->tcp_second_timer_threshold =
706 tcp->tcp_snd_ts_ok = B_TRUE;
708 tcp->tcp_snd_ws_ok = B_TRUE;
710 tcp->tcp_snd_sack_ok = B_TRUE;
712 tcp->tcp_ecn_ok = B_TRUE;
721 tcp->tcp_snd_sack_ok = B_TRUE;
740 mss = tcp->tcp_initial_pmtu = uinfo.iulp_mtu;
748 if (tcp->tcp_ipsec_overhead == 0)
749 tcp->tcp_ipsec_overhead = conn_ipsec_length(connp);
751 mss -= tcp->tcp_ipsec_overhead;
759 tcp->tcp_mss = mss;
762 * Update the tcp connection with LSO capability.
764 tcp_update_lso(tcp, connp->conn_ixa);
771 tcp_iss_init(tcp);
773 tcp->tcp_loopback = (uinfo.iulp_loopback | uinfo.iulp_local);
789 * on a tcp. Thus every function that potentially calls tcp_clean_death
790 * must check for the tcp state before calling tcp_clean_death.
792 * tcp_timer_handler, all check for the tcp state.
799 tcp_t *tcp = ((conn_t *)arg)->conn_tcp;
802 if (tcp->tcp_state > TCPS_BOUND)
816 tcp_clean_death(tcp_t *tcp, int err)
820 conn_t *connp = tcp->tcp_connp;
821 tcp_stack_t *tcps = tcp->tcp_tcps;
823 if (tcp->tcp_fused)
824 tcp_unfuse(tcp);
826 if (tcp->tcp_linger_tid != 0 &&
827 TCP_TIMER_CANCEL(tcp, tcp->tcp_linger_tid) >= 0) {
828 tcp_stop_lingering(tcp);
831 ASSERT(tcp != NULL);
838 if (TCP_IS_DETACHED(tcp)) {
839 if (tcp->tcp_hard_binding) {
852 tcp_closei_local(tcp);
853 if (!tcp->tcp_tconnind_started) {
856 tcp->tcp_state = TCPS_BOUND;
859 void, NULL, tcp_t *, tcp, void, NULL,
863 tcp_close_detached(tcp);
874 if (tcp->tcp_listen_cnt != NULL)
875 TCP_DECR_LISTEN_CNT(tcp);
882 if (tcp->tcp_state >= TCPS_ESTABLISHED &&
883 tcp->tcp_state < TCPS_TIME_WAIT) {
900 if ((tcp->tcp_state >= TCPS_SYN_SENT) && err) {
901 if (tcp->tcp_state >= TCPS_ESTABLISHED &&
902 !TCP_IS_SOCKET(tcp)) {
917 connp->conn_upper_handle, tcp->tcp_connid, err);
931 if (tcp->tcp_state <= TCPS_SYN_RCVD) {
934 } else if (tcp->tcp_state <= TCPS_CLOSE_WAIT) {
946 if (tcp->tcp_listener != NULL && IPCL_IS_NONSTR(connp)) {
947 tcp_closei_local(tcp);
948 tcp->tcp_state = TCPS_BOUND;
950 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
955 tcp_reinit(tcp);
963 * In case tcp is in the "lingering state" and waits for the SO_LINGER timeout
967 tcp_stop_lingering(tcp_t *tcp)
970 tcp_stack_t *tcps = tcp->tcp_tcps;
971 conn_t *connp = tcp->tcp_connp;
973 tcp->tcp_linger_tid = 0;
974 if (tcp->tcp_state > TCPS_LISTEN) {
975 tcp_acceptor_hash_remove(tcp);
976 mutex_enter(&tcp->tcp_non_sq_lock);
977 if (tcp->tcp_flow_stopped) {
978 tcp_clrqfull(tcp);
980 mutex_exit(&tcp->tcp_non_sq_lock);
982 if (tcp->tcp_timer_tid != 0) {
983 delta = TCP_TIMER_CANCEL(tcp, tcp->tcp_timer_tid);
984 tcp->tcp_timer_tid = 0;
991 tcp_timers_stop(tcp);
993 tcp->tcp_detached = B_TRUE;
997 if (tcp->tcp_state == TCPS_TIME_WAIT) {
998 tcp_time_wait_append(tcp);
1009 tcp->tcp_timer_tid = TCP_TIMER(tcp, tcp_timer,
1013 tcp_closei_local(tcp);
1017 tcp->tcp_detached = B_TRUE;
1022 mutex_enter(&tcp->tcp_closelock);
1023 tcp->tcp_closed = 1;
1024 cv_signal(&tcp->tcp_closecv);
1025 mutex_exit(&tcp->tcp_closelock);
1039 tcp_t *tcp = connp->conn_tcp;
1040 mblk_t *mp = &tcp->tcp_closemp;
1057 tcp->tcp_closeflags = (uint8_t)flags;
1067 tcp->tcp_closemp_used = B_TRUE;
1070 "connp %p tcp %p\n", (void *)connp, (void *)tcp);
1072 TCP_DEBUG_GETPCSTACK(tcp->tcmp_stk, 15);
1108 mutex_enter(&tcp->tcp_closelock);
1109 while (!tcp->tcp_closed) {
1110 if (!cv_wait_sig(&tcp->tcp_closecv, &tcp->tcp_closelock)) {
1127 mutex_exit(&tcp->tcp_closelock);
1134 mutex_enter(&tcp->tcp_closelock);
1139 while (!tcp->tcp_closed)
1140 cv_wait(&tcp->tcp_closecv, &tcp->tcp_closelock);
1141 mutex_exit(&tcp->tcp_closelock);
1154 if (tcp->tcp_wait_for_eagers && !IPCL_IS_NONSTR(connp)) {
1176 tcp_t *tcp = connp->conn_tcp;
1179 if (tcp->tcp_linger_tid != 0 &&
1180 TCP_TIMER_CANCEL(tcp, tcp->tcp_linger_tid) >= 0) {
1181 tcp_stop_lingering(tcp);
1182 tcp->tcp_client_errno = EINTR;
1209 tcp_close_detached(tcp_t *tcp)
1211 if (tcp->tcp_fused)
1212 tcp_unfuse(tcp);
1216 * cluster tcp list walks by blocking a TCP disconnect callback
1217 * if a cluster tcp list walk is in progress. This ensures
1221 tcp_closei_local(tcp);
1222 CONN_DEC_REF(tcp->tcp_connp);
1233 tcp_closei_local(tcp_t *tcp)
1235 conn_t *connp = tcp->tcp_connp;
1236 tcp_stack_t *tcps = tcp->tcp_tcps;
1239 if (!TCP_IS_SOCKET(tcp))
1240 tcp_acceptor_hash_remove(tcp);
1242 TCPS_UPDATE_MIB(tcps, tcpHCInSegs, tcp->tcp_ibsegs);
1243 tcp->tcp_ibsegs = 0;
1244 TCPS_UPDATE_MIB(tcps, tcpHCOutSegs, tcp->tcp_obsegs);
1245 tcp->tcp_obsegs = 0;
1254 if (tcp->tcp_state >= TCPS_ESTABLISHED &&
1255 tcp->tcp_state < TCPS_TIME_WAIT) {
1264 if (tcp->tcp_listener != NULL) {
1265 tcp_t *listener = tcp->tcp_listener;
1277 if (!tcp->tcp_tconnind_started) {
1278 tcp_eager_unlink(tcp);
1285 ASSERT(tcp->tcp_detached);
1295 tcp_timers_stop(tcp);
1297 if (tcp->tcp_state == TCPS_LISTEN) {
1298 if (tcp->tcp_ip_addr_cache) {
1299 kmem_free((void *)tcp->tcp_ip_addr_cache,
1301 tcp->tcp_ip_addr_cache = NULL;
1306 if (tcp->tcp_listen_cnt != NULL)
1307 TCP_DECR_LISTEN_CNT(tcp);
1309 mutex_enter(&tcp->tcp_non_sq_lock);
1310 if (tcp->tcp_flow_stopped)
1311 tcp_clrqfull(tcp);
1312 mutex_exit(&tcp->tcp_non_sq_lock);
1314 tcp_bind_hash_remove(tcp);
1317 * is trying to remove this tcp from the time wait list, we will
1323 if (tcp->tcp_state == TCPS_TIME_WAIT)
1324 (void) tcp_time_wait_remove(tcp, NULL);
1327 oldstate = tcp->tcp_state;
1328 tcp->tcp_state = TCPS_CLOSED;
1331 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
1342 ASSERT(tcp->tcp_time_wait_next == NULL);
1343 ASSERT(tcp->tcp_time_wait_prev == NULL);
1344 ASSERT(tcp->tcp_time_wait_expire == 0);
1346 tcp_ipsec_cleanup(tcp);
1350 * tcp is dying (called from ipcl_conn_destroy and error cases).
1354 tcp_free(tcp_t *tcp)
1357 conn_t *connp = tcp->tcp_connp;
1359 ASSERT(tcp != NULL);
1360 ASSERT(tcp->tcp_ptpahn == NULL && tcp->tcp_acceptor_hash == NULL);
1365 tcp_close_mpp(&tcp->tcp_xmit_head);
1366 tcp_close_mpp(&tcp->tcp_reass_head);
1367 if (tcp->tcp_rcv_list != NULL) {
1369 tcp_close_mpp(&tcp->tcp_rcv_list);
1371 if ((mp = tcp->tcp_urp_mp) != NULL) {
1374 if ((mp = tcp->tcp_urp_mark_mp) != NULL) {
1378 if (tcp->tcp_fused_sigurg_mp != NULL) {
1379 ASSERT(!IPCL_IS_NONSTR(tcp->tcp_connp));
1380 freeb(tcp->tcp_fused_sigurg_mp);
1381 tcp->tcp_fused_sigurg_mp = NULL;
1384 if (tcp->tcp_ordrel_mp != NULL) {
1385 ASSERT(!IPCL_IS_NONSTR(tcp->tcp_connp));
1386 freeb(tcp->tcp_ordrel_mp);
1387 tcp->tcp_ordrel_mp = NULL;
1390 TCP_NOTSACK_REMOVE_ALL(tcp->tcp_notsack_list, tcp);
1391 bzero(&tcp->tcp_sack_info, sizeof (tcp_sack_info_t));
1393 if (tcp->tcp_hopopts != NULL) {
1394 mi_free(tcp->tcp_hopopts);
1395 tcp->tcp_hopopts = NULL;
1396 tcp->tcp_hopoptslen = 0;
1398 ASSERT(tcp->tcp_hopoptslen == 0);
1399 if (tcp->tcp_dstopts != NULL) {
1400 mi_free(tcp->tcp_dstopts);
1401 tcp->tcp_dstopts = NULL;
1402 tcp->tcp_dstoptslen = 0;
1404 ASSERT(tcp->tcp_dstoptslen == 0);
1405 if (tcp->tcp_rthdrdstopts != NULL) {
1406 mi_free(tcp->tcp_rthdrdstopts);
1407 tcp->tcp_rthdrdstopts = NULL;
1408 tcp->tcp_rthdrdstoptslen = 0;
1410 ASSERT(tcp->tcp_rthdrdstoptslen == 0);
1411 if (tcp->tcp_rthdr != NULL) {
1412 mi_free(tcp->tcp_rthdr);
1413 tcp->tcp_rthdr = NULL;
1414 tcp->tcp_rthdrlen = 0;
1416 ASSERT(tcp->tcp_rthdrlen == 0);
1423 tcp_close_mpp(&tcp->tcp_conn.tcp_eager_conn_ind);
1435 tcp->tcp_detached = B_TRUE;
1445 * tcp_get_conn is used to get a clean tcp connection structure.
1455 * 2) Defence against DOS attack. Allocating a tcp/conn in tcp_input_listener
1457 * But allocating the conn/tcp in IP land is also not the best since
1461 * putting the conn/tcp back in freelist, we don't pay a penalty for
1474 tcp_t *tcp = NULL;
1485 tcp = tcp_time_wait->tcp_free_list;
1486 ASSERT((tcp != NULL) ^ (tcp_time_wait->tcp_free_list_cnt == 0));
1487 if (tcp != NULL) {
1488 tcp_time_wait->tcp_free_list = tcp->tcp_time_wait_next;
1491 tcp->tcp_time_wait_next = NULL;
1492 connp = tcp->tcp_connp;
1495 ASSERT(tcp->tcp_tcps == NULL);
1497 ASSERT(tcp->tcp_rsrv_mp != NULL);
1502 tcp->tcp_tcps = tcps;
1505 connp->conn_ixa->ixa_notify_cookie = tcp;
1527 tcp = connp->conn_tcp;
1528 tcp->tcp_rsrv_mp = tcp_rsrv_mp;
1529 mutex_init(&tcp->tcp_rsrv_mp_lock, NULL, MUTEX_DEFAULT, NULL);
1531 tcp->tcp_tcps = tcps;
1543 connp->conn_ixa->ixa_notify_cookie = tcp;
1554 tcp_connect_ipv4(tcp_t *tcp, ipaddr_t *dstaddrp, in_port_t dstport,
1559 conn_t *connp = tcp->tcp_connp;
1560 tcp_stack_t *tcps = tcp->tcp_tcps;
1600 * in the tcp-four-tuple have been filled in the tcp structure. Now we
1601 * have to see which state tcp was in so we can take appropriate action.
1603 if (tcp->tcp_state == TCPS_IDLE) {
1611 tcp, B_TRUE);
1612 lport = tcp_bindi(tcp, lport, &connp->conn_laddr_v6, 0, B_TRUE,
1622 error = tcp_set_destination(tcp);
1633 tcp->tcp_state = TCPS_SYN_SENT;
1643 tcp_connect_ipv6(tcp_t *tcp, in6_addr_t *dstaddrp, in_port_t dstport,
1647 conn_t *connp = tcp->tcp_connp;
1648 tcp_stack_t *tcps = tcp->tcp_tcps;
1696 * in the tcp-four-tuple have been filled in the tcp structure. Now we
1697 * have to see which state tcp was in so we can take appropriate action.
1699 if (tcp->tcp_state == TCPS_IDLE) {
1707 tcp, B_TRUE);
1708 lport = tcp_bindi(tcp, lport, &connp->conn_laddr_v6, 0, B_TRUE,
1718 error = tcp_set_destination(tcp);
1729 tcp->tcp_state = TCPS_SYN_SENT;
1740 tcp_disconnect_common(tcp_t *tcp, t_scalar_t seqnum)
1743 tcp_stack_t *tcps = tcp->tcp_tcps;
1744 conn_t *connp = tcp->tcp_connp;
1752 if (tcp->tcp_state <= TCPS_BOUND) {
1755 "tcp_disconnect: bad state, %d", tcp->tcp_state);
1758 } else if (tcp->tcp_state >= TCPS_ESTABLISHED) {
1762 if (seqnum == -1 || tcp->tcp_conn_req_max == 0) {
1775 int old_state = tcp->tcp_state;
1782 ASSERT(tcp->tcp_time_wait_next == NULL);
1783 ASSERT(tcp->tcp_time_wait_prev == NULL);
1784 ASSERT(tcp->tcp_time_wait_expire == 0);
1803 if (tcp->tcp_conn_req_max && lconnp == NULL) {
1804 tcp->tcp_state = TCPS_LISTEN;
1806 connp->conn_ixa, void, NULL, tcp_t *, tcp, void,
1809 tcp->tcp_conn_req_max = 0;
1810 tcp->tcp_state = TCPS_BOUND;
1812 connp->conn_ixa, void, NULL, tcp_t *, tcp, void,
1822 if (tcp->tcp_listen_cnt != NULL)
1823 TCP_DECR_LISTEN_CNT(tcp);
1838 if (tcp->tcp_fused)
1839 tcp_unfuse(tcp);
1841 mutex_enter(&tcp->tcp_eager_lock);
1842 if ((tcp->tcp_conn_req_cnt_q0 != 0) ||
1843 (tcp->tcp_conn_req_cnt_q != 0)) {
1844 tcp_eager_cleanup(tcp, 0);
1846 mutex_exit(&tcp->tcp_eager_lock);
1848 tcp_xmit_ctl("tcp_disconnect", tcp, tcp->tcp_snxt,
1849 tcp->tcp_rnxt, TH_RST | TH_ACK);
1851 tcp_reinit(tcp);
1854 } else if (!tcp_eager_blowoff(tcp, seqnum)) {
1866 tcp_disconnect(tcp_t *tcp, mblk_t *mp)
1870 conn_t *connp = tcp->tcp_connp;
1874 tcp_err_ack(tcp, mp, TPROTO, 0);
1878 error = tcp_disconnect_common(tcp, seqnum);
1880 tcp_err_ack(tcp, mp, error, 0);
1882 if (tcp->tcp_state >= TCPS_ESTABLISHED) {
1893 * Handle reinitialization of a tcp structure.
1897 tcp_reinit(tcp_t *tcp)
1900 tcp_stack_t *tcps = tcp->tcp_tcps;
1901 conn_t *connp = tcp->tcp_connp;
1905 ASSERT(tcp->tcp_listener == NULL);
1913 tcp_timers_stop(tcp);
1919 TCPS_UPDATE_MIB(tcps, tcpHCInSegs, tcp->tcp_ibsegs);
1920 tcp->tcp_ibsegs = 0;
1921 TCPS_UPDATE_MIB(tcps, tcpHCOutSegs, tcp->tcp_obsegs);
1922 tcp->tcp_obsegs = 0;
1924 tcp_close_mpp(&tcp->tcp_xmit_head);
1925 if (tcp->tcp_snd_zcopy_aware)
1926 tcp_zcopy_notify(tcp);
1927 tcp->tcp_xmit_last = tcp->tcp_xmit_tail = NULL;
1928 tcp->tcp_unsent = tcp->tcp_xmit_tail_unsent = 0;
1929 mutex_enter(&tcp->tcp_non_sq_lock);
1930 if (tcp->tcp_flow_stopped &&
1931 TCP_UNSENT_BYTES(tcp) <= connp->conn_sndlowat) {
1932 tcp_clrqfull(tcp);
1934 mutex_exit(&tcp->tcp_non_sq_lock);
1935 tcp_close_mpp(&tcp->tcp_reass_head);
1936 tcp->tcp_reass_tail = NULL;
1937 if (tcp->tcp_rcv_list != NULL) {
1939 tcp_close_mpp(&tcp->tcp_rcv_list);
1940 tcp->tcp_rcv_last_head = NULL;
1941 tcp->tcp_rcv_last_tail = NULL;
1942 tcp->tcp_rcv_cnt = 0;
1944 tcp->tcp_rcv_last_tail = NULL;
1946 if ((mp = tcp->tcp_urp_mp) != NULL) {
1948 tcp->tcp_urp_mp = NULL;
1950 if ((mp = tcp->tcp_urp_mark_mp) != NULL) {
1952 tcp->tcp_urp_mark_mp = NULL;
1954 if (tcp->tcp_fused_sigurg_mp != NULL) {
1955 ASSERT(!IPCL_IS_NONSTR(tcp->tcp_connp));
1956 freeb(tcp->tcp_fused_sigurg_mp);
1957 tcp->tcp_fused_sigurg_mp = NULL;
1959 if (tcp->tcp_ordrel_mp != NULL) {
1960 ASSERT(!IPCL_IS_NONSTR(tcp->tcp_connp));
1961 freeb(tcp->tcp_ordrel_mp);
1962 tcp->tcp_ordrel_mp = NULL;
1970 tcp_close_mpp(&tcp->tcp_conn.tcp_eager_conn_ind);
1978 ASSERT(tcp->tcp_time_wait_next == NULL);
1979 ASSERT(tcp->tcp_time_wait_prev == NULL);
1980 ASSERT(tcp->tcp_time_wait_expire == 0);
1985 tcp_reinit_values(tcp);
1989 tcp_ipsec_cleanup(tcp);
1993 oldstate = tcp->tcp_state;
1995 if (tcp->tcp_conn_req_max != 0) {
2013 tcp->tcp_state = TCPS_LISTEN;
2014 tcp->tcp_eager_next_q0 = tcp->tcp_eager_prev_q0 = tcp;
2015 tcp->tcp_eager_next_drop_q0 = tcp;
2016 tcp->tcp_eager_prev_drop_q0 = tcp;
2031 tcp->tcp_state = TCPS_BOUND;
2037 tcp_init_values(tcp, NULL);
2040 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
2043 ASSERT(tcp->tcp_ptpbhn != NULL);
2044 tcp->tcp_rwnd = connp->conn_rcvbuf;
2045 tcp->tcp_mss = connp->conn_ipversion != IPV4_VERSION ?
2057 tcp_reinit_values(tcp)
2058 tcp_t *tcp;
2060 tcp_stack_t *tcps = tcp->tcp_tcps;
2061 conn_t *connp = tcp->tcp_connp;
2071 PRESERVE(tcp->tcp_bind_hash_port);
2072 PRESERVE(tcp->tcp_bind_hash);
2073 PRESERVE(tcp->tcp_ptpbhn);
2074 PRESERVE(tcp->tcp_acceptor_hash);
2075 PRESERVE(tcp->tcp_ptpahn);
2078 ASSERT(tcp->tcp_time_wait_next == NULL);
2079 ASSERT(tcp->tcp_time_wait_prev == NULL);
2080 ASSERT(tcp->tcp_time_wait_expire == 0);
2081 PRESERVE(tcp->tcp_state);
2085 ASSERT(tcp->tcp_xmit_head == NULL);
2086 ASSERT(tcp->tcp_xmit_last == NULL);
2087 ASSERT(tcp->tcp_unsent == 0);
2088 ASSERT(tcp->tcp_xmit_tail == NULL);
2089 ASSERT(tcp->tcp_xmit_tail_unsent == 0);
2091 tcp->tcp_snxt = 0; /* Displayed in mib */
2092 tcp->tcp_suna = 0; /* Displayed in mib */
2093 tcp->tcp_swnd = 0;
2094 DONTCARE(tcp->tcp_cwnd); /* Init in tcp_process_options */
2096 ASSERT(tcp->tcp_ibsegs == 0);
2097 ASSERT(tcp->tcp_obsegs == 0);
2106 tcp->tcp_ipha = NULL;
2107 tcp->tcp_ip6h = NULL;
2108 tcp->tcp_tcpha = NULL;
2114 DONTCARE(tcp->tcp_naglim); /* Init in tcp_init_values */
2115 DONTCARE(tcp->tcp_ipha);
2116 DONTCARE(tcp->tcp_ip6h);
2117 DONTCARE(tcp->tcp_tcpha);
2118 tcp->tcp_valid_bits = 0;
2120 DONTCARE(tcp->tcp_timer_backoff); /* Init in tcp_init_values */
2121 DONTCARE(tcp->tcp_last_recv_time); /* Init in tcp_init_values */
2122 tcp->tcp_last_rcv_lbolt = 0;
2124 tcp->tcp_init_cwnd = 0;
2126 tcp->tcp_urp_last_valid = 0;
2127 tcp->tcp_hard_binding = 0;
2129 tcp->tcp_fin_acked = 0;
2130 tcp->tcp_fin_rcvd = 0;
2131 tcp->tcp_fin_sent = 0;
2132 tcp->tcp_ordrel_done = 0;
2134 tcp->tcp_detached = 0;
2136 tcp->tcp_snd_ws_ok = B_FALSE;
2137 tcp->tcp_snd_ts_ok = B_FALSE;
2138 tcp->tcp_zero_win_probe = 0;
2140 tcp->tcp_loopback = 0;
2141 tcp->tcp_localnet = 0;
2142 tcp->tcp_syn_defense = 0;
2143 tcp->tcp_set_timer = 0;
2145 tcp->tcp_active_open = 0;
2146 tcp->tcp_rexmit = B_FALSE;
2147 tcp->tcp_xmit_zc_clean = B_FALSE;
2149 tcp->tcp_snd_sack_ok = B_FALSE;
2150 tcp->tcp_hwcksum = B_FALSE;
2152 DONTCARE(tcp->tcp_maxpsz_multiplier); /* Init in tcp_init_values */
2154 tcp->tcp_conn_def_q0 = 0;
2155 tcp->tcp_ip_forward_progress = B_FALSE;
2156 tcp->tcp_ecn_ok = B_FALSE;
2158 tcp->tcp_cwr = B_FALSE;
2159 tcp->tcp_ecn_echo_on = B_FALSE;
2160 tcp->tcp_is_wnd_shrnk = B_FALSE;
2162 TCP_NOTSACK_REMOVE_ALL(tcp->tcp_notsack_list, tcp);
2163 bzero(&tcp->tcp_sack_info, sizeof (tcp_sack_info_t));
2165 tcp->tcp_rcv_ws = 0;
2166 tcp->tcp_snd_ws = 0;
2167 tcp->tcp_ts_recent = 0;
2168 tcp->tcp_rnxt = 0; /* Displayed in mib */
2169 DONTCARE(tcp->tcp_rwnd); /* Set in tcp_reinit() */
2170 tcp->tcp_initial_pmtu = 0;
2172 ASSERT(tcp->tcp_reass_head == NULL);
2173 ASSERT(tcp->tcp_reass_tail == NULL);
2175 tcp->tcp_cwnd_cnt = 0;
2177 ASSERT(tcp->tcp_rcv_list == NULL);
2178 ASSERT(tcp->tcp_rcv_last_head == NULL);
2179 ASSERT(tcp->tcp_rcv_last_tail == NULL);
2180 ASSERT(tcp->tcp_rcv_cnt == 0);
2182 DONTCARE(tcp->tcp_cwnd_ssthresh); /* Init in tcp_set_destination */
2183 DONTCARE(tcp->tcp_cwnd_max); /* Init in tcp_init_values */
2184 tcp->tcp_csuna = 0;
2186 tcp->tcp_rto = 0; /* Displayed in MIB */
2187 DONTCARE(tcp->tcp_rtt_sa); /* Init in tcp_init_values */
2188 DONTCARE(tcp->tcp_rtt_sd); /* Init in tcp_init_values */
2189 tcp->tcp_rtt_update = 0;
2191 DONTCARE(tcp->tcp_swl1); /* Init in case TCPS_LISTEN/TCPS_SYN_SENT */
2192 DONTCARE(tcp->tcp_swl2); /* Init in case TCPS_LISTEN/TCPS_SYN_SENT */
2194 tcp->tcp_rack = 0; /* Displayed in mib */
2195 tcp->tcp_rack_cnt = 0;
2196 tcp->tcp_rack_cur_max = 0;
2197 tcp->tcp_rack_abs_max = 0;
2199 tcp->tcp_max_swnd = 0;
2201 ASSERT(tcp->tcp_listener == NULL);
2203 DONTCARE(tcp->tcp_irs); /* tcp_valid_bits cleared */
2204 DONTCARE(tcp->tcp_iss); /* tcp_valid_bits cleared */
2205 DONTCARE(tcp->tcp_fss); /* tcp_valid_bits cleared */
2206 DONTCARE(tcp->tcp_urg); /* tcp_valid_bits cleared */
2208 ASSERT(tcp->tcp_conn_req_cnt_q == 0);
2209 ASSERT(tcp->tcp_conn_req_cnt_q0 == 0);
2210 PRESERVE(tcp->tcp_conn_req_max);
2211 PRESERVE(tcp->tcp_conn_req_seqnum);
2213 DONTCARE(tcp->tcp_first_timer_threshold); /* Init in tcp_init_values */
2214 DONTCARE(tcp->tcp_second_timer_threshold); /* Init in tcp_init_values */
2215 DONTCARE(tcp->tcp_first_ctimer_threshold); /* Init in tcp_init_values */
2216 DONTCARE(tcp->tcp_second_ctimer_threshold); /* in tcp_init_values */
2218 DONTCARE(tcp->tcp_urp_last); /* tcp_urp_last_valid is cleared */
2219 ASSERT(tcp->tcp_urp_mp == NULL);
2220 ASSERT(tcp->tcp_urp_mark_mp == NULL);
2221 ASSERT(tcp->tcp_fused_sigurg_mp == NULL);
2223 ASSERT(tcp->tcp_eager_next_q == NULL);
2224 ASSERT(tcp->tcp_eager_last_q == NULL);
2225 ASSERT((tcp->tcp_eager_next_q0 == NULL &&
2226 tcp->tcp_eager_prev_q0 == NULL) ||
2227 tcp->tcp_eager_next_q0 == tcp->tcp_eager_prev_q0);
2228 ASSERT(tcp->tcp_conn.tcp_eager_conn_ind == NULL);
2230 ASSERT((tcp->tcp_eager_next_drop_q0 == NULL &&
2231 tcp->tcp_eager_prev_drop_q0 == NULL) ||
2232 tcp->tcp_eager_next_drop_q0 == tcp->tcp_eager_prev_drop_q0);
2234 DONTCARE(tcp->tcp_ka_rinterval); /* Init in tcp_init_values */
2235 DONTCARE(tcp->tcp_ka_abort_thres); /* Init in tcp_init_values */
2236 DONTCARE(tcp->tcp_ka_cnt); /* Init in tcp_init_values */
2238 tcp->tcp_client_errno = 0;
2245 tcp->tcp_last_sent_len = 0;
2246 tcp->tcp_dupack_cnt = 0;
2251 PRESERVE(tcp->tcp_acceptor_lockp);
2253 ASSERT(tcp->tcp_ordrel_mp == NULL);
2254 PRESERVE(tcp->tcp_acceptor_id);
2255 DONTCARE(tcp->tcp_ipsec_overhead);
2261 tcp->tcp_mss = tcps->tcps_mss_def_ipv6;
2264 tcp->tcp_mss = tcps->tcps_mss_def_ipv4;
2269 tcp->tcp_recvifindex = 0;
2270 tcp->tcp_recvhops = 0;
2271 tcp->tcp_closed = 0;
2272 if (tcp->tcp_hopopts != NULL) {
2273 mi_free(tcp->tcp_hopopts);
2274 tcp->tcp_hopopts = NULL;
2275 tcp->tcp_hopoptslen = 0;
2277 ASSERT(tcp->tcp_hopoptslen == 0);
2278 if (tcp->tcp_dstopts != NULL) {
2279 mi_free(tcp->tcp_dstopts);
2280 tcp->tcp_dstopts = NULL;
2281 tcp->tcp_dstoptslen = 0;
2283 ASSERT(tcp->tcp_dstoptslen == 0);
2284 if (tcp->tcp_rthdrdstopts != NULL) {
2285 mi_free(tcp->tcp_rthdrdstopts);
2286 tcp->tcp_rthdrdstopts = NULL;
2287 tcp->tcp_rthdrdstoptslen = 0;
2289 ASSERT(tcp->tcp_rthdrdstoptslen == 0);
2290 if (tcp->tcp_rthdr != NULL) {
2291 mi_free(tcp->tcp_rthdr);
2292 tcp->tcp_rthdr = NULL;
2293 tcp->tcp_rthdrlen = 0;
2295 ASSERT(tcp->tcp_rthdrlen == 0);
2298 tcp->tcp_fused = B_FALSE;
2299 tcp->tcp_unfusable = B_FALSE;
2300 tcp->tcp_fused_sigurg = B_FALSE;
2301 tcp->tcp_loopback_peer = NULL;
2303 tcp->tcp_lso = B_FALSE;
2305 tcp->tcp_in_ack_unsent = 0;
2306 tcp->tcp_cork = B_FALSE;
2307 tcp->tcp_tconnind_started = B_FALSE;
2309 PRESERVE(tcp->tcp_squeue_bytes);
2311 tcp->tcp_closemp_used = B_FALSE;
2313 PRESERVE(tcp->tcp_rsrv_mp);
2314 PRESERVE(tcp->tcp_rsrv_mp_lock);
2317 DONTCARE(tcp->tcmp_stk[0]);
2320 PRESERVE(tcp->tcp_connid);
2322 ASSERT(tcp->tcp_listen_cnt == NULL);
2323 ASSERT(tcp->tcp_reass_tid == 0);
2334 tcp_init_values(tcp_t *tcp, tcp_t *parent)
2336 tcp_stack_t *tcps = tcp->tcp_tcps;
2337 conn_t *connp = tcp->tcp_connp;
2347 tcp->tcp_naglim = tcps->tcps_naglim_def;
2349 tcp->tcp_rto_initial = tcps->tcps_rexmit_interval_initial;
2350 tcp->tcp_rto_min = tcps->tcps_rexmit_interval_min;
2351 tcp->tcp_rto_max = tcps->tcps_rexmit_interval_max;
2353 tcp->tcp_first_ctimer_threshold =
2355 tcp->tcp_second_ctimer_threshold =
2357 tcp->tcp_first_timer_threshold = tcps->tcps_ip_notify_interval;
2358 tcp->tcp_second_timer_threshold = tcps->tcps_ip_abort_interval;
2360 tcp->tcp_fin_wait_2_flush_interval =
2363 tcp->tcp_ka_interval = tcps->tcps_keepalive_interval;
2364 tcp->tcp_ka_abort_thres = tcps->tcps_keepalive_abort_interval;
2365 tcp->tcp_ka_cnt = 0;
2366 tcp->tcp_ka_rinterval = 0;
2374 tcp->tcp_naglim = parent->tcp_naglim;
2376 tcp->tcp_rto_initial = parent->tcp_rto_initial;
2377 tcp->tcp_rto_min = parent->tcp_rto_min;
2378 tcp->tcp_rto_max = parent->tcp_rto_max;
2380 tcp->tcp_first_ctimer_threshold =
2382 tcp->tcp_second_ctimer_threshold =
2384 tcp->tcp_first_timer_threshold =
2386 tcp->tcp_second_timer_threshold =
2389 tcp->tcp_fin_wait_2_flush_interval =
2392 tcp->tcp_ka_interval = parent->tcp_ka_interval;
2393 tcp->tcp_ka_abort_thres = parent->tcp_ka_abort_thres;
2394 tcp->tcp_ka_cnt = parent->tcp_ka_cnt;
2395 tcp->tcp_ka_rinterval = parent->tcp_ka_rinterval;
2397 tcp->tcp_init_cwnd = parent->tcp_init_cwnd;
2407 tcp->tcp_rtt_sa = tcp->tcp_rto_initial << 2;
2408 tcp->tcp_rtt_sd = tcp->tcp_rto_initial >> 1;
2409 rto = (tcp->tcp_rtt_sa >> 3) + tcp->tcp_rtt_sd +
2410 tcps->tcps_rexmit_interval_extra + (tcp->tcp_rtt_sa >> 5) +
2412 TCP_SET_RTO(tcp, rto);
2414 tcp->tcp_timer_backoff = 0;
2415 tcp->tcp_ms_we_have_waited = 0;
2416 tcp->tcp_last_recv_time = ddi_get_lbolt();
2417 tcp->tcp_cwnd_max = tcps->tcps_cwnd_max_;
2418 tcp->tcp_cwnd_ssthresh = TCP_MAX_LARGEWIN;
2420 tcp->tcp_maxpsz_multiplier = tcps->tcps_maxpsz_multiplier;
2425 tcp->tcp_fused = B_FALSE;
2426 tcp->tcp_unfusable = B_FALSE;
2427 tcp->tcp_fused_sigurg = B_FALSE;
2428 tcp->tcp_loopback_peer = NULL;
2438 tcp->tcp_rcv_ws = TCP_MAX_WINSHIFT;
2439 tcp->tcp_rwnd = connp->conn_rcvbuf;
2441 tcp->tcp_cork = B_FALSE;
2461 tcp_update_pmtu(tcp_t *tcp, boolean_t decrease_only)
2465 conn_t *connp = tcp->tcp_connp;
2469 if (tcp->tcp_tcps->tcps_ignore_path_mtu)
2472 if (tcp->tcp_state < TCPS_ESTABLISHED)
2492 if (mss == tcp->tcp_mss)
2498 if (mss > tcp->tcp_mss && decrease_only)
2501 DTRACE_PROBE2(tcp_update_pmtu, int32_t, tcp->tcp_mss, uint32_t, mss);
2511 tcp_mss_set(tcp, mss);
2523 if (mss < tcp->tcp_tcps->tcps_mss_min)
2531 tcp->tcp_ipha->ipha_fragment_offset_and_flags = 0;
2537 tcp_maxpsz_set(tcp_t *tcp, boolean_t set_maxblk)
2539 conn_t *connp = tcp->tcp_connp;
2541 int32_t mss = tcp->tcp_mss;
2544 if (TCP_IS_DETACHED(tcp))
2546 if (tcp->tcp_fused) {
2547 maxpsz = tcp_fuse_maxpsz(tcp);
2549 } else if (tcp->tcp_maxpsz_multiplier == 0) {
2566 maxpsz = tcp->tcp_maxpsz_multiplier * mss;
2582 /* For /dev/tcp aka AF_INET open */
2600 tcp_t *tcp = NULL;
2661 tcp = connp->conn_tcp;
2681 tcp->tcp_mss = tcps->tcps_mss_def_ipv6;
2686 tcp->tcp_mss = tcps->tcps_mss_def_ipv4;
2706 ASSERT(tcp->tcp_tcps == tcps);
2718 tcp->tcp_issocket = 1;
2733 SOCK_CONNID_INIT(tcp->tcp_connid);
2734 /* DTrace ignores this - it isn't a tcp:::state-change */
2735 tcp->tcp_state = TCPS_IDLE;
2736 tcp_init_values(tcp, NULL);
2744 tcp_t *tcp = NULL;
2818 tcp = connp->conn_tcp;
2824 tcp->tcp_acceptor_id = (t_uscalar_t)RD(q);
2826 tcp->tcp_acceptor_id = conn_dev;
2828 tcp_acceptor_hash_insert(tcp->tcp_acceptor_id, tcp);
2847 * Build/update the tcp header template (in conn_ht_iphc) based on
2849 * headers, and the maximum size tcp header (to avoid reallocation
2850 * on the fly for additional tcp options).
2856 tcp_build_hdrs(tcp_t *tcp)
2858 tcp_stack_t *tcps = tcp->tcp_tcps;
2859 conn_t *connp = tcp->tcp_connp;
2871 * existing tcp header.
2893 tcp->tcp_tcpha = tcpha;
2895 /* restore any old tcp header */
2919 tcp->tcp_ipha = (ipha_t *)connp->conn_ht_iphc;
2921 tcp->tcp_ip6h = (ip6_t *)connp->conn_ht_iphc;
2953 tcp_rwnd_set(tcp_t *tcp, uint32_t rwnd)
2955 uint32_t mss = tcp->tcp_mss;
2958 boolean_t tcp_detached = TCP_IS_DETACHED(tcp);
2959 tcp_stack_t *tcps = tcp->tcp_tcps;
2960 conn_t *connp = tcp->tcp_connp;
2970 if (tcp->tcp_fused) {
2972 tcp_t *peer_tcp = tcp->tcp_loopback_peer;
2975 sth_hiwat = tcp_fuse_set_rcv_hiwat(tcp, rwnd);
2979 tcp_set_recv_threshold(tcp, sth_hiwat >> 3);
2983 if (tcp->tcp_tcpha != NULL) {
2984 tcp->tcp_tcpha->tha_win =
2985 htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
2987 if ((tcp->tcp_rcv_ws > 0) && rwnd > tcp->tcp_cwnd_max)
2988 tcp->tcp_cwnd_max = rwnd;
3001 old_max_rwnd = tcp->tcp_rwnd;
3012 if (rwnd < old_max_rwnd && tcp->tcp_state > TCPS_SYN_SENT) {
3021 max_transmittable_rwnd = TCP_MAXWIN << tcp->tcp_rcv_ws;
3032 tcp->tcp_rwnd = old_max_rwnd = rwnd;
3034 if (tcp->tcp_localnet) {
3035 tcp->tcp_rack_abs_max =
3043 tcp->tcp_rack_abs_max =
3046 if (tcp->tcp_rack_cur_max > tcp->tcp_rack_abs_max)
3047 tcp->tcp_rack_cur_max = tcp->tcp_rack_abs_max;
3049 tcp->tcp_rack_cur_max = 0;
3055 tcp->tcp_rwnd += rwnd - old_max_rwnd;
3059 if (tcp->tcp_tcpha != NULL) {
3060 tcp->tcp_tcpha->tha_win =
3061 htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
3064 if ((tcp->tcp_rcv_ws > 0) && rwnd > tcp->tcp_cwnd_max)
3065 tcp->tcp_cwnd_max = rwnd;
3070 tcp_set_recv_threshold(tcp, rwnd >> 3);
3079 tcp_t *tcp = connp->conn_tcp;
3082 switch (tcp->tcp_state) {
3094 mutex_enter(&tcp->tcp_eager_lock);
3095 if (tcp->tcp_conn_req_cnt_q0 != 0 || tcp->tcp_conn_req_cnt_q != 0) {
3096 tcp_eager_cleanup(tcp, 0);
3098 mutex_exit(&tcp->tcp_eager_lock);
3101 if (tcp->tcp_listen_cnt != NULL)
3102 TCP_DECR_LISTEN_CNT(tcp);
3105 tcp_bind_hash_remove(tcp);
3106 oldstate = tcp->tcp_state;
3107 tcp->tcp_state = TCPS_IDLE;
3109 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
3122 tcp_get_proto_props(tcp_t *tcp, struct sock_proto_props *sopp)
3124 conn_t *connp = tcp->tcp_connp;
3127 sopp->sopp_maxblk = tcp_maxpsz_set(tcp, B_FALSE);
3129 sopp->sopp_rxhiwat = tcp->tcp_fused ?
3130 tcp_fuse_set_rcv_hiwat(tcp, connp->conn_rcvbuf) :
3136 if (tcp->tcp_fused) {
3137 ASSERT(tcp->tcp_loopback);
3138 ASSERT(tcp->tcp_loopback_peer != NULL);
3140 * For fused tcp loopback, set the stream head's write
3144 * Non-fused tcp loopback case is handled separately below.
3151 (void) tcp_maxpsz_set(tcp->tcp_loopback_peer, B_TRUE);
3152 } else if (tcp->tcp_snd_sack_ok) {
3154 (tcp->tcp_loopback ? 0 : tcp->tcp_tcps->tcps_wroff_xtra);
3157 (tcp->tcp_loopback ? 0 : tcp->tcp_tcps->tcps_wroff_xtra);
3160 if (tcp->tcp_loopback) {
3170 tcp_zcopy_check(tcp_t *tcp)
3172 conn_t *connp = tcp->tcp_connp;
3175 tcp_stack_t *tcps = tcp->tcp_tcps;
3182 tcp->tcp_snd_zcopy_on = zc_enabled;
3183 if (!TCP_IS_DETACHED(tcp)) {
3211 tcp_zcopy_backoff(tcp_t *tcp, mblk_t *bp, boolean_t fix_xmitlist)
3216 tcp_stack_t *tcps = tcp->tcp_tcps;
3223 tcp->tcp_xmit_zc_clean = B_FALSE;
3231 tcp_zcopy_notify(tcp);
3246 if (tcp->tcp_xmit_tail == bp)
3247 tcp->tcp_xmit_tail = nbp;
3273 tcp->tcp_xmit_last = tail;
3274 tcp->tcp_xmit_zc_clean = B_TRUE;
3281 tcp_zcopy_notify(tcp_t *tcp)
3286 if (tcp->tcp_detached)
3288 connp = tcp->tcp_connp;
3305 tcp_update_lso(tcp_t *tcp, ip_xmit_attr_t *ixa)
3327 tcp->tcp_lso_max = MIN(TCP_MAX_LSO_LENGTH, lsoc->ill_lso_max);
3329 DTRACE_PROBE3(tcp_update_lso, boolean_t, tcp->tcp_lso,
3330 boolean_t, B_TRUE, uint32_t, tcp->tcp_lso_max);
3336 if (!tcp->tcp_lso)
3337 tcp->tcp_maxpsz_multiplier = 0;
3339 tcp->tcp_lso = B_TRUE;
3340 TCP_STAT(tcp->tcp_tcps, tcp_lso_enabled);
3342 DTRACE_PROBE3(tcp_update_lso, boolean_t, tcp->tcp_lso,
3343 boolean_t, B_FALSE, uint32_t, tcp->tcp_lso_max);
3349 if (tcp->tcp_lso) {
3350 tcp->tcp_maxpsz_multiplier =
3351 tcp->tcp_tcps->tcps_maxpsz_multiplier;
3353 tcp->tcp_lso = B_FALSE;
3354 TCP_STAT(tcp->tcp_tcps, tcp_lso_disabled);
3358 (void) tcp_maxpsz_set(tcp, B_TRUE);
3365 tcp_update_zcopy(tcp_t *tcp)
3367 conn_t *connp = tcp->tcp_connp;
3368 tcp_stack_t *tcps = tcp->tcp_tcps;
3370 if (tcp->tcp_snd_zcopy_on) {
3371 tcp->tcp_snd_zcopy_on = B_FALSE;
3372 if (!TCP_IS_DETACHED(tcp)) {
3378 tcp->tcp_snd_zcopy_on = B_TRUE;
3379 if (!TCP_IS_DETACHED(tcp)) {
3396 tcp_t *tcp = (tcp_t *)arg;
3397 conn_t *connp = tcp->tcp_connp;
3401 tcp_update_lso(tcp, connp->conn_ixa);
3404 tcp_update_pmtu(tcp, B_FALSE);
3407 tcp_update_zcopy(tcp);
3428 * Returns with a CONN_INC_REF tcp structure. Caller must do a CONN_DEC_REF.
3434 tcp_t *tcp;
3438 for (tcp = tf->tf_tcp; tcp != NULL;
3439 tcp = tcp->tcp_acceptor_hash) {
3440 if (tcp->tcp_acceptor_id == id) {
3441 CONN_INC_REF(tcp->tcp_connp);
3443 return (tcp);
3454 tcp_acceptor_hash_insert(t_uscalar_t id, tcp_t *tcp)
3459 tcp_stack_t *tcps = tcp->tcp_tcps;
3463 if (tcp->tcp_ptpahn != NULL)
3464 tcp_acceptor_hash_remove(tcp);
3469 tcpnext->tcp_ptpahn = &tcp->tcp_acceptor_hash;
3470 tcp->tcp_acceptor_hash = tcpnext;
3471 tcp->tcp_ptpahn = tcpp;
3472 tcpp[0] = tcp;
3473 tcp->tcp_acceptor_lockp = &tf->tf_lock; /* For tcp_*_hash_remove */
3481 tcp_acceptor_hash_remove(tcp_t *tcp)
3490 lockp = tcp->tcp_acceptor_lockp;
3492 if (tcp->tcp_ptpahn == NULL)
3497 if (tcp->tcp_ptpahn) {
3498 tcpnext = tcp->tcp_acceptor_hash;
3500 tcpnext->tcp_ptpahn = tcp->tcp_ptpahn;
3501 tcp->tcp_acceptor_hash = NULL;
3503 *tcp->tcp_ptpahn = tcpnext;
3504 tcp->tcp_ptpahn = NULL;
3507 tcp->tcp_acceptor_lockp = NULL;
3931 tcp_iss_init(tcp_t *tcp)
3936 tcp_stack_t *tcps = tcp->tcp_tcps;
3937 conn_t *connp = tcp->tcp_connp;
3940 tcp->tcp_iss = tcps->tcps_iss_incr_extra;
3951 tcp->tcp_iss += answer[0] ^ answer[1] ^ answer[2] ^ answer[3];
3959 tcp->tcp_iss += (gethrtime() >> ISS_NSEC_SHT) + tcp_random();
3962 tcp->tcp_iss += (uint32_t)gethrestime_sec() *
3966 tcp->tcp_valid_bits = TCP_ISS_VALID;
3967 tcp->tcp_fss = tcp->tcp_iss - 1;
3968 tcp->tcp_suna = tcp->tcp_iss;
3969 tcp->tcp_snxt = tcp->tcp_iss + 1;
3970 tcp->tcp_rexmit_nxt = tcp->tcp_snxt;
3971 tcp->tcp_csuna = tcp->tcp_snxt;
3981 tcp_setqfull(tcp_t *tcp)
3983 tcp_stack_t *tcps = tcp->tcp_tcps;
3984 conn_t *connp = tcp->tcp_connp;
3986 if (tcp->tcp_closed)
3989 conn_setqfull(connp, &tcp->tcp_flow_stopped);
3990 if (tcp->tcp_flow_stopped)
3995 tcp_clrqfull(tcp_t *tcp)
3997 conn_t *connp = tcp->tcp_connp;
3999 if (tcp->tcp_closed)
4001 conn_clrqfull(connp, &tcp->tcp_flow_stopped);
4054 tcp_t *tcp = connp->conn_tcp;
4056 if (tcp->tcp_state >= TCPS_BOUND) {
4059 "tcp_bind: bad state, %d", tcp->tcp_state);
4068 ASSERT(tcp->tcp_state == TCPS_BOUND);
4069 tcp->tcp_conn_req_max = 0;
4082 tcp_t *tcp = connp->conn_tcp;
4091 tcp_stack_t *tcps = tcp->tcp_tcps;
4095 oldstate = tcp->tcp_state;
4137 switch (tcp->tcp_state) {
4178 error = tcp_connect_ipv6(tcp, &sin6->sin6_addr,
4195 error = tcp_connect_ipv4(tcp, dstaddrp, dstport,
4202 error = tcp_connect_ipv4(tcp, dstaddrp, dstport, srcid);
4214 tcp->tcp_active_open = 1;
4219 mss = tcp->tcp_mss - connp->conn_ht_iphc_len;
4228 tcp->tcp_rwnd = connp->conn_rcvbuf;
4229 tcp->tcp_rwnd = MAX(MSS_ROUNDUP(tcp->tcp_rwnd, mss),
4231 connp->conn_rcvbuf = tcp->tcp_rwnd;
4232 tcp_set_ws_value(tcp);
4233 tcp->tcp_tcpha->tha_win = htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
4234 if (tcp->tcp_rcv_ws > 0 || tcps->tcps_wscale_always)
4235 tcp->tcp_snd_ws_ok = B_TRUE;
4244 (tcp->tcp_rcv_ws && tcps->tcps_tstamp_if_wscale)) {
4245 tcp->tcp_snd_ts_ok = B_TRUE;
4254 ASSERT(tcp->tcp_num_sack_blk == 0);
4255 ASSERT(tcp->tcp_notsack_list == NULL);
4256 tcp->tcp_snd_sack_ok = B_TRUE;
4268 tcp->tcp_ecn_ok = B_TRUE;
4272 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
4275 TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
4276 syn_mp = tcp_xmit_mp(tcp, NULL, 0, NULL, NULL,
4277 tcp->tcp_iss, B_FALSE, NULL, B_FALSE);
4284 SOCK_CONNID_BUMP(tcp->tcp_connid);
4287 * tcp:::connect-request event.
4291 void_ip_t *, syn_mp->b_rptr, tcp_t *, tcp,
4294 tcp_send_data(tcp, syn_mp);
4297 if (tcp->tcp_conn.tcp_opts_conn_req != NULL)
4298 tcp_close_mpp(&tcp->tcp_conn.tcp_opts_conn_req);
4304 tcp->tcp_state = oldstate;
4305 if (tcp->tcp_conn.tcp_opts_conn_req != NULL)
4306 tcp_close_mpp(&tcp->tcp_conn.tcp_opts_conn_req);
4314 tcp_t *tcp = connp->conn_tcp;
4316 tcp_stack_t *tcps = tcp->tcp_tcps;
4322 if (tcp->tcp_state >= TCPS_BOUND) {
4323 if ((tcp->tcp_state == TCPS_BOUND ||
4324 tcp->tcp_state == TCPS_LISTEN) && backlog > 0) {
4336 "tcp_listen: bad state, %d", tcp->tcp_state);
4370 ASSERT(tcp->tcp_state == TCPS_BOUND || tcp->tcp_state == TCPS_LISTEN);
4371 tcp->tcp_conn_req_max = backlog;
4372 if (tcp->tcp_conn_req_max) {
4373 if (tcp->tcp_conn_req_max < tcps->tcps_conn_req_min)
4374 tcp->tcp_conn_req_max = tcps->tcps_conn_req_min;
4375 if (tcp->tcp_conn_req_max > tcps->tcps_conn_req_max_q)
4376 tcp->tcp_conn_req_max = tcps->tcps_conn_req_max_q;
4383 if (tcp->tcp_state != TCPS_LISTEN) {
4384 tcp->tcp_state = TCPS_LISTEN;
4386 connp->conn_ixa, void, NULL, tcp_t *, tcp,
4389 tcp->tcp_eager_next_q0 = tcp->tcp_eager_prev_q0 = tcp;
4390 tcp->tcp_eager_next_drop_q0 = tcp;
4391 tcp->tcp_eager_prev_drop_q0 = tcp;
4392 tcp->tcp_second_ctimer_threshold =
4413 oldstate = tcp->tcp_state;
4414 tcp->tcp_state = TCPS_IDLE;
4416 connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
4434 tcp_bind_hash_remove(tcp);
4443 tcp->tcp_listen_cnt == NULL) {
4478 tcp->tcp_listen_cnt = tlc;