inet/tcp/tcp_input.c

777  *    either when eager goes into ESTABLISHED, or gets freed up.)
784 	tcp_t	*eager;
791 	/* Pick oldest eager from the list of droppable eagers */
792 	eager = tcp->tcp_eager_prev_drop_q0;
795 	if (eager == tcp) {
804 	 * Take this eager out from the list of droppable eagers since we are
807 	MAKE_UNDROPPABLE(eager);
820 	CONN_INC_REF(eager->tcp_connp);
822 	SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
823 	    tcp_clean_death_wrapper, eager->tcp_connp, NULL,
975  * Called via squeue to get on to eager's perimeter. It sends a
976  * TH_RST if eager is in the fanout table. The listener wants the
977  * eager to disappear either by means of tcp_eager_blowoff() or
979  * called (via squeue) if the eager cannot be inserted in the
987 	tcp_t	*eager = econnp->conn_tcp;
988 	tcp_t	*listener = eager->tcp_listener;
992 	 * the eager was using listener's queue's, we avoid
995 	ASSERT(eager->tcp_detached);
1000 	 * An eager's conn_fanout will be NULL if it's a duplicate
1004 	if (econnp->conn_fanout != NULL && eager->tcp_state > TCPS_LISTEN) {
1006 		    eager, eager->tcp_snxt, 0, TH_RST);
1009 	/* We are here because listener wants this eager gone */
1012 		tcp_eager_unlink(eager);
1013 		if (eager->tcp_tconnind_started) {
1015 			 * The eager has sent a conn_ind up to the
1018 			 * placed on eager in tcp_input_data() before
1027 	if (eager->tcp_state != TCPS_CLOSED)
1028 		tcp_close_detached(eager);
1032  * Reset any eager connection hanging off this listener marked
1038 	tcp_t	*eager;
1041 	eager = listener;
1044 		eager = eager->tcp_eager_next_q;
1045 		if (eager == NULL) {
1049 	} while (eager->tcp_conn_req_seqnum != seqnum);
1051 	if (eager->tcp_closemp_used) {
1055 	eager->tcp_closemp_used = B_TRUE;
1056 	TCP_DEBUG_GETPCSTACK(eager->tcmp_stk, 15);
1057 	CONN_INC_REF(eager->tcp_connp);
1059 	mp = &eager->tcp_closemp;
1060 	SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp, tcp_eager_kill,
1061 	    eager->tcp_connp, NULL, SQ_FILL, SQTAG_TCP_EAGER_BLOWOFF);
1066  * Reset any eager connection hanging off this listener
1072 	tcp_t	*eager;
1081 		eager = listener->tcp_eager_next_q;
1082 		while (eager != NULL) {
1083 			if (!eager->tcp_closemp_used) {
1084 				eager->tcp_closemp_used = B_TRUE;
1085 				TCP_DEBUG_GETPCSTACK(eager->tcmp_stk, 15);
1086 				CONN_INC_REF(eager->tcp_connp);
1087 				mp = &eager->tcp_closemp;
1088 				SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
1089 				    tcp_eager_kill, eager->tcp_connp, NULL,
1092 			eager = eager->tcp_eager_next_q;
1097 	eager = listener->tcp_eager_next_q0;
1098 	while (eager != listener) {
1099 		if (!eager->tcp_closemp_used) {
1100 			eager->tcp_closemp_used = B_TRUE;
1101 			TCP_DEBUG_GETPCSTACK(eager->tcmp_stk, 15);
1102 			CONN_INC_REF(eager->tcp_connp);
1103 			mp = &eager->tcp_closemp;
1104 			SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
1105 			    tcp_eager_kill, eager->tcp_connp, NULL, SQ_FILL,
1108 		eager = eager->tcp_eager_next_q0;
1113  * If we are an eager connection hanging off a listener that hasn't
1127 		/* Remove the eager tcp from q0 */
1139 		 * Take the eager out, if it is in the list of droppable
1170 						 * is only one eager in the
1197  * The eager is now established in its own perimeter as soon as SYN is
1209  * incoming SYN-ACK-ACK (eager perim) 	-> tcp_input_data()
1220  * tcp_tli_accept() extracts the eager and makes the q->q_ptr <-> eager
1221  * association (we are not behind eager's squeue but sockfs is protecting us
1237  * a M_SETOPS mblk to eager perimeter to finish accept (tcp_accept_finish()).
1248  * 1) We start out in tcp_input_listener by eager placing a ref on
1249  * listener and listener adding eager to listeners->tcp_eager_next_q0.
1252  * doing so we place a ref on the eager. This ref is finally dropped at the
1259  * In the above scheme, the eager is the entity that adds and releases the
1260  * references. Note that tcp_accept_finish executes in the squeue of the eager
1262  * in the listener's squeue, the eager is nascent at this point and the
1263  * reference can be considered to have been added on behalf of the eager.
1268  * Once the listener and eager are linked, the listener never does the unlink.
1270  * a message on all eager perimeter. The eager then does the unlink, clears
1276  * Similarly, if eager decides to go away, it can unlink itself and close.
1277  * When the T_CONN_RES comes down, we check if eager has closed. Note that
1278  * the reference to eager is still valid because of the extra ref we put
1281  * Listener can always locate the eager under the protection
1283  * on the eager during the accept processing.
1285  * The acceptor stream accesses the eager in the accept processing
1286  * based on the ref placed on eager before sending T_conn_ind.
1293  * If the accept happens (even on a closed eager) the eager drops its
1295  * eager is killed due to an incoming RST before the T_conn_ind is sent up,
1298  * is dropped while executing in the eager's context (squeue).
1315 	tcp_t		*eager;
1490 	eager = econnp->conn_tcp;
1491 	eager->tcp_detached = B_TRUE;
1492 	SOCK_CONNID_INIT(eager->tcp_connid);
1495 	 * Initialize the eager's tcp_t and inherit some parameters from
1498 	tcp_init_values(eager, listener);
1510 	eager->tcp_recvifindex = 0;
1511 	eager->tcp_recvhops = 0xffffffffU;
1537 	ASSERT(eager->tcp_conn.tcp_eager_conn_ind == NULL);
1538 	ASSERT(!eager->tcp_tconnind_started);
1546 	eager->tcp_conn.tcp_eager_conn_ind = tpi_mp;
1547 	ASSERT(eager->tcp_ordrel_mp == NULL);
1553 		eager->tcp_issocket = B_TRUE;
1561 		if ((eager->tcp_ordrel_mp = mi_tpi_ordrel_ind()) == NULL)
1584 	 * metrics. If it does not, the eager's receive window will be set
1587 	eager->tcp_rwnd = 0;
1639 	eager->tcp_hard_binding = B_TRUE;
1642 	    TCP_BIND_HASH(econnp->conn_lport)], eager, 0);
1646 		tcp_bind_hash_remove(eager);
1650 	SOCK_CONNID_BUMP(eager->tcp_connid);
1656 	if (tcp_set_destination(eager) != 0) {
1659 		tcp_bind_hash_remove(eager);
1664 	tcp_process_options(eager, tcpha);
1669 		eager->tcp_ecn_ok = B_TRUE;
1675 	 * eager's tcp_rwnd to the nearest MSS. Then find out the window
1682 	eager->tcp_rwnd = MSS_ROUNDUP(
1683 	    (eager->tcp_rwnd == 0 ? econnp->conn_rcvbuf :
1684 	    eager->tcp_rwnd), eager->tcp_mss);
1685 	if (eager->tcp_snd_ws_ok)
1686 		tcp_set_ws_value(eager);
1693 	(void) tcp_rwnd_set(eager, eager->tcp_rwnd);
1695 	ASSERT(eager->tcp_connp->conn_rcvbuf != 0 &&
1696 	    eager->tcp_connp->conn_rcvbuf == eager->tcp_rwnd);
1699 	    econnp->conn_rcvbuf == eager->tcp_rwnd);
1701 	/* Put a ref on the listener for the eager. */
1704 	listener->tcp_eager_next_q0->tcp_eager_prev_q0 = eager;
1705 	eager->tcp_eager_next_q0 = listener->tcp_eager_next_q0;
1706 	listener->tcp_eager_next_q0 = eager;
1707 	eager->tcp_eager_prev_q0 = listener;
1710 	eager->tcp_listener = listener;
1711 	eager->tcp_saved_listener = listener;
1717 	eager->tcp_listen_cnt = listener->tcp_listen_cnt;
1723 	eager->tcp_conn_req_seqnum = listener->tcp_conn_req_seqnum;
1741 			eager->tcp_dontdrop = B_TRUE;
1746 	 * We need to insert the eager in its own perimeter but as soon
1747 	 * as we do that, we expose the eager to the classifier and
1748 	 * should not touch any field outside the eager's perimeter.
1749 	 * So do all the work necessary before inserting the eager
1754 	eager->tcp_irs = seg_seq;
1755 	eager->tcp_rack = seg_seq;
1756 	eager->tcp_rnxt = seg_seq + 1;
1757 	eager->tcp_tcpha->tha_ack = htonl(eager->tcp_rnxt);
1759 	eager->tcp_state = TCPS_SYN_RCVD;
1761 	    econnp->conn_ixa, void, NULL, tcp_t *, eager, void, NULL,
1764 	mp1 = tcp_xmit_mp(eager, eager->tcp_xmit_head, eager->tcp_mss,
1765 	    NULL, NULL, eager->tcp_iss, B_FALSE, NULL, B_FALSE);
1780 	 * being sent on the wire for the eager, our initial tcp_rto
1794 	 * for this eager.
1796 	 * It is necessary to acquire an extra reference on the eager
1798 	 * ensure against an eager close race.
1803 	TCP_TIMER_RESTART(eager, eager->tcp_rto);
1806 	 * Insert the eager in its own perimeter now. We are ready to deal
1807 	 * with any packets on eager.
1821 		    tcp_t *, eager, __dtrace_tcp_tcph_t *,
1832 	eager->tcp_closemp_used = B_TRUE;
1833 	TCP_DEBUG_GETPCSTACK(eager->tcmp_stk, 15);
1834 	mp1 = &eager->tcp_closemp;
1985 	/* Can't drain on an eager connection */
2367 		 * eager and completion of the accept are not atomic.
2776 	 * If this is a detached connection and not an eager
3611 			 * We are here means eager is fine but it can
3614 			 * ensure that reference to eager is valid after
3615 			 * we get out of eager's perimeter. So we do
3632 				/* ... and close the eager */
3656 			 * We are here means eager is fine but it can
3659 			 * ensure that reference to eager is valid after
3660 			 * we get out of eager's perimeter. So we do
3677 				 * listener and eager squeues are the same.
3679 				 * because neither the eager nor the listener
4477 			 * conn is detached or it is a STREAMS based eager.
4478 			 * In the eager case we defer the notification until
4651 		 *	Making M_PCPROTO and MARK messages skip the eager case
4861 		 * we send up an ordrel_ind, unless this is an eager, in which
4864 		 * eager, because we have an upper handle to send it to.