/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2016 Joyent, Inc.
*/
/*
* This file contains functions related to TCP time wait processing. Also
* refer to the time wait handling comments in tcp_impl.h.
*/
#include <sys/squeue_impl.h>
#include <inet/tcp_impl.h>
#include <inet/tcp_cluster.h>
#define TW_BUCKET(t) \
/*
* Remove a connection from the list of detached TIME_WAIT connections.
* It returns B_FALSE if it can't remove the connection from the list
* as the connection has already been removed from the list due to an
* earlier call to tcp_time_wait_remove(); otherwise it returns B_TRUE.
*/
{
tsp = *((tcp_squeue_priv_t **)
} else {
}
/* 0 means that the tcp_t has not been added to the time wait list. */
if (tcp->tcp_time_wait_expire == 0) {
if (locked)
return (B_FALSE);
}
}
} else {
unsigned int bucket;
}
tcp->tcp_time_wait_expire = 0;
tsp->tcp_time_wait_cnt--;
if (locked)
return (B_TRUE);
}
/* Constants used for fast checking of a localhost address */
#if defined(_BIG_ENDIAN)
#else
#endif
#define IS_LOCAL_HOST(x) ( \
/*
* Add a connection to the list of detached TIME_WAIT connections
* and set its time to expire.
*/
void
{
unsigned int bucket;
/* Freed above */
/* must have happened at the time of detaching the tcp */
/*
* Immediately expire loopback connections. Since there is no worry
* about packets on the local host showing up after a long network
* delay, this is safe and allows much higher rates of connection churn
* for applications operating locally.
*
* This typically bypasses the tcp_free_list fast path due to squeue
* re-entry for the loopback close operation.
*/
if (tcp->tcp_loopback) {
return;
}
/*
* In order to reap TIME_WAITs reliably, we should use a source of time
* that is not adjustable by the user. While it would be more accurate
* to grab this timestamp before (potentially) sleeping on the
* tcp_time_wait_lock, doing so complicates bucket addressing later.
*/
now = ddi_get_lbolt64();
/*
* Each squeue uses an arbitrary time offset when scheduling
* expiration timers. This prevents the bucketing from forcing
* tcp_time_wait_collector to run in locksetup across squeues.
*
* This offset is (re)initialized when a new TIME_WAIT connection is
* added to an squeue which has no connections waiting to expire.
*/
if (tsp->tcp_time_wait_tid == 0) {
}
/*
* Use the netstack-defined timeout, rounded up to the minimum
* time_wait_collector interval.
*/
/*
* Append the connection into the appropriate bucket.
*/
}
tsp->tcp_time_wait_cnt++;
/*
* Round delay up to the nearest bucket boundary.
*/
/*
* The newly inserted entry may require a tighter schedule for the
* expiration timer.
*/
/*
* It is possible for the timer to fire before the untimeout
* action is able to complete. In that case, the exclusion
* offered by the tcp_time_wait_collector_active flag will
* prevent multiple collector threads from processing records
* simultaneously from the same squeue.
*/
(void) untimeout_default(old_tid, 0);
return;
}
/*
* Start a fresh timer if none exists.
*/
if (tsp->tcp_time_wait_schedule == 0) {
}
}
/*
* Wrapper to call tcp_close_detached() via squeue to clean up TIME-WAIT
* tcp_t. Used in tcp_time_wait_collector().
*/
/* ARGSUSED */
static void
{
return;
}
/*
* Because they have no upstream client to rebind or tcp_close()
* them later, we axe the connection here and now.
*/
}
static void
{
/*
* This is essentially a TIME_WAIT reclaim fast path optimization for
* performance where the connection is checked under the fanout lock
* (so that no one else can get access to the conn_t) that the refcnt
* is 2 (one each for TCP and the classifier hash list). That is the
* case and clustering callbacks are not enabled, the conn can be
* removed under the fanout lock and avoid clean-up under the squeue.
*
* This optimization is forgone when clustering is enabled since the
* clustering callback must be made before setting the CONDEMNED flag
* and after dropping all locks
*
* See the comments in tcp_closei_local for additional information
* regarding the refcnt logic.
*/
if (mutex_tryenter(lock)) {
/*
* Set the CONDEMNED flag now itself so that the refcnt
* cannot increase due to any walker.
*/
/*
* Add to head of tcp_free_list
*/
tsp->tcp_free_list_cnt++;
} else {
/*
* Do not add to tcp_free_list
*/
}
/*
* With the fast-path complete, we can bail.
*/
return;
} else {
/*
* Fall back to slow path.
*/
}
} else {
}
/*
* We can reuse the closemp here since conn has detached (otherwise we
* wouldn't even be in time_wait list). It is safe to change
* tcp_closemp_used without taking a lock as no other thread can
* concurrently access it at this point in the connection lifecycle.
*/
} else {
"tcp_timewait_collector: concurrent use of tcp_closemp: "
}
}
/*
* Purge any tcp_t instances associated with this squeue which have expired
* from the TIME_WAIT state.
*/
void
{
unsigned int idx;
/*
* Because of timer scheduling complexity and the fact that the
* tcp_time_wait_lock is dropped during tcp_time_wait_purge, it is
* possible for multiple tcp_time_wait_collector threads to run against
* the same squeue. This flag is used to exclude other collectors from
* the squeue during execution.
*/
if (tsp->tcp_time_wait_collector_active) {
return;
}
/*
* After its assignment here, the value of sched_active must not be
* altered as it is used to validate the state of the
* tcp_time_wait_collector callout schedule for this squeue.
*
* The same does not hold true of sched_cur, which holds the timestamp
* of the bucket undergoing processing. While it is initially equal to
* sched_active, certain conditions below can walk it forward,
* triggering the retry loop.
*/
/*
* Purge the free list if necessary
*/
tsp->tcp_free_list_cnt--;
}
}
/*
* If there are no connections pending, clear timer-related state to be
* reinitialized by the next caller.
*/
if (tsp->tcp_time_wait_cnt == 0) {
tsp->tcp_time_wait_offset = 0;
tsp->tcp_time_wait_schedule = 0;
tsp->tcp_time_wait_tid = 0;
return;
}
/*
* Grab the bucket which we were scheduled to cleanse.
*/
/*
* Since the bucket count is sized to prevent wrap-around
* during typical operation and timers are schedule to process
* buckets with only expired connections, there is only one
* reason to encounter a connection expiring in the future:
* The tcp_time_wait_collector thread has been so delayed in
* its processing that connections have wrapped around the
* timing wheel into this bucket.
*
* In that case, the remaining entires in the bucket can be
* ignored since, being appended sequentially, they should all
* expire in the future.
*/
break;
}
/*
* Pull the connection out of the bucket.
*/
/*
* Purge the connection.
*
* While tcp_time_wait_lock will be temporarily dropped as part
* of the process, there is no risk of the timer being
* (re)scheduled while the collector is running since a value
* corresponding to the past is left in tcp_time_wait_schedule.
*/
/*
* Because tcp_time_wait_remove clears the tcp_time_wait_next
* field, the next item must be grabbed directly from the
* bucket itself.
*/
}
if (tsp->tcp_time_wait_cnt == 0) {
/*
* There is not a need for the collector to schedule a new
* timer if no pending items remain. The timer state can be
* cleared only if it was untouched while the collector dropped
* its locks during tcp_time_wait_purge.
*/
tsp->tcp_time_wait_offset = 0;
tsp->tcp_time_wait_schedule = 0;
tsp->tcp_time_wait_tid = 0;
}
return;
} else {
unsigned int nidx;
/*
* Locate the next bucket containing entries.
*/
break;
}
}
}
/*
* It is possible that the system is under such dire load that between
* the timer scheduling and TIME_WAIT processing delay, execution
* overran the interval allocated to this bucket.
*/
/*
* Attempt to right the situation by immediately performing a
* purge on the next bucket. This loop will continue as needed
* until the schedule can be pushed out ahead of the clock.
*/
goto retry;
}
/*
* Another thread may have snuck in to reschedule the timer while locks
* were dropped during tcp_time_wait_purge. Defer to the running timer
* if that is the case.
*/
return;
}
/*
* Schedule the next timer.
*/
}
/*
* tcp_time_wait_processing() handles processing of incoming packets when
* the tcp_t is in the TIME_WAIT state.
*
* A TIME_WAIT tcp_t that has an associated open TCP end point (not in
* detached state) is never put on the time wait list.
*/
void
{
int options;
if (tcp->tcp_snd_sack_ok)
else
if (!(options & TCP_OPT_TSTAMP_PRESENT)) {
goto done;
TH_ACK);
goto done;
}
}
if (gap < 0) {
goto done;
}
/*
* When TCP receives a duplicate FIN in
* TIME_WAIT state, restart the 2 MSL timer.
* See page 73 in RFC 793. Make sure this TCP
* is already on the TIME_WAIT list. If not,
* just restart the timer.
*/
if (TCP_IS_DETACHED(tcp)) {
B_TRUE) {
}
} else {
}
goto done;
}
flags |= TH_ACK_NEEDED;
seg_len = 0;
goto process_ack;
}
/* Fix seg_seq, and chew the gap off the front. */
}
/*
* Make sure that when we accept the connection, pick
* an ISS greater than (tcp_snxt + tcp_iss_incr/2) for the
* old connection.
*
* The next ISS generated is equal to tcp_iss_incr_extra
* + tcp_iss_incr/2 + other components depending on the
* value of tcp_strong_iss. We pre-calculate the new
* ISS here and compare with tcp_snxt to determine if
* we need to make adjustment to tcp_iss_incr_extra.
*
* The above calculation is ugly and is a
* waste of CPU cycles...
*/
switch (tcps->tcps_strong_iss) {
case 2: {
/* Add time and MD5 components. */
struct {
} arg;
/* We use MAPPED addresses in tcp_iss_init */
sizeof (arg));
break;
}
case 1:
/* Add time component and min random (i.e. 1). */
break;
default:
/* Add only time component. */
break;
}
/*
* New ISS not guaranteed to be tcp_iss_incr/2
* ahead of the current tcp_snxt, so add the
* difference to tcp_iss_incr_extra.
*/
}
/*
* If tcp_clean_death() can not perform the task now,
* drop the SYN packet and let the other side re-xmit.
* Otherwise pass the SYN packet back in, since the
* old tcp state has been cleaned up or freed.
*/
goto done;
/* Drops ref on nconnp */
return;
}
goto done;
}
/*
* rgap is the amount of stuff received out of window. A negative
* value is the amount out of window.
*/
if (rgap < 0) {
/* Fix seg_len and make sure there is something left. */
if (seg_len <= 0) {
goto done;
}
flags |= TH_ACK_NEEDED;
seg_len = 0;
goto process_ack;
}
}
/*
* Check whether we can update tcp_ts_recent. This test is from RFC
* 7323, section 5.3.
*/
}
/* Always ack out of order packets */
flags |= TH_ACK_NEEDED;
seg_len = 0;
} else if (seg_len > 0) {
}
(void) tcp_clean_death(tcp, 0);
goto done;
}
/*
* Do not delete the TCP structure if it is in
* TIME_WAIT state. Refer to RFC 1122, 4.2.2.13.
*/
goto done;
}
if (bytes_acked <= 0) {
if (bytes_acked == 0 && seg_len == 0 &&
} else {
/* Acks something not sent */
flags |= TH_ACK_NEEDED;
}
}
if (flags & TH_ACK_NEEDED) {
/*
* Time to send an ack for some reason.
*/
}
done:
}