Lines Matching defs:eager
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.