Lines Matching defs:eager
951 * Swap information between the eager and acceptor for a TLI/XTI client.
954 * called. In either case, both the eager and listener are in their own
960 tcp_accept_swap(tcp_t *listener, tcp_t *acceptor, tcp_t *eager)
964 ASSERT(eager->tcp_connp->conn_rq == listener->tcp_connp->conn_rq);
965 ASSERT(eager->tcp_detached && !acceptor->tcp_detached);
967 ASSERT(!TCP_IS_SOCKET(eager));
980 * To permit stream re-use by TLI/XTI, the eager needs a copy of
983 eager->tcp_acceptor_id = acceptor->tcp_acceptor_id;
985 /* remove eager from listen list... */
987 tcp_eager_unlink(eager);
988 ASSERT(eager->tcp_eager_next_q == NULL &&
989 eager->tcp_eager_last_q == NULL);
990 ASSERT(eager->tcp_eager_next_q0 == NULL &&
991 eager->tcp_eager_prev_q0 == NULL);
994 econnp = eager->tcp_connp;
1010 eager->tcp_detached = B_FALSE;
1012 ASSERT(eager->tcp_ack_tid == 0);
1026 ASSERT(eager->tcp_tcps == acceptor->tcp_tcps);
1065 * Drop the eager's ref on the listener, that was placed when
1066 * this eager began life in tcp_input_listener.
1074 * Someone blewoff the eager before we could finish
1077 * The only reason eager exists it because we put in
1080 * on the eager will be dropped by the squeue when we
1153 * in case the eager was flow-controlled, w/o this
1206 * At this point, eager is fully established and will
1295 tcp_t *eager;
1318 * Once the acceptor/eager are modified (in tcp_accept_swap) the
1332 * queue hash lookup since that will return an eager listener in a
1338 eager = listener->tcp_eager_next_q;
1341 (eager->tcp_conn_req_seqnum != tcr->SEQ_number)) {
1359 * Transfer tcp_conn_req_max to the eager so that when
1363 eager->tcp_conn_req_max = listener->tcp_conn_req_max;
1410 * Rendezvous with an eager connection request packet hanging off
1416 eager = listener;
1418 eager = eager->tcp_eager_next_q;
1419 if (eager == NULL) {
1425 } while (eager->tcp_conn_req_seqnum != seqnum);
1434 * and eager's ref on listener.
1440 * The eager at this point is set in its own squeue and
1445 ASSERT(eager->tcp_connp->conn_ref >= 1);
1455 CONN_DEC_REF(eager->tcp_connp);
1460 econnp = eager->tcp_connp;
1465 CONN_DEC_REF(eager->tcp_connp);
1492 CONN_DEC_REF(eager->tcp_connp);
1541 tcp_accept_swap(listener, acceptor, eager);
1544 * tcp_accept_swap unlinks eager from listener but does not drop
1545 * the eager's reference on the listener.
1547 ASSERT(eager->tcp_listener == NULL);
1551 * The eager is now associated with its own queue. Insert in
1555 tcp_acceptor_hash_insert(acceptor_id, eager);
1566 * are appropriate to inherit from listner=>eager are done
1568 * in transfer logic from eager=>acceptor in tcp_accept_swap().
1583 if (tcp_conprim_opt_process(eager, mp1,
1585 eager->tcp_accept_error = 1;
1592 * put a T_DISCON_IND on the eager queue.
1595 eager->tcp_send_discon_ind = 1;
1609 * eager->tcp_send_discon_ind set).
1666 * eager same squeue as listener (we can distinguish non socket
1675 SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, discon_mp,
1676 tcp_accept_finish, eager->tcp_connp, NULL, SQ_FILL,
1691 tcp_t *eager;
1738 &eager, conn_res->OPT_length);
1745 econnp = eager->tcp_connp;
1754 listener = eager->tcp_listener;
1770 eager->tcp_issocket = B_TRUE;
1774 ASSERT(eager->tcp_tcps == listener->tcp_tcps);
1785 * classifier hash list. However the eager could have received
1787 * the eager from the classifier hash list, hence we can't
1802 tcp_eager_unlink(eager);
1806 * At this point, the eager is detached from the listener
1807 * but we still have an extra refs on eager (apart from the
1884 * a cleanup/blowoff to happen for the eager, so
1899 * if listener's perimeter is same as eager's.
1913 /* retrieve the eager */
1922 * sending eager as an option since it violates
1923 * the option semantics. So remove the eager as
1933 * a cleanup/blowoff to happen for the eager. We
1949 * Take the eager out, if it is in the list of droppable eagers
1958 * The eager already has an extra ref put in tcp_input_data
1990 * done with the eager. Once we have have sent up
1992 * any time and release the refhold we have on the eager.