tcp_input.c 152.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Implementation of the Transmission Control Protocol(TCP).
 *
 * Version:	$Id: tcp_input.c,v 1.243 2002/02/01 22:01:04 davem Exp $
 *
10
 * Authors:	Ross Biro
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *		Mark Evans, <evansmp@uhura.aston.ac.uk>
 *		Corey Minyard <wf-rch!minyard@relay.EU.net>
 *		Florian La Roche, <flla@stud.uni-sb.de>
 *		Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
 *		Linus Torvalds, <torvalds@cs.helsinki.fi>
 *		Alan Cox, <gw4pts@gw4pts.ampr.org>
 *		Matthew Dillon, <dillon@apollo.west.oic.com>
 *		Arnt Gulbrandsen, <agulbra@nvg.unit.no>
 *		Jorge Cwik, <jorge@laser.satlink.net>
 */

/*
 * Changes:
 *		Pedro Roque	:	Fast Retransmit/Recovery.
 *					Two receive queues.
 *					Retransmit queue handled by TCP.
 *					Better retransmit timer handling.
 *					New congestion avoidance.
 *					Header prediction.
 *					Variable renaming.
 *
 *		Eric		:	Fast Retransmit.
 *		Randy Scott	:	MSS option defines.
 *		Eric Schenk	:	Fixes to slow start algorithm.
 *		Eric Schenk	:	Yet another double ACK bug.
 *		Eric Schenk	:	Delayed ACK bug fixes.
 *		Eric Schenk	:	Floyd style fast retrans war avoidance.
 *		David S. Miller	:	Don't allow zero congestion window.
 *		Eric Schenk	:	Fix retransmitter so that it sends
 *					next packet on ack of previous packet.
 *		Andi Kleen	:	Moved open_request checking here
 *					and process RSTs for open_requests.
 *		Andi Kleen	:	Better prune_queue, and other fixes.
S
Stephen Hemminger 已提交
45
 *		Andrey Savochkin:	Fix RTT measurements in the presence of
L
Linus Torvalds 已提交
46 47 48 49 50 51 52
 *					timestamps.
 *		Andrey Savochkin:	Check sequence numbers correctly when
 *					removing SACKs due to in sequence incoming
 *					data segments.
 *		Andi Kleen:		Make sure we never ack data there is not
 *					enough room for. Also make this condition
 *					a fatal error if it might still happen.
53
 *		Andi Kleen:		Add tcp_measure_rcv_mss to make
L
Linus Torvalds 已提交
54
 *					connections with MSS<min(MTU,ann. MSS)
55
 *					work without delayed acks.
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
 *		Andi Kleen:		Process packets with PSH set in the
 *					fast path.
 *		J Hadi Salim:		ECN support
 *	 	Andrei Gurtov,
 *		Pasi Sarolahti,
 *		Panu Kuhlberg:		Experimental audit of TCP (re)transmission
 *					engine. Lots of bugs are found.
 *		Pasi Sarolahti:		F-RTO for dealing with spurious RTOs
 */

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/sysctl.h>
#include <net/tcp.h>
#include <net/inet_common.h>
#include <linux/ipsec.h>
#include <asm/unaligned.h>
C
Chris Leech 已提交
73
#include <net/netdma.h>
L
Linus Torvalds 已提交
74

75 76 77 78 79 80 81 82 83
int sysctl_tcp_timestamps __read_mostly = 1;
int sysctl_tcp_window_scaling __read_mostly = 1;
int sysctl_tcp_sack __read_mostly = 1;
int sysctl_tcp_fack __read_mostly = 1;
int sysctl_tcp_reordering __read_mostly = TCP_FASTRETRANS_THRESH;
int sysctl_tcp_ecn __read_mostly;
int sysctl_tcp_dsack __read_mostly = 1;
int sysctl_tcp_app_win __read_mostly = 31;
int sysctl_tcp_adv_win_scale __read_mostly = 2;
L
Linus Torvalds 已提交
84

85 86 87
int sysctl_tcp_stdurg __read_mostly;
int sysctl_tcp_rfc1337 __read_mostly;
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
88
int sysctl_tcp_frto __read_mostly = 2;
89
int sysctl_tcp_frto_response __read_mostly;
90
int sysctl_tcp_nometrics_save __read_mostly;
L
Linus Torvalds 已提交
91

92 93
int sysctl_tcp_moderate_rcvbuf __read_mostly = 1;
int sysctl_tcp_abc __read_mostly;
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103

#define FLAG_DATA		0x01 /* Incoming frame contained data.		*/
#define FLAG_WIN_UPDATE		0x02 /* Incoming ACK was a window update.	*/
#define FLAG_DATA_ACKED		0x04 /* This ACK acknowledged new data.		*/
#define FLAG_RETRANS_DATA_ACKED	0x08 /* "" "" some of which was retransmitted.	*/
#define FLAG_SYN_ACKED		0x10 /* This ACK acknowledged SYN.		*/
#define FLAG_DATA_SACKED	0x20 /* New SACK.				*/
#define FLAG_ECE		0x40 /* ECE in this ACK				*/
#define FLAG_DATA_LOST		0x80 /* SACK detected data lossage.		*/
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
I
Ilpo Järvinen 已提交
104
#define FLAG_ONLY_ORIG_SACKED	0x200 /* SACKs only non-rexmit sent before RTO */
105
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
106
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
107
#define FLAG_NONHEAD_RETRANS_ACKED	0x1000 /* Non-head rexmitted data was ACKed */
108
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
L
Linus Torvalds 已提交
109 110 111 112 113

#define FLAG_ACKED		(FLAG_DATA_ACKED|FLAG_SYN_ACKED)
#define FLAG_NOT_DUP		(FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)
#define FLAG_CA_ALERT		(FLAG_DATA_SACKED|FLAG_ECE)
#define FLAG_FORWARD_PROGRESS	(FLAG_ACKED|FLAG_DATA_SACKED)
114
#define FLAG_ANY_PROGRESS	(FLAG_FORWARD_PROGRESS|FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
115

I
Ilpo Järvinen 已提交
116 117
#define IsSackFrto() (sysctl_tcp_frto == 0x2)

L
Linus Torvalds 已提交
118
#define TCP_REMNANT (TCP_FLAG_FIN|TCP_FLAG_URG|TCP_FLAG_SYN|TCP_FLAG_PSH)
119
#define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
L
Linus Torvalds 已提交
120

121
/* Adapt the MSS value used to make delayed ack decision to the
L
Linus Torvalds 已提交
122
 * real world.
123
 */
124
static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
125
{
126
	struct inet_connection_sock *icsk = inet_csk(sk);
127
	const unsigned int lss = icsk->icsk_ack.last_seg_size;
128
	unsigned int len;
L
Linus Torvalds 已提交
129

130
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
131 132 133 134

	/* skb->len may jitter because of SACKs, even if peer
	 * sends good full-sized frames.
	 */
135
	len = skb_shinfo(skb)->gso_size ? : skb->len;
136 137
	if (len >= icsk->icsk_ack.rcv_mss) {
		icsk->icsk_ack.rcv_mss = len;
L
Linus Torvalds 已提交
138 139 140 141 142 143
	} else {
		/* Otherwise, we make more careful check taking into account,
		 * that SACKs block is variable.
		 *
		 * "len" is invariant segment length, including TCP header.
		 */
144
		len += skb->data - skb_transport_header(skb);
L
Linus Torvalds 已提交
145 146 147 148 149 150 151
		if (len >= TCP_MIN_RCVMSS + sizeof(struct tcphdr) ||
		    /* If PSH is not set, packet should be
		     * full sized, provided peer TCP is not badly broken.
		     * This observation (if it is correct 8)) allows
		     * to handle super-low mtu links fairly.
		     */
		    (len >= TCP_MIN_MSS + sizeof(struct tcphdr) &&
152
		     !(tcp_flag_word(tcp_hdr(skb)) & TCP_REMNANT))) {
L
Linus Torvalds 已提交
153 154 155 156
			/* Subtract also invariant (if peer is RFC compliant),
			 * tcp header plus fixed timestamp option length.
			 * Resulting "len" is MSS free of SACK jitter.
			 */
157 158
			len -= tcp_sk(sk)->tcp_header_len;
			icsk->icsk_ack.last_seg_size = len;
L
Linus Torvalds 已提交
159
			if (len == lss) {
160
				icsk->icsk_ack.rcv_mss = len;
L
Linus Torvalds 已提交
161 162 163
				return;
			}
		}
164 165
		if (icsk->icsk_ack.pending & ICSK_ACK_PUSHED)
			icsk->icsk_ack.pending |= ICSK_ACK_PUSHED2;
166
		icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
L
Linus Torvalds 已提交
167 168 169
	}
}

170
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
171
{
172 173
	struct inet_connection_sock *icsk = inet_csk(sk);
	unsigned quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
174

175 176
	if (quickacks == 0)
		quickacks = 2;
177 178
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
179 180
}

181
void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
182
{
183 184 185 186
	struct inet_connection_sock *icsk = inet_csk(sk);
	tcp_incr_quickack(sk);
	icsk->icsk_ack.pingpong = 0;
	icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
187 188 189 190 191 192
}

/* Send ACKs quickly, if "quick" count is not exhausted
 * and the session is not interactive.
 */

193
static inline int tcp_in_quickack_mode(const struct sock *sk)
L
Linus Torvalds 已提交
194
{
195 196
	const struct inet_connection_sock *icsk = inet_csk(sk);
	return icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong;
L
Linus Torvalds 已提交
197 198
}

199 200
static inline void TCP_ECN_queue_cwr(struct tcp_sock *tp)
{
201
	if (tp->ecn_flags & TCP_ECN_OK)
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

static inline void TCP_ECN_accept_cwr(struct tcp_sock *tp, struct sk_buff *skb)
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

static inline void TCP_ECN_withdraw_cwr(struct tcp_sock *tp)
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

static inline void TCP_ECN_check_ce(struct tcp_sock *tp, struct sk_buff *skb)
{
218
	if (tp->ecn_flags & TCP_ECN_OK) {
219 220 221 222 223 224 225 226 227 228 229 230
		if (INET_ECN_is_ce(TCP_SKB_CB(skb)->flags))
			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
		/* Funny extension: if ECT is not set on a segment,
		 * it is surely retransmit. It is not in ECN RFC,
		 * but Linux follows this rule. */
		else if (INET_ECN_is_not_ect((TCP_SKB_CB(skb)->flags)))
			tcp_enter_quickack_mode((struct sock *)tp);
	}
}

static inline void TCP_ECN_rcv_synack(struct tcp_sock *tp, struct tcphdr *th)
{
231
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
232 233 234 235 236
		tp->ecn_flags &= ~TCP_ECN_OK;
}

static inline void TCP_ECN_rcv_syn(struct tcp_sock *tp, struct tcphdr *th)
{
237
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
238 239 240 241 242
		tp->ecn_flags &= ~TCP_ECN_OK;
}

static inline int TCP_ECN_rcv_ecn_echo(struct tcp_sock *tp, struct tcphdr *th)
{
243
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
244 245 246 247
		return 1;
	return 0;
}

L
Linus Torvalds 已提交
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

static void tcp_fixup_sndbuf(struct sock *sk)
{
	int sndmem = tcp_sk(sk)->rx_opt.mss_clamp + MAX_TCP_HEADER + 16 +
		     sizeof(struct sk_buff);

	if (sk->sk_sndbuf < 3 * sndmem)
		sk->sk_sndbuf = min(3 * sndmem, sysctl_tcp_wmem[2]);
}

/* 2. Tuning advertised window (window_clamp, rcv_ssthresh)
 *
 * All tcp_full_space() is split to two parts: "network" buffer, allocated
 * forward and advertised in receiver window (tp->rcv_wnd) and
 * "application buffer", required to isolate scheduling/application
 * latencies from network.
 * window_clamp is maximal advertised window. It can be less than
 * tcp_full_space(), in this case tcp_full_space() - window_clamp
 * is reserved for "application" buffer. The less window_clamp is
 * the smoother our behaviour from viewpoint of network, but the lower
 * throughput and the higher sensitivity of the connection to losses. 8)
 *
 * rcv_ssthresh is more strict window_clamp used at "slow start"
 * phase to predict further behaviour of this connection.
 * It is used for two goals:
 * - to enforce header prediction at sender, even when application
 *   requires some significant "application buffer". It is check #1.
 * - to prevent pruning of receive queue because of misprediction
 *   of receiver window. Check #2.
 *
 * The scheme does not work when sender sends good segments opening
S
Stephen Hemminger 已提交
283
 * window and then starts to feed us spaghetti. But it should work
L
Linus Torvalds 已提交
284 285 286 287
 * in common situations. Otherwise, we have to rely on queue collapsing.
 */

/* Slow part of check#2. */
288
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
289
{
290
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
291
	/* Optimize this! */
292 293
	int truesize = tcp_win_from_space(skb->truesize) >> 1;
	int window = tcp_win_from_space(sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
294 295 296

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
297
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
298 299 300 301 302 303 304

		truesize >>= 1;
		window >>= 1;
	}
	return 0;
}

305
static void tcp_grow_window(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
306
{
307 308
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
309 310 311 312 313 314 315 316 317 318
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
	    !tcp_memory_pressure) {
		int incr;

		/* Check #2. Increase window, if skb with such overhead
		 * will fit to rcvbuf in future.
		 */
		if (tcp_win_from_space(skb->truesize) <= skb->len)
319
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
320
		else
321
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
322 323

		if (incr) {
324 325
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
326
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
327 328 329 330 331 332 333 334 335 336 337 338
		}
	}
}

/* 3. Tuning rcvbuf, when connection enters established state. */

static void tcp_fixup_rcvbuf(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int rcvmem = tp->advmss + MAX_TCP_HEADER + 16 + sizeof(struct sk_buff);

	/* Try to select rcvbuf so that 4 mss-sized segments
S
Stephen Hemminger 已提交
339
	 * will fit to window and corresponding skbs will fit to our rcvbuf.
L
Linus Torvalds 已提交
340 341 342 343 344 345 346 347
	 * (was 3; 4 is minimum to allow fast retransmit to work.)
	 */
	while (tcp_win_from_space(rcvmem) < tp->advmss)
		rcvmem += 128;
	if (sk->sk_rcvbuf < 4 * rcvmem)
		sk->sk_rcvbuf = min(4 * rcvmem, sysctl_tcp_rmem[2]);
}

S
Stephen Hemminger 已提交
348
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
 *    established state.
 */
static void tcp_init_buffer_space(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int maxwin;

	if (!(sk->sk_userlocks & SOCK_RCVBUF_LOCK))
		tcp_fixup_rcvbuf(sk);
	if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK))
		tcp_fixup_sndbuf(sk);

	tp->rcvq_space.space = tp->rcv_wnd;

	maxwin = tcp_full_space(sk);

	if (tp->window_clamp >= maxwin) {
		tp->window_clamp = maxwin;

		if (sysctl_tcp_app_win && maxwin > 4 * tp->advmss)
			tp->window_clamp = max(maxwin -
					       (maxwin >> sysctl_tcp_app_win),
					       4 * tp->advmss);
	}

	/* Force reservation of one segment. */
	if (sysctl_tcp_app_win &&
	    tp->window_clamp > 2 * tp->advmss &&
	    tp->window_clamp + tp->advmss > maxwin)
		tp->window_clamp = max(2 * tp->advmss, maxwin - tp->advmss);

	tp->rcv_ssthresh = min(tp->rcv_ssthresh, tp->window_clamp);
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

/* 5. Recalculate window clamp after socket hit its memory bounds. */
385
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
386
{
387
	struct tcp_sock *tp = tcp_sk(sk);
388
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
389

390
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
391

392 393 394 395 396 397
	if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
	    !tcp_memory_pressure &&
	    atomic_read(&tcp_memory_allocated) < sysctl_tcp_mem[0]) {
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
				    sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
398
	}
399
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
400
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
401 402
}

S
Stephen Hemminger 已提交
403 404 405 406 407 408 409 410 411 412 413 414
/* Initialize RCV_MSS value.
 * RCV_MSS is an our guess about MSS used by the peer.
 * We haven't any direct information about the MSS.
 * It's better to underestimate the RCV_MSS rather than overestimate.
 * Overestimations make us ACKing less frequently than needed.
 * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
 */
void tcp_initialize_rcv_mss(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

415
	hint = min(hint, tp->rcv_wnd / 2);
S
Stephen Hemminger 已提交
416 417 418 419 420 421
	hint = min(hint, TCP_MIN_RCVMSS);
	hint = max(hint, TCP_MIN_MSS);

	inet_csk(sk)->icsk_ack.rcv_mss = hint;
}

L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
/* Receiver "autotuning" code.
 *
 * The algorithm for RTT estimation w/o timestamps is based on
 * Dynamic Right-Sizing (DRS) by Wu Feng and Mike Fisk of LANL.
 * <http://www.lanl.gov/radiant/website/pubs/drs/lacsi2001.ps>
 *
 * More detail on this code can be found at
 * <http://www.psc.edu/~jheffner/senior_thesis.ps>,
 * though this reference is out of date.  A new paper
 * is pending.
 */
static void tcp_rcv_rtt_update(struct tcp_sock *tp, u32 sample, int win_dep)
{
	u32 new_sample = tp->rcv_rtt_est.rtt;
	long m = sample;

	if (m == 0)
		m = 1;

	if (new_sample != 0) {
		/* If we sample in larger samples in the non-timestamp
		 * case, we could grossly overestimate the RTT especially
		 * with chatty applications or bulk transfer apps which
		 * are stalled on filesystem I/O.
		 *
		 * Also, since we are only going for a minimum in the
S
Stephen Hemminger 已提交
448
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
449
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
450 451 452 453 454 455 456 457
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
		} else if (m < new_sample)
			new_sample = m << 3;
	} else {
S
Stephen Hemminger 已提交
458
		/* No previous measure. */
L
Linus Torvalds 已提交
459 460 461 462 463 464 465 466 467 468 469 470 471
		new_sample = m << 3;
	}

	if (tp->rcv_rtt_est.rtt != new_sample)
		tp->rcv_rtt_est.rtt = new_sample;
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
	if (tp->rcv_rtt_est.time == 0)
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
472
	tcp_rcv_rtt_update(tp, jiffies - tp->rcv_rtt_est.time, 1);
L
Linus Torvalds 已提交
473 474 475 476 477 478

new_measure:
	tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
	tp->rcv_rtt_est.time = tcp_time_stamp;
}

479 480
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
481
{
482
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
483 484
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
485
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
L
Linus Torvalds 已提交
486 487 488 489 490 491 492 493 494 495 496 497
		tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rx_opt.rcv_tsecr, 0);
}

/*
 * This function should be called every time data is copied to user space.
 * It calculates the appropriate TCP receive buffer space.
 */
void tcp_rcv_space_adjust(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int time;
	int space;
498

L
Linus Torvalds 已提交
499 500
	if (tp->rcvq_space.time == 0)
		goto new_measure;
501

L
Linus Torvalds 已提交
502
	time = tcp_time_stamp - tp->rcvq_space.time;
503
	if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
L
Linus Torvalds 已提交
504
		return;
505

L
Linus Torvalds 已提交
506 507 508 509 510 511 512 513 514
	space = 2 * (tp->copied_seq - tp->rcvq_space.seq);

	space = max(tp->rcvq_space.space, space);

	if (tp->rcvq_space.space != space) {
		int rcvmem;

		tp->rcvq_space.space = space;

515 516
		if (sysctl_tcp_moderate_rcvbuf &&
		    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
L
Linus Torvalds 已提交
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
			int new_clamp = space;

			/* Receive space grows, normalize in order to
			 * take into account packet headers and sk_buff
			 * structure overhead.
			 */
			space /= tp->advmss;
			if (!space)
				space = 1;
			rcvmem = (tp->advmss + MAX_TCP_HEADER +
				  16 + sizeof(struct sk_buff));
			while (tcp_win_from_space(rcvmem) < tp->advmss)
				rcvmem += 128;
			space *= rcvmem;
			space = min(space, sysctl_tcp_rmem[2]);
			if (space > sk->sk_rcvbuf) {
				sk->sk_rcvbuf = space;

				/* Make the window clamp follow along.  */
				tp->window_clamp = new_clamp;
			}
		}
	}
540

L
Linus Torvalds 已提交
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
	tp->rcvq_space.time = tcp_time_stamp;
}

/* There is something which you must keep in mind when you analyze the
 * behavior of the tp->ato delayed ack timeout interval.  When a
 * connection starts up, we want to ack as quickly as possible.  The
 * problem is that "good" TCP's do slow start at the beginning of data
 * transmission.  The means that until we send the first few ACK's the
 * sender will sit on his end and only queue most of his data, because
 * he can only send snd_cwnd unacked packets at any given time.  For
 * each ACK we send, he increments snd_cwnd and transmits more of his
 * queue.  -DaveM
 */
556
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
557
{
558
	struct tcp_sock *tp = tcp_sk(sk);
559
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
560 561
	u32 now;

562
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
563

564
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
565 566

	tcp_rcv_rtt_measure(tp);
567

L
Linus Torvalds 已提交
568 569
	now = tcp_time_stamp;

570
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
571 572 573
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
574 575
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
576
	} else {
577
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
578

579
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
580
			/* The fastest case is the first. */
581 582 583 584 585 586
			icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;
		} else if (m < icsk->icsk_ack.ato) {
			icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;
			if (icsk->icsk_ack.ato > icsk->icsk_rto)
				icsk->icsk_ack.ato = icsk->icsk_rto;
		} else if (m > icsk->icsk_rto) {
S
Stephen Hemminger 已提交
587
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
588 589
			 * restart window, so that we send ACKs quickly.
			 */
590
			tcp_incr_quickack(sk);
591
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
592 593
		}
	}
594
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
595 596 597 598

	TCP_ECN_check_ce(tp, skb);

	if (skb->len >= 128)
599
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
600 601
}

602 603 604 605 606
static u32 tcp_rto_min(struct sock *sk)
{
	struct dst_entry *dst = __sk_dst_get(sk);
	u32 rto_min = TCP_RTO_MIN;

607
	if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
608
		rto_min = dst->metrics[RTAX_RTO_MIN - 1];
609 610 611
	return rto_min;
}

L
Linus Torvalds 已提交
612 613 614 615 616 617 618 619 620
/* Called to compute a smoothed rtt estimate. The data fed to this
 * routine either comes from timestamps, or from segments that were
 * known _not_ to have been retransmitted [see Karn/Partridge
 * Proceedings SIGCOMM 87]. The algorithm is from the SIGCOMM 88
 * piece by Van Jacobson.
 * NOTE: the next three routines used to be one big routine.
 * To save cycles in the RFC 1323 implementation it was better to break
 * it up into three procedures. -- erics
 */
621
static void tcp_rtt_estimator(struct sock *sk, const __u32 mrtt)
L
Linus Torvalds 已提交
622
{
623
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
624 625 626 627 628
	long m = mrtt; /* RTT */

	/*	The following amusing code comes from Jacobson's
	 *	article in SIGCOMM '88.  Note that rtt and mdev
	 *	are scaled versions of rtt and mean deviation.
629
	 *	This is designed to be as fast as possible
L
Linus Torvalds 已提交
630 631 632 633 634 635 636
	 *	m stands for "measurement".
	 *
	 *	On a 1990 paper the rto value is changed to:
	 *	RTO = rtt + 4 * mdev
	 *
	 * Funny. This algorithm seems to be very broken.
	 * These formulae increase RTO, when it should be decreased, increase
S
Stephen Hemminger 已提交
637
	 * too slowly, when it should be increased quickly, decrease too quickly
L
Linus Torvalds 已提交
638 639 640 641
	 * etc. I guess in BSD RTO takes ONE value, so that it is absolutely
	 * does not matter how to _calculate_ it. Seems, it was trap
	 * that VJ failed to avoid. 8)
	 */
S
Stephen Hemminger 已提交
642
	if (m == 0)
L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
		m = 1;
	if (tp->srtt != 0) {
		m -= (tp->srtt >> 3);	/* m is now error in rtt est */
		tp->srtt += m;		/* rtt = 7/8 rtt + 1/8 new */
		if (m < 0) {
			m = -m;		/* m is now abs(error) */
			m -= (tp->mdev >> 2);   /* similar update on mdev */
			/* This is similar to one of Eifel findings.
			 * Eifel blocks mdev updates when rtt decreases.
			 * This solution is a bit different: we use finer gain
			 * for mdev in this case (alpha*beta).
			 * Like Eifel it also prevents growth of rto,
			 * but also it limits too fast rto decreases,
			 * happening in pure Eifel.
			 */
			if (m > 0)
				m >>= 3;
		} else {
			m -= (tp->mdev >> 2);   /* similar update on mdev */
		}
		tp->mdev += m;	    	/* mdev = 3/4 mdev + 1/4 new */
		if (tp->mdev > tp->mdev_max) {
			tp->mdev_max = tp->mdev;
			if (tp->mdev_max > tp->rttvar)
				tp->rttvar = tp->mdev_max;
		}
		if (after(tp->snd_una, tp->rtt_seq)) {
			if (tp->mdev_max < tp->rttvar)
671
				tp->rttvar -= (tp->rttvar - tp->mdev_max) >> 2;
L
Linus Torvalds 已提交
672
			tp->rtt_seq = tp->snd_nxt;
673
			tp->mdev_max = tcp_rto_min(sk);
L
Linus Torvalds 已提交
674 675 676
		}
	} else {
		/* no previous measure. */
677 678
		tp->srtt = m << 3;	/* take the measured time to be rtt */
		tp->mdev = m << 1;	/* make sure rto = 3*rtt */
679
		tp->mdev_max = tp->rttvar = max(tp->mdev, tcp_rto_min(sk));
L
Linus Torvalds 已提交
680 681 682 683 684 685 686
		tp->rtt_seq = tp->snd_nxt;
	}
}

/* Calculate rto without backoff.  This is the second half of Van Jacobson's
 * routine referred to above.
 */
687
static inline void tcp_set_rto(struct sock *sk)
L
Linus Torvalds 已提交
688
{
689
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
690 691 692 693 694 695 696 697
	/* Old crap is replaced with new one. 8)
	 *
	 * More seriously:
	 * 1. If rtt variance happened to be less 50msec, it is hallucination.
	 *    It cannot be less due to utterly erratic ACK generation made
	 *    at least by solaris and freebsd. "Erratic ACKs" has _nothing_
	 *    to do with delayed acks, because at cwnd>2 true delack timeout
	 *    is invisible. Actually, Linux-2.4 also generates erratic
S
Stephen Hemminger 已提交
698
	 *    ACKs in some circumstances.
L
Linus Torvalds 已提交
699
	 */
700
	inet_csk(sk)->icsk_rto = (tp->srtt >> 3) + tp->rttvar;
L
Linus Torvalds 已提交
701 702 703 704

	/* 2. Fixups made earlier cannot be right.
	 *    If we do not estimate RTO correctly without them,
	 *    all the algo is pure shit and should be replaced
S
Stephen Hemminger 已提交
705
	 *    with correct one. It is exactly, which we pretend to do.
L
Linus Torvalds 已提交
706 707 708 709 710 711
	 */
}

/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
 * guarantees that rto is higher.
 */
712
static inline void tcp_bound_rto(struct sock *sk)
L
Linus Torvalds 已提交
713
{
714 715
	if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
		inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
L
Linus Torvalds 已提交
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
}

/* Save metrics learned by this TCP session.
   This function is called only, when TCP finishes successfully
   i.e. when it enters TIME-WAIT or goes from LAST-ACK to CLOSE.
 */
void tcp_update_metrics(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct dst_entry *dst = __sk_dst_get(sk);

	if (sysctl_tcp_nometrics_save)
		return;

	dst_confirm(dst);

732
	if (dst && (dst->flags & DST_HOST)) {
733
		const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
734 735
		int m;

736
		if (icsk->icsk_backoff || !tp->srtt) {
L
Linus Torvalds 已提交
737 738 739 740 741
			/* This session failed to estimate rtt. Why?
			 * Probably, no packets returned in time.
			 * Reset our results.
			 */
			if (!(dst_metric_locked(dst, RTAX_RTT)))
742
				dst->metrics[RTAX_RTT - 1] = 0;
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750 751 752 753
			return;
		}

		m = dst_metric(dst, RTAX_RTT) - tp->srtt;

		/* If newly calculated rtt larger than stored one,
		 * store new one. Otherwise, use EWMA. Remember,
		 * rtt overestimation is always better than underestimation.
		 */
		if (!(dst_metric_locked(dst, RTAX_RTT))) {
			if (m <= 0)
754
				dst->metrics[RTAX_RTT - 1] = tp->srtt;
L
Linus Torvalds 已提交
755
			else
756
				dst->metrics[RTAX_RTT - 1] -= (m >> 3);
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765 766 767 768
		}

		if (!(dst_metric_locked(dst, RTAX_RTTVAR))) {
			if (m < 0)
				m = -m;

			/* Scale deviation to rttvar fixed point */
			m >>= 1;
			if (m < tp->mdev)
				m = tp->mdev;

			if (m >= dst_metric(dst, RTAX_RTTVAR))
769
				dst->metrics[RTAX_RTTVAR - 1] = m;
L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778 779 780 781 782
			else
				dst->metrics[RTAX_RTTVAR-1] -=
					(dst->metrics[RTAX_RTTVAR-1] - m)>>2;
		}

		if (tp->snd_ssthresh >= 0xFFFF) {
			/* Slow start still did not finish. */
			if (dst_metric(dst, RTAX_SSTHRESH) &&
			    !dst_metric_locked(dst, RTAX_SSTHRESH) &&
			    (tp->snd_cwnd >> 1) > dst_metric(dst, RTAX_SSTHRESH))
				dst->metrics[RTAX_SSTHRESH-1] = tp->snd_cwnd >> 1;
			if (!dst_metric_locked(dst, RTAX_CWND) &&
			    tp->snd_cwnd > dst_metric(dst, RTAX_CWND))
783
				dst->metrics[RTAX_CWND - 1] = tp->snd_cwnd;
L
Linus Torvalds 已提交
784
		} else if (tp->snd_cwnd > tp->snd_ssthresh &&
785
			   icsk->icsk_ca_state == TCP_CA_Open) {
L
Linus Torvalds 已提交
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
			/* Cong. avoidance phase, cwnd is reliable. */
			if (!dst_metric_locked(dst, RTAX_SSTHRESH))
				dst->metrics[RTAX_SSTHRESH-1] =
					max(tp->snd_cwnd >> 1, tp->snd_ssthresh);
			if (!dst_metric_locked(dst, RTAX_CWND))
				dst->metrics[RTAX_CWND-1] = (dst->metrics[RTAX_CWND-1] + tp->snd_cwnd) >> 1;
		} else {
			/* Else slow start did not finish, cwnd is non-sense,
			   ssthresh may be also invalid.
			 */
			if (!dst_metric_locked(dst, RTAX_CWND))
				dst->metrics[RTAX_CWND-1] = (dst->metrics[RTAX_CWND-1] + tp->snd_ssthresh) >> 1;
			if (dst->metrics[RTAX_SSTHRESH-1] &&
			    !dst_metric_locked(dst, RTAX_SSTHRESH) &&
			    tp->snd_ssthresh > dst->metrics[RTAX_SSTHRESH-1])
				dst->metrics[RTAX_SSTHRESH-1] = tp->snd_ssthresh;
		}

		if (!dst_metric_locked(dst, RTAX_REORDERING)) {
			if (dst->metrics[RTAX_REORDERING-1] < tp->reordering &&
			    tp->reordering != sysctl_tcp_reordering)
				dst->metrics[RTAX_REORDERING-1] = tp->reordering;
		}
	}
}

812 813 814 815 816 817 818 819 820
/* Numbers are taken from RFC3390.
 *
 * John Heffner states:
 *
 *	The RFC specifies a window of no more than 4380 bytes
 *	unless 2*MSS > 4380.  Reading the pseudocode in the RFC
 *	is a bit misleading because they use a clamp at 4380 bytes
 *	rather than use a multiplier in the relevant range.
 */
L
Linus Torvalds 已提交
821 822 823 824 825
__u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst)
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

	if (!cwnd) {
826
		if (tp->mss_cache > 1460)
L
Linus Torvalds 已提交
827 828
			cwnd = 2;
		else
829
			cwnd = (tp->mss_cache > 1095) ? 3 : 4;
L
Linus Torvalds 已提交
830 831 832 833
	}
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

S
Stephen Hemminger 已提交
834
/* Set slow start threshold and cwnd not falling to slow start */
835
void tcp_enter_cwr(struct sock *sk, const int set_ssthresh)
S
Stephen Hemminger 已提交
836 837
{
	struct tcp_sock *tp = tcp_sk(sk);
838
	const struct inet_connection_sock *icsk = inet_csk(sk);
S
Stephen Hemminger 已提交
839 840 841

	tp->prior_ssthresh = 0;
	tp->bytes_acked = 0;
842
	if (icsk->icsk_ca_state < TCP_CA_CWR) {
S
Stephen Hemminger 已提交
843
		tp->undo_marker = 0;
844 845
		if (set_ssthresh)
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
S
Stephen Hemminger 已提交
846 847 848 849 850 851 852 853 854 855 856
		tp->snd_cwnd = min(tp->snd_cwnd,
				   tcp_packets_in_flight(tp) + 1U);
		tp->snd_cwnd_cnt = 0;
		tp->high_seq = tp->snd_nxt;
		tp->snd_cwnd_stamp = tcp_time_stamp;
		TCP_ECN_queue_cwr(tp);

		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}

857 858 859 860 861 862
/*
 * Packet counting of FACK is based on in-order assumptions, therefore TCP
 * disables it when reordering is detected
 */
static void tcp_disable_fack(struct tcp_sock *tp)
{
863 864 865
	/* RFC3517 uses different metric in lost marker => reset on change */
	if (tcp_is_fack(tp))
		tp->lost_skb_hint = NULL;
866 867 868
	tp->rx_opt.sack_ok &= ~2;
}

869
/* Take a notice that peer is sending D-SACKs */
870 871 872 873 874
static void tcp_dsack_seen(struct tcp_sock *tp)
{
	tp->rx_opt.sack_ok |= 4;
}

L
Linus Torvalds 已提交
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
/* Initialize metrics on socket. */

static void tcp_init_metrics(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct dst_entry *dst = __sk_dst_get(sk);

	if (dst == NULL)
		goto reset;

	dst_confirm(dst);

	if (dst_metric_locked(dst, RTAX_CWND))
		tp->snd_cwnd_clamp = dst_metric(dst, RTAX_CWND);
	if (dst_metric(dst, RTAX_SSTHRESH)) {
		tp->snd_ssthresh = dst_metric(dst, RTAX_SSTHRESH);
		if (tp->snd_ssthresh > tp->snd_cwnd_clamp)
			tp->snd_ssthresh = tp->snd_cwnd_clamp;
	}
	if (dst_metric(dst, RTAX_REORDERING) &&
	    tp->reordering != dst_metric(dst, RTAX_REORDERING)) {
896
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
		tp->reordering = dst_metric(dst, RTAX_REORDERING);
	}

	if (dst_metric(dst, RTAX_RTT) == 0)
		goto reset;

	if (!tp->srtt && dst_metric(dst, RTAX_RTT) < (TCP_TIMEOUT_INIT << 3))
		goto reset;

	/* Initial rtt is determined from SYN,SYN-ACK.
	 * The segment is small and rtt may appear much
	 * less than real one. Use per-dst memory
	 * to make it more realistic.
	 *
	 * A bit of theory. RTT is time passed after "normal" sized packet
S
Stephen Hemminger 已提交
912
	 * is sent until it is ACKed. In normal circumstances sending small
L
Linus Torvalds 已提交
913 914 915 916 917 918 919 920 921 922 923 924 925
	 * packets force peer to delay ACKs and calculation is correct too.
	 * The algorithm is adaptive and, provided we follow specs, it
	 * NEVER underestimate RTT. BUT! If peer tries to make some clever
	 * tricks sort of "quick acks" for time long enough to decrease RTT
	 * to low value, and then abruptly stops to do it and starts to delay
	 * ACKs, wait for troubles.
	 */
	if (dst_metric(dst, RTAX_RTT) > tp->srtt) {
		tp->srtt = dst_metric(dst, RTAX_RTT);
		tp->rtt_seq = tp->snd_nxt;
	}
	if (dst_metric(dst, RTAX_RTTVAR) > tp->mdev) {
		tp->mdev = dst_metric(dst, RTAX_RTTVAR);
926
		tp->mdev_max = tp->rttvar = max(tp->mdev, tcp_rto_min(sk));
L
Linus Torvalds 已提交
927
	}
928 929 930
	tcp_set_rto(sk);
	tcp_bound_rto(sk);
	if (inet_csk(sk)->icsk_rto < TCP_TIMEOUT_INIT && !tp->rx_opt.saw_tstamp)
L
Linus Torvalds 已提交
931 932 933 934 935 936 937 938 939 940 941 942 943
		goto reset;
	tp->snd_cwnd = tcp_init_cwnd(tp, dst);
	tp->snd_cwnd_stamp = tcp_time_stamp;
	return;

reset:
	/* Play conservative. If timestamps are not
	 * supported, TCP will fail to recalculate correct
	 * rtt, if initial rto is too small. FORGET ALL AND RESET!
	 */
	if (!tp->rx_opt.saw_tstamp && tp->srtt) {
		tp->srtt = 0;
		tp->mdev = tp->mdev_max = tp->rttvar = TCP_TIMEOUT_INIT;
944
		inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT;
L
Linus Torvalds 已提交
945 946 947
	}
}

948 949
static void tcp_update_reordering(struct sock *sk, const int metric,
				  const int ts)
L
Linus Torvalds 已提交
950
{
951
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
952 953 954 955 956 957
	if (metric > tp->reordering) {
		tp->reordering = min(TCP_MAX_REORDERING, metric);

		/* This exciting event is worth to be remembered. 8) */
		if (ts)
			NET_INC_STATS_BH(LINUX_MIB_TCPTSREORDER);
958
		else if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
959
			NET_INC_STATS_BH(LINUX_MIB_TCPRENOREORDER);
960
		else if (tcp_is_fack(tp))
L
Linus Torvalds 已提交
961 962 963 964 965
			NET_INC_STATS_BH(LINUX_MIB_TCPFACKREORDER);
		else
			NET_INC_STATS_BH(LINUX_MIB_TCPSACKREORDER);
#if FASTRETRANS_DEBUG > 1
		printk(KERN_DEBUG "Disorder%d %d %u f%u s%u rr%d\n",
966
		       tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
L
Linus Torvalds 已提交
967 968 969 970 971
		       tp->reordering,
		       tp->fackets_out,
		       tp->sacked_out,
		       tp->undo_marker ? tp->undo_retrans : 0);
#endif
972
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
	}
}

/* This procedure tags the retransmission queue when SACKs arrive.
 *
 * We have three tag bits: SACKED(S), RETRANS(R) and LOST(L).
 * Packets in queue with these bits set are counted in variables
 * sacked_out, retrans_out and lost_out, correspondingly.
 *
 * Valid combinations are:
 * Tag  InFlight	Description
 * 0	1		- orig segment is in flight.
 * S	0		- nothing flies, orig reached receiver.
 * L	0		- nothing flies, orig lost by net.
 * R	2		- both orig and retransmit are in flight.
 * L|R	1		- orig is lost, retransmit is in flight.
 * S|R  1		- orig reached receiver, retrans is still in flight.
 * (L|S|R is logically valid, it could occur when L|R is sacked,
 *  but it is equivalent to plain S and code short-curcuits it to S.
 *  L|S is logically invalid, it would mean -1 packet in flight 8))
 *
 * These 6 states form finite state machine, controlled by the following events:
 * 1. New ACK (+SACK) arrives. (tcp_sacktag_write_queue())
 * 2. Retransmission. (tcp_retransmit_skb(), tcp_xmit_retransmit_queue())
 * 3. Loss detection event of one of three flavors:
 *	A. Scoreboard estimator decided the packet is lost.
 *	   A'. Reno "three dupacks" marks head of queue lost.
 *	   A''. Its FACK modfication, head until snd.fack is lost.
 *	B. SACK arrives sacking data transmitted after never retransmitted
 *	   hole was sent out.
 *	C. SACK arrives sacking SND.NXT at the moment, when the
 *	   segment was retransmitted.
 * 4. D-SACK added new rule: D-SACK changes any tag to S.
 *
 * It is pleasant to note, that state diagram turns out to be commutative,
 * so that we are allowed not to be bothered by order of our actions,
 * when multiple events arrive simultaneously. (see the function below).
 *
 * Reordering detection.
 * --------------------
 * Reordering metric is maximal distance, which a packet can be displaced
 * in packet stream. With SACKs we can estimate it:
 *
 * 1. SACK fills old hole and the corresponding segment was not
 *    ever retransmitted -> reordering. Alas, we cannot use it
 *    when segment was retransmitted.
 * 2. The last flaw is solved with D-SACK. D-SACK arrives
 *    for retransmitted and already SACKed segment -> reordering..
 * Both of these heuristics are not used in Loss state, when we cannot
 * account for retransmits accurately.
I
Ilpo Järvinen 已提交
1023 1024 1025 1026 1027 1028 1029
 *
 * SACK block validation.
 * ----------------------
 *
 * SACK block range validation checks that the received SACK block fits to
 * the expected sequence limits, i.e., it is between SND.UNA and SND.NXT.
 * Note that SND.UNA is not included to the range though being valid because
1030 1031 1032 1033 1034 1035 1036 1037 1038
 * it means that the receiver is rather inconsistent with itself reporting
 * SACK reneging when it should advance SND.UNA. Such SACK block this is
 * perfectly valid, however, in light of RFC2018 which explicitly states
 * that "SACK block MUST reflect the newest segment.  Even if the newest
 * segment is going to be discarded ...", not that it looks very clever
 * in case of head skb. Due to potentional receiver driven attacks, we
 * choose to avoid immediate execution of a walk in write queue due to
 * reneging and defer head skb's loss recovery to standard loss recovery
 * procedure that will eventually trigger (nothing forbids us doing this).
I
Ilpo Järvinen 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
 *
 * Implements also blockage to start_seq wrap-around. Problem lies in the
 * fact that though start_seq (s) is before end_seq (i.e., not reversed),
 * there's no guarantee that it will be before snd_nxt (n). The problem
 * happens when start_seq resides between end_seq wrap (e_w) and snd_nxt
 * wrap (s_w):
 *
 *         <- outs wnd ->                          <- wrapzone ->
 *         u     e      n                         u_w   e_w  s n_w
 *         |     |      |                          |     |   |  |
 * |<------------+------+----- TCP seqno space --------------+---------->|
 * ...-- <2^31 ->|                                           |<--------...
 * ...---- >2^31 ------>|                                    |<--------...
 *
 * Current code wouldn't be vulnerable but it's better still to discard such
 * crazy SACK blocks. Doing this check for start_seq alone closes somewhat
 * similar case (end_seq after snd_nxt wrap) as earlier reversed check in
 * snd_nxt wrap -> snd_una region will then become "well defined", i.e.,
 * equal to the ideal case (infinite seqno space without wrap caused issues).
 *
 * With D-SACK the lower bound is extended to cover sequence space below
 * SND.UNA down to undo_marker, which is the last point of interest. Yet
1061
 * again, D-SACK block must not to go across snd_una (for the same reason as
I
Ilpo Järvinen 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070
 * for the normal SACK blocks, explained above). But there all simplicity
 * ends, TCP might receive valid D-SACKs below that. As long as they reside
 * fully below undo_marker they do not affect behavior in anyway and can
 * therefore be safely ignored. In rare cases (which are more or less
 * theoretical ones), the D-SACK will nicely cross that boundary due to skb
 * fragmentation and packet reordering past skb's retransmission. To consider
 * them correctly, the acceptable range must be extended even more though
 * the exact amount is rather hard to quantify. However, tp->max_window can
 * be used as an exaggerated estimate.
L
Linus Torvalds 已提交
1071
 */
I
Ilpo Järvinen 已提交
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
static int tcp_is_sackblock_valid(struct tcp_sock *tp, int is_dsack,
				  u32 start_seq, u32 end_seq)
{
	/* Too far in future, or reversed (interpretation is ambiguous) */
	if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
		return 0;

	/* Nasty start_seq wrap-around check (see comments above) */
	if (!before(start_seq, tp->snd_nxt))
		return 0;

1083
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
		return 1;

	if (!is_dsack || !tp->undo_marker)
		return 0;

	/* ...Then it's D-SACK, and must reside below snd_una completely */
	if (!after(end_seq, tp->snd_una))
		return 0;

	if (!before(start_seq, tp->undo_marker))
		return 1;

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
		return 0;

	/* Undo_marker boundary crossing (overestimates a lot). Known already:
	 *   start_seq < undo_marker and end_seq >= undo_marker.
	 */
	return !before(start_seq, end_seq - tp->max_window);
}

1109 1110 1111
/* Check for lost retransmit. This superb idea is borrowed from "ratehalving".
 * Event "C". Later note: FACK people cheated me again 8), we have to account
 * for reordering! Ugly, but should help.
1112 1113 1114
 *
 * Search retransmitted skbs from write_queue that were sent when snd_nxt was
 * less than what is now known to be received by the other end (derived from
1115 1116
 * highest SACK block). Also calculate the lowest snd_nxt among the remaining
 * retransmitted skbs to avoid some costly processing per ACKs.
1117
 */
1118
static void tcp_mark_lost_retrans(struct sock *sk)
1119
{
1120
	const struct inet_connection_sock *icsk = inet_csk(sk);
1121 1122
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;
1123
	int cnt = 0;
1124
	u32 new_low_seq = tp->snd_nxt;
1125
	u32 received_upto = tcp_highest_sack_seq(tp);
1126 1127 1128 1129

	if (!tcp_is_fack(tp) || !tp->retrans_out ||
	    !after(received_upto, tp->lost_retrans_low) ||
	    icsk->icsk_ca_state != TCP_CA_Recovery)
1130
		return;
1131 1132 1133 1134 1135 1136

	tcp_for_write_queue(skb, sk) {
		u32 ack_seq = TCP_SKB_CB(skb)->ack_seq;

		if (skb == tcp_send_head(sk))
			break;
1137
		if (cnt == tp->retrans_out)
1138 1139 1140 1141
			break;
		if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
			continue;

1142 1143 1144 1145
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS))
			continue;

		if (after(received_upto, ack_seq) &&
1146
		    (tcp_is_fack(tp) ||
1147
		     !before(received_upto,
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
			     ack_seq + tp->reordering * tp->mss_cache))) {
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
			tp->retrans_out -= tcp_skb_pcount(skb);

			/* clear lost hint */
			tp->retransmit_skb_hint = NULL;

			if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_ACKED))) {
				tp->lost_out += tcp_skb_pcount(skb);
				TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			}
1159
			NET_INC_STATS_BH(LINUX_MIB_TCPLOSTRETRANSMIT);
1160
		} else {
1161
			if (before(ack_seq, new_low_seq))
1162
				new_low_seq = ack_seq;
1163
			cnt += tcp_skb_pcount(skb);
1164 1165
		}
	}
1166 1167 1168

	if (tp->retrans_out)
		tp->lost_retrans_low = new_low_seq;
1169
}
I
Ilpo Järvinen 已提交
1170

1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
static int tcp_check_dsack(struct tcp_sock *tp, struct sk_buff *ack_skb,
			   struct tcp_sack_block_wire *sp, int num_sacks,
			   u32 prior_snd_una)
{
	u32 start_seq_0 = ntohl(get_unaligned(&sp[0].start_seq));
	u32 end_seq_0 = ntohl(get_unaligned(&sp[0].end_seq));
	int dup_sack = 0;

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
		dup_sack = 1;
1181
		tcp_dsack_seen(tp);
1182 1183 1184 1185 1186 1187 1188 1189
		NET_INC_STATS_BH(LINUX_MIB_TCPDSACKRECV);
	} else if (num_sacks > 1) {
		u32 end_seq_1 = ntohl(get_unaligned(&sp[1].end_seq));
		u32 start_seq_1 = ntohl(get_unaligned(&sp[1].start_seq));

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
			dup_sack = 1;
1190
			tcp_dsack_seen(tp);
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
			NET_INC_STATS_BH(LINUX_MIB_TCPDSACKOFORECV);
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
	if (dup_sack &&
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1204 1205 1206 1207 1208 1209
/* Check if skb is fully within the SACK block. In presence of GSO skbs,
 * the incoming SACK may not exactly match but we can find smaller MSS
 * aligned portion of it that matches. Therefore we might need to fragment
 * which may fail and creates some hassle (caller must handle error case
 * returns).
 */
1210 1211
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
				 u32 start_seq, u32 end_seq)
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
{
	int in_sack, err;
	unsigned int pkt_len;

	in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq) &&
		  !before(end_seq, TCP_SKB_CB(skb)->end_seq);

	if (tcp_skb_pcount(skb) > 1 && !in_sack &&
	    after(TCP_SKB_CB(skb)->end_seq, start_seq)) {

		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

		if (!in_sack)
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
		else
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
		err = tcp_fragment(sk, skb, pkt_len, skb_shinfo(skb)->gso_size);
		if (err < 0)
			return err;
	}

	return in_sack;
}

1236
static int tcp_sacktag_one(struct sk_buff *skb, struct sock *sk,
1237 1238
			   int *reord, int dup_sack, int fack_count)
{
1239
	struct tcp_sock *tp = tcp_sk(sk);
1240 1241 1242 1243 1244 1245 1246
	u8 sacked = TCP_SKB_CB(skb)->sacked;
	int flag = 0;

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
		if (after(TCP_SKB_CB(skb)->end_seq, tp->undo_marker))
			tp->undo_retrans--;
1247
		if (sacked & TCPCB_SACKED_ACKED)
1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
			*reord = min(fack_count, *reord);
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
	if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
		return flag;

	if (!(sacked & TCPCB_SACKED_ACKED)) {
		if (sacked & TCPCB_SACKED_RETRANS) {
			/* If the segment is not tagged as lost,
			 * we do not clear RETRANS, believing
			 * that retransmission is still in flight.
			 */
			if (sacked & TCPCB_LOST) {
				TCP_SKB_CB(skb)->sacked &=
					~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
				tp->lost_out -= tcp_skb_pcount(skb);
				tp->retrans_out -= tcp_skb_pcount(skb);

				/* clear lost hint */
				tp->retransmit_skb_hint = NULL;
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
				if (before(TCP_SKB_CB(skb)->seq,
					   tcp_highest_sack_seq(tp)))
					*reord = min(fack_count, *reord);

				/* SACK enhanced F-RTO (RFC4138; Appendix B) */
				if (!after(TCP_SKB_CB(skb)->end_seq, tp->frto_highmark))
					flag |= FLAG_ONLY_ORIG_SACKED;
			}

			if (sacked & TCPCB_LOST) {
				TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
				tp->lost_out -= tcp_skb_pcount(skb);

				/* clear lost hint */
				tp->retransmit_skb_hint = NULL;
			}
		}

		TCP_SKB_CB(skb)->sacked |= TCPCB_SACKED_ACKED;
		flag |= FLAG_DATA_SACKED;
		tp->sacked_out += tcp_skb_pcount(skb);

		fack_count += tcp_skb_pcount(skb);

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
		if (!tcp_is_fack(tp) && (tp->lost_skb_hint != NULL) &&
		    before(TCP_SKB_CB(skb)->seq,
			   TCP_SKB_CB(tp->lost_skb_hint)->seq))
			tp->lost_cnt_hint += tcp_skb_pcount(skb);

		if (fack_count > tp->fackets_out)
			tp->fackets_out = fack_count;

1308 1309
		if (!before(TCP_SKB_CB(skb)->seq, tcp_highest_sack_seq(tp)))
			tcp_advance_highest_sack(sk, skb);
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
	}

	/* D-SACK. We can detect redundant retransmission in S|R and plain R
	 * frames and clear it. undo_retrans is decreased above, L|R frames
	 * are accounted above as well.
	 */
	if (dup_sack && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)) {
		TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
		tp->retrans_out -= tcp_skb_pcount(skb);
		tp->retransmit_skb_hint = NULL;
	}

	return flag;
}

1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
					u32 start_seq, u32 end_seq,
					int dup_sack_in, int *fack_count,
					int *reord, int *flag)
{
	tcp_for_write_queue_from(skb, sk) {
		int in_sack = 0;
		int dup_sack = dup_sack_in;

		if (skb == tcp_send_head(sk))
			break;

		/* queue is in-order => we can short-circuit the walk early */
		if (!before(TCP_SKB_CB(skb)->seq, end_seq))
			break;

		if ((next_dup != NULL) &&
		    before(TCP_SKB_CB(skb)->seq, next_dup->end_seq)) {
			in_sack = tcp_match_skb_to_sack(sk, skb,
							next_dup->start_seq,
							next_dup->end_seq);
			if (in_sack > 0)
				dup_sack = 1;
		}

		if (in_sack <= 0)
1352 1353
			in_sack = tcp_match_skb_to_sack(sk, skb, start_seq,
							end_seq);
1354 1355 1356 1357
		if (unlikely(in_sack < 0))
			break;

		if (in_sack)
1358 1359
			*flag |= tcp_sacktag_one(skb, sk, reord, dup_sack,
						 *fack_count);
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369

		*fack_count += tcp_skb_pcount(skb);
	}
	return skb;
}

/* Avoid all extra work that is being done by sacktag while walking in
 * a normal way
 */
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1370
					u32 skip_to_seq, int *fack_count)
1371 1372 1373 1374 1375
{
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;

1376
		if (!before(TCP_SKB_CB(skb)->end_seq, skip_to_seq))
1377
			break;
1378 1379

		*fack_count += tcp_skb_pcount(skb);
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
	}
	return skb;
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
						u32 skip_to_seq,
						int *fack_count, int *reord,
						int *flag)
{
	if (next_dup == NULL)
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1395
		skb = tcp_sacktag_skip(skb, sk, next_dup->start_seq, fack_count);
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
		tcp_sacktag_walk(skb, sk, NULL,
				 next_dup->start_seq, next_dup->end_seq,
				 1, fack_count, reord, flag);
	}

	return skb;
}

static int tcp_sack_cache_ok(struct tcp_sock *tp, struct tcp_sack_block *cache)
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1409
static int
1410 1411
tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb,
			u32 prior_snd_una)
L
Linus Torvalds 已提交
1412
{
1413
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1414
	struct tcp_sock *tp = tcp_sk(sk);
1415 1416
	unsigned char *ptr = (skb_transport_header(ack_skb) +
			      TCP_SKB_CB(ack_skb)->sacked);
1417 1418
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
	struct tcp_sack_block sp[4];
1419 1420
	struct tcp_sack_block *cache;
	struct sk_buff *skb;
1421
	int num_sacks = (ptr[1] - TCPOLEN_SACK_BASE) >> 3;
1422
	int used_sacks;
L
Linus Torvalds 已提交
1423 1424
	int reord = tp->packets_out;
	int flag = 0;
1425
	int found_dup_sack = 0;
1426 1427
	int fack_count;
	int i, j;
1428
	int first_sack_index;
L
Linus Torvalds 已提交
1429

1430
	if (!tp->sacked_out) {
1431 1432
		if (WARN_ON(tp->fackets_out))
			tp->fackets_out = 0;
1433
		tcp_highest_sack_reset(sk);
1434
	}
L
Linus Torvalds 已提交
1435

1436
	found_dup_sack = tcp_check_dsack(tp, ack_skb, sp_wire,
1437 1438
					 num_sacks, prior_snd_una);
	if (found_dup_sack)
1439
		flag |= FLAG_DSACKING_ACK;
1440 1441 1442 1443 1444 1445 1446 1447

	/* Eliminate too old ACKs, but take into
	 * account more or less fresh ones, they can
	 * contain valid SACK info.
	 */
	if (before(TCP_SKB_CB(ack_skb)->ack_seq, prior_snd_una - tp->max_window))
		return 0;

1448 1449 1450
	if (!tp->packets_out)
		goto out;

1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
		int dup_sack = !i && found_dup_sack;

		sp[used_sacks].start_seq = ntohl(get_unaligned(&sp_wire[i].start_seq));
		sp[used_sacks].end_seq = ntohl(get_unaligned(&sp_wire[i].end_seq));

		if (!tcp_is_sackblock_valid(tp, dup_sack,
					    sp[used_sacks].start_seq,
					    sp[used_sacks].end_seq)) {
			if (dup_sack) {
				if (!tp->undo_marker)
					NET_INC_STATS_BH(LINUX_MIB_TCPDSACKIGNOREDNOUNDO);
				else
					NET_INC_STATS_BH(LINUX_MIB_TCPDSACKIGNOREDOLD);
			} else {
				/* Don't count olds caused by ACK reordering */
				if ((TCP_SKB_CB(ack_skb)->ack_seq != tp->snd_una) &&
				    !after(sp[used_sacks].end_seq, tp->snd_una))
					continue;
				NET_INC_STATS_BH(LINUX_MIB_TCPSACKDISCARD);
			}
			if (i == 0)
				first_sack_index = -1;
			continue;
		}

		/* Ignore very old stuff early */
		if (!after(sp[used_sacks].end_seq, prior_snd_una))
			continue;

		used_sacks++;
	}

1486 1487
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1488 1489
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1490
				struct tcp_sack_block tmp;
B
Baruch Even 已提交
1491

1492
				tmp = sp[j];
1493 1494
				sp[j] = sp[j + 1];
				sp[j + 1] = tmp;
1495

1496 1497
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1498
					first_sack_index = j + 1;
1499 1500 1501 1502
			}
		}
	}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
	skb = tcp_write_queue_head(sk);
	fack_count = 0;
	i = 0;

	if (!tp->sacked_out) {
		/* It's already past, so skip checking against it */
		cache = tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
	} else {
		cache = tp->recv_sack_cache;
		/* Skip empty blocks in at head of the cache */
		while (tcp_sack_cache_ok(tp, cache) && !cache->start_seq &&
		       !cache->end_seq)
			cache++;
1516 1517
	}

1518
	while (i < used_sacks) {
1519 1520
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
1521
		int dup_sack = (found_dup_sack && (i == first_sack_index));
1522
		struct tcp_sack_block *next_dup = NULL;
1523

1524 1525
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1526 1527 1528 1529 1530

		/* Event "B" in the comment above. */
		if (after(end_seq, tp->high_seq))
			flag |= FLAG_DATA_LOST;

1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
		/* Skip too early cached blocks */
		while (tcp_sack_cache_ok(tp, cache) &&
		       !before(start_seq, cache->end_seq))
			cache++;

		/* Can skip some work by looking recv_sack_cache? */
		if (tcp_sack_cache_ok(tp, cache) && !dup_sack &&
		    after(end_seq, cache->start_seq)) {

			/* Head todo? */
			if (before(start_seq, cache->start_seq)) {
1542 1543
				skb = tcp_sacktag_skip(skb, sk, start_seq,
						       &fack_count);
1544 1545 1546 1547 1548
				skb = tcp_sacktag_walk(skb, sk, next_dup,
						       start_seq,
						       cache->start_seq,
						       dup_sack, &fack_count,
						       &reord, &flag);
1549
			}
1550

1551
			/* Rest of the block already fully processed? */
1552
			if (!after(end_seq, cache->end_seq))
1553
				goto advance_sp;
1554

1555 1556 1557 1558
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
						       cache->end_seq,
						       &fack_count, &reord,
						       &flag);
1559

1560
			/* ...tail remains todo... */
1561
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1562
				/* ...but better entrypoint exists! */
1563 1564 1565
				skb = tcp_highest_sack(sk);
				if (skb == NULL)
					break;
1566 1567 1568
				fack_count = tp->fackets_out;
				cache++;
				goto walk;
1569 1570
			}

1571 1572
			skb = tcp_sacktag_skip(skb, sk, cache->end_seq,
					       &fack_count);
1573 1574 1575 1576
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1577

1578 1579 1580 1581
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
			if (skb == NULL)
				break;
1582
			fack_count = tp->fackets_out;
L
Linus Torvalds 已提交
1583
		}
1584
		skb = tcp_sacktag_skip(skb, sk, start_seq, &fack_count);
1585 1586 1587 1588

walk:
		skb = tcp_sacktag_walk(skb, sk, next_dup, start_seq, end_seq,
				       dup_sack, &fack_count, &reord, &flag);
1589

1590
advance_sp:
1591 1592 1593 1594 1595
		/* SACK enhanced FRTO (RFC4138, Appendix B): Clearing correct
		 * due to in-order walk
		 */
		if (after(end_seq, tp->frto_highmark))
			flag &= ~FLAG_ONLY_ORIG_SACKED;
1596 1597

		i++;
L
Linus Torvalds 已提交
1598 1599
	}

1600 1601 1602 1603 1604 1605 1606 1607
	/* Clear the head of the cache sack blocks so we can skip it next time */
	for (i = 0; i < ARRAY_SIZE(tp->recv_sack_cache) - used_sacks; i++) {
		tp->recv_sack_cache[i].start_seq = 0;
		tp->recv_sack_cache[i].end_seq = 0;
	}
	for (j = 0; j < used_sacks; j++)
		tp->recv_sack_cache[i++] = sp[j];

1608
	tcp_mark_lost_retrans(sk);
L
Linus Torvalds 已提交
1609

1610 1611
	tcp_verify_left_out(tp);

1612 1613
	if ((reord < tp->fackets_out) &&
	    ((icsk->icsk_ca_state != TCP_CA_Loss) || tp->undo_marker) &&
1614
	    (!tp->frto_highmark || after(tp->snd_una, tp->frto_highmark)))
1615
		tcp_update_reordering(sk, tp->fackets_out - reord, 0);
L
Linus Torvalds 已提交
1616

1617 1618
out:

L
Linus Torvalds 已提交
1619 1620 1621 1622 1623 1624 1625 1626 1627
#if FASTRETRANS_DEBUG > 0
	BUG_TRAP((int)tp->sacked_out >= 0);
	BUG_TRAP((int)tp->lost_out >= 0);
	BUG_TRAP((int)tp->retrans_out >= 0);
	BUG_TRAP((int)tcp_packets_in_flight(tp) >= 0);
#endif
	return flag;
}

1628 1629 1630
/* If we receive more dupacks than we expected counting segments
 * in assumption of absent reordering, interpret this as reordering.
 * The only another reason could be bug in receiver TCP.
1631
 */
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
static void tcp_check_reno_reordering(struct sock *sk, const int addend)
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 holes;

	holes = max(tp->lost_out, 1U);
	holes = min(holes, tp->packets_out);

	if ((tp->sacked_out + holes) > tp->packets_out) {
		tp->sacked_out = tp->packets_out - holes;
		tcp_update_reordering(sk, tp->packets_out + addend, 0);
	}
}

/* Emulate SACKs for SACKless connection: account for a new dupack. */

static void tcp_add_reno_sack(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	tp->sacked_out++;
	tcp_check_reno_reordering(sk, 0);
1653
	tcp_verify_left_out(tp);
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
}

/* Account for ACK, ACKing some data in Reno Recovery phase. */

static void tcp_remove_reno_sacks(struct sock *sk, int acked)
{
	struct tcp_sock *tp = tcp_sk(sk);

	if (acked > 0) {
		/* One ACK acked hole. The rest eat duplicate ACKs. */
1664
		if (acked - 1 >= tp->sacked_out)
1665 1666
			tp->sacked_out = 0;
		else
1667
			tp->sacked_out -= acked - 1;
1668 1669
	}
	tcp_check_reno_reordering(sk, acked);
1670
	tcp_verify_left_out(tp);
1671 1672 1673 1674 1675 1676 1677
}

static inline void tcp_reset_reno_sack(struct tcp_sock *tp)
{
	tp->sacked_out = 0;
}

1678 1679 1680
/* F-RTO can only be used if TCP has never retransmitted anything other than
 * head (SACK enhanced variant from Appendix B of RFC4138 is more robust here)
 */
1681
int tcp_use_frto(struct sock *sk)
1682 1683
{
	const struct tcp_sock *tp = tcp_sk(sk);
1684 1685
	struct sk_buff *skb;

1686
	if (!sysctl_tcp_frto)
1687
		return 0;
1688

I
Ilpo Järvinen 已提交
1689 1690 1691
	if (IsSackFrto())
		return 1;

1692 1693 1694 1695
	/* Avoid expensive walking of rexmit queue if possible */
	if (tp->retrans_out > 1)
		return 0;

1696 1697 1698 1699 1700
	skb = tcp_write_queue_head(sk);
	skb = tcp_write_queue_next(sk, skb);	/* Skips head */
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1701
		if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
1702 1703
			return 0;
		/* Short-circuit when first non-SACKed skb has been checked */
1704
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
1705 1706 1707
			break;
	}
	return 1;
1708 1709
}

1710 1711
/* RTO occurred, but do not yet enter Loss state. Instead, defer RTO
 * recovery a bit and use heuristics in tcp_process_frto() to detect if
1712 1713 1714 1715 1716
 * the RTO was spurious. Only clear SACKED_RETRANS of the head here to
 * keep retrans_out counting accurate (with SACK F-RTO, other than head
 * may still have that bit set); TCPCB_LOST and remaining SACKED_RETRANS
 * bits are handled if the Loss state is really to be entered (in
 * tcp_enter_frto_loss).
1717 1718 1719 1720
 *
 * Do like tcp_enter_loss() would; when RTO expires the second time it
 * does:
 *  "Reduce ssthresh if it has not yet been made inside this window."
L
Linus Torvalds 已提交
1721 1722 1723
 */
void tcp_enter_frto(struct sock *sk)
{
1724
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1725 1726 1727
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

1728
	if ((!tp->frto_counter && icsk->icsk_ca_state <= TCP_CA_Disorder) ||
1729
	    tp->snd_una == tp->high_seq ||
1730 1731
	    ((icsk->icsk_ca_state == TCP_CA_Loss || tp->frto_counter) &&
	     !icsk->icsk_retransmits)) {
1732
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
1733
		/* Our state is too optimistic in ssthresh() call because cwnd
1734
		 * is not reduced until tcp_enter_frto_loss() when previous F-RTO
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
		 * recovery has not yet completed. Pattern would be this: RTO,
		 * Cumulative ACK, RTO (2xRTO for the same segment does not end
		 * up here twice).
		 * RFC4138 should be more specific on what to do, even though
		 * RTO is quite unlikely to occur after the first Cumulative ACK
		 * due to back-off and complexity of triggering events ...
		 */
		if (tp->frto_counter) {
			u32 stored_cwnd;
			stored_cwnd = tp->snd_cwnd;
			tp->snd_cwnd = 2;
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
			tp->snd_cwnd = stored_cwnd;
		} else {
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		}
		/* ... in theory, cong.control module could do "any tricks" in
		 * ssthresh(), which means that ca_state, lost bits and lost_out
		 * counter would have to be faked before the call occurs. We
		 * consider that too expensive, unlikely and hacky, so modules
		 * using these in ssthresh() must deal these incompatibility
		 * issues if they receives CA_EVENT_FRTO and frto_counter != 0
		 */
1758
		tcp_ca_event(sk, CA_EVENT_FRTO);
L
Linus Torvalds 已提交
1759 1760 1761 1762 1763
	}

	tp->undo_marker = tp->snd_una;
	tp->undo_retrans = 0;

1764
	skb = tcp_write_queue_head(sk);
1765 1766
	if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
		tp->undo_marker = 0;
1767
	if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
1768
		TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
1769
		tp->retrans_out -= tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
1770
	}
1771
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1772

1773 1774 1775
	/* Too bad if TCP was application limited */
	tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp) + 1);

I
Ilpo Järvinen 已提交
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
	/* Earlier loss recovery underway (see RFC4138; Appendix B).
	 * The last condition is necessary at least in tp->frto_counter case.
	 */
	if (IsSackFrto() && (tp->frto_counter ||
	    ((1 << icsk->icsk_ca_state) & (TCPF_CA_Recovery|TCPF_CA_Loss))) &&
	    after(tp->high_seq, tp->snd_una)) {
		tp->frto_highmark = tp->high_seq;
	} else {
		tp->frto_highmark = tp->snd_nxt;
	}
1786 1787
	tcp_set_ca_state(sk, TCP_CA_Disorder);
	tp->high_seq = tp->snd_nxt;
1788
	tp->frto_counter = 1;
L
Linus Torvalds 已提交
1789 1790 1791 1792 1793 1794
}

/* Enter Loss state after F-RTO was applied. Dupack arrived after RTO,
 * which indicates that we should follow the traditional RTO recovery,
 * i.e. mark everything lost and do go-back-N retransmission.
 */
1795
static void tcp_enter_frto_loss(struct sock *sk, int allowed_segments, int flag)
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	tp->lost_out = 0;
1801
	tp->retrans_out = 0;
1802
	if (tcp_is_reno(tp))
1803
		tcp_reset_reno_sack(tp);
L
Linus Torvalds 已提交
1804

1805 1806 1807
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1808 1809

		TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
1810 1811 1812 1813
		/*
		 * Count the retransmission made on RTO correctly (only when
		 * waiting for the first ACK and did not get it)...
		 */
1814
		if ((tp->frto_counter == 1) && !(flag & FLAG_DATA_ACKED)) {
1815 1816 1817
			/* For some reason this R-bit might get cleared? */
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)
				tp->retrans_out += tcp_skb_pcount(skb);
1818 1819 1820
			/* ...enter this if branch just for the first segment */
			flag |= FLAG_DATA_ACKED;
		} else {
1821 1822
			if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
				tp->undo_marker = 0;
1823
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
1824
		}
L
Linus Torvalds 已提交
1825

1826
		/* Don't lost mark skbs that were fwd transmitted after RTO */
1827
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) &&
1828 1829 1830
		    !after(TCP_SKB_CB(skb)->end_seq, tp->frto_highmark)) {
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
1831 1832
		}
	}
1833
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1834

1835
	tp->snd_cwnd = tcp_packets_in_flight(tp) + allowed_segments;
L
Linus Torvalds 已提交
1836 1837 1838
	tp->snd_cwnd_cnt = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;
	tp->frto_counter = 0;
1839
	tp->bytes_acked = 0;
L
Linus Torvalds 已提交
1840 1841

	tp->reordering = min_t(unsigned int, tp->reordering,
1842
			       sysctl_tcp_reordering);
1843
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1844 1845
	tp->high_seq = tp->frto_highmark;
	TCP_ECN_queue_cwr(tp);
1846

1847
	tcp_clear_retrans_hints_partial(tp);
L
Linus Torvalds 已提交
1848 1849
}

1850
static void tcp_clear_retrans_partial(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1851 1852 1853 1854 1855 1856 1857 1858
{
	tp->retrans_out = 0;
	tp->lost_out = 0;

	tp->undo_marker = 0;
	tp->undo_retrans = 0;
}

1859 1860 1861 1862 1863 1864 1865 1866
void tcp_clear_retrans(struct tcp_sock *tp)
{
	tcp_clear_retrans_partial(tp);

	tp->fackets_out = 0;
	tp->sacked_out = 0;
}

L
Linus Torvalds 已提交
1867 1868 1869 1870 1871 1872
/* Enter Loss state. If "how" is not zero, forget all SACK information
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
void tcp_enter_loss(struct sock *sk, int how)
{
1873
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1874 1875 1876 1877
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	/* Reduce ssthresh if it has not yet been made inside this window. */
1878 1879 1880 1881 1882
	if (icsk->icsk_ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq ||
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
L
Linus Torvalds 已提交
1883 1884 1885 1886 1887
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;

1888
	tp->bytes_acked = 0;
1889 1890 1891 1892
	tcp_clear_retrans_partial(tp);

	if (tcp_is_reno(tp))
		tcp_reset_reno_sack(tp);
L
Linus Torvalds 已提交
1893

1894 1895 1896
	if (!how) {
		/* Push undo marker, if it was plain RTO and nothing
		 * was retransmitted. */
L
Linus Torvalds 已提交
1897
		tp->undo_marker = tp->snd_una;
1898 1899
		tcp_clear_retrans_hints_partial(tp);
	} else {
1900 1901
		tp->sacked_out = 0;
		tp->fackets_out = 0;
1902 1903
		tcp_clear_all_retrans_hints(tp);
	}
L
Linus Torvalds 已提交
1904

1905 1906 1907
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1908

1909
		if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
L
Linus Torvalds 已提交
1910 1911 1912 1913 1914 1915 1916 1917
			tp->undo_marker = 0;
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
		if (!(TCP_SKB_CB(skb)->sacked&TCPCB_SACKED_ACKED) || how) {
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
		}
	}
1918
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1919 1920

	tp->reordering = min_t(unsigned int, tp->reordering,
1921
			       sysctl_tcp_reordering);
1922
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1923 1924
	tp->high_seq = tp->snd_nxt;
	TCP_ECN_queue_cwr(tp);
1925
	/* Abort F-RTO algorithm if one is in progress */
1926
	tp->frto_counter = 0;
L
Linus Torvalds 已提交
1927 1928
}

1929 1930 1931 1932 1933 1934 1935
/* If ACK arrived pointing to a remembered SACK, it means that our
 * remembered SACKs do not reflect real state of receiver i.e.
 * receiver _host_ is heavily congested (or buggy).
 *
 * Do processing similar to RTO timeout.
 */
static int tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
1936
{
1937
	if (flag & FLAG_SACK_RENEGING) {
1938
		struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1939 1940 1941
		NET_INC_STATS_BH(LINUX_MIB_TCPSACKRENEGING);

		tcp_enter_loss(sk, 1);
1942
		icsk->icsk_retransmits++;
1943
		tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
1944
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
1945
					  icsk->icsk_rto, TCP_RTO_MAX);
L
Linus Torvalds 已提交
1946 1947 1948 1949 1950 1951 1952
		return 1;
	}
	return 0;
}

static inline int tcp_fackets_out(struct tcp_sock *tp)
{
1953
	return tcp_is_reno(tp) ? tp->sacked_out + 1 : tp->fackets_out;
L
Linus Torvalds 已提交
1954 1955
}

1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975
/* Heurestics to calculate number of duplicate ACKs. There's no dupACKs
 * counter when SACK is enabled (without SACK, sacked_out is used for
 * that purpose).
 *
 * Instead, with FACK TCP uses fackets_out that includes both SACKed
 * segments up to the highest received SACK block so far and holes in
 * between them.
 *
 * With reordering, holes may still be in flight, so RFC3517 recovery
 * uses pure sacked_out (total number of SACKed segments) even though
 * it violates the RFC that uses duplicate ACKs, often these are equal
 * but when e.g. out-of-window ACKs or packet duplication occurs,
 * they differ. Since neither occurs due to loss, TCP should really
 * ignore them.
 */
static inline int tcp_dupack_heurestics(struct tcp_sock *tp)
{
	return tcp_is_fack(tp) ? tp->fackets_out : tp->sacked_out + 1;
}

1976
static inline int tcp_skb_timedout(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
1977
{
1978
	return (tcp_time_stamp - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto);
L
Linus Torvalds 已提交
1979 1980
}

1981
static inline int tcp_head_timedout(struct sock *sk)
L
Linus Torvalds 已提交
1982
{
1983 1984
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
1985
	return tp->packets_out &&
1986
	       tcp_skb_timedout(sk, tcp_write_queue_head(sk));
L
Linus Torvalds 已提交
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
}

/* Linux NewReno/SACK/FACK/ECN state machine.
 * --------------------------------------
 *
 * "Open"	Normal state, no dubious events, fast path.
 * "Disorder"   In all the respects it is "Open",
 *		but requires a bit more attention. It is entered when
 *		we see some SACKs or dupacks. It is split of "Open"
 *		mainly to move some processing from fast path to slow one.
 * "CWR"	CWND was reduced due to some Congestion Notification event.
 *		It can be ECN, ICMP source quench, local device congestion.
 * "Recovery"	CWND was reduced, we are fast-retransmitting.
 * "Loss"	CWND was reduced due to RTO timeout or SACK reneging.
 *
 * tcp_fastretrans_alert() is entered:
 * - each incoming ACK, if state is not "Open"
 * - when arrived ACK is unusual, namely:
 *	* SACK
 *	* Duplicate ACK.
 *	* ECN ECE.
 *
 * Counting packets in flight is pretty simple.
 *
 *	in_flight = packets_out - left_out + retrans_out
 *
 *	packets_out is SND.NXT-SND.UNA counted in packets.
 *
 *	retrans_out is number of retransmitted segments.
 *
 *	left_out is number of segments left network, but not ACKed yet.
 *
 *		left_out = sacked_out + lost_out
 *
 *     sacked_out: Packets, which arrived to receiver out of order
 *		   and hence not ACKed. With SACKs this number is simply
 *		   amount of SACKed data. Even without SACKs
 *		   it is easy to give pretty reliable estimate of this number,
 *		   counting duplicate ACKs.
 *
 *       lost_out: Packets lost by network. TCP has no explicit
 *		   "loss notification" feedback from network (for now).
 *		   It means that this number can be only _guessed_.
 *		   Actually, it is the heuristics to predict lossage that
 *		   distinguishes different algorithms.
 *
 *	F.e. after RTO, when all the queue is considered as lost,
 *	lost_out = packets_out and in_flight = retrans_out.
 *
 *		Essentially, we have now two algorithms counting
 *		lost packets.
 *
 *		FACK: It is the simplest heuristics. As soon as we decided
 *		that something is lost, we decide that _all_ not SACKed
 *		packets until the most forward SACK are lost. I.e.
 *		lost_out = fackets_out - sacked_out and left_out = fackets_out.
 *		It is absolutely correct estimate, if network does not reorder
 *		packets. And it loses any connection to reality when reordering
 *		takes place. We use FACK by default until reordering
 *		is suspected on the path to this destination.
 *
 *		NewReno: when Recovery is entered, we assume that one segment
 *		is lost (classic Reno). While we are in Recovery and
 *		a partial ACK arrives, we assume that one more packet
 *		is lost (NewReno). This heuristics are the same in NewReno
 *		and SACK.
 *
 *  Imagine, that's all! Forget about all this shamanism about CWND inflation
 *  deflation etc. CWND is real congestion window, never inflated, changes
 *  only according to classic VJ rules.
 *
 * Really tricky (and requiring careful tuning) part of algorithm
 * is hidden in functions tcp_time_to_recover() and tcp_xmit_retransmit_queue().
 * The first determines the moment _when_ we should reduce CWND and,
 * hence, slow down forward transmission. In fact, it determines the moment
 * when we decide that hole is caused by loss, rather than by a reorder.
 *
 * tcp_xmit_retransmit_queue() decides, _what_ we should retransmit to fill
 * holes, caused by lost packets.
 *
 * And the most logically complicated part of algorithm is undo
 * heuristics. We detect false retransmits due to both too early
 * fast retransmit (reordering) and underestimated RTO, analyzing
 * timestamps and D-SACKs. When we detect that some segments were
 * retransmitted by mistake and CWND reduction was wrong, we undo
 * window reduction and abort recovery phase. This logic is hidden
 * inside several functions named tcp_try_undo_<something>.
 */

/* This function decides, when we should leave Disordered state
 * and enter Recovery phase, reducing congestion window.
 *
 * Main question: may we further continue forward transmission
 * with the same cwnd?
 */
2082
static int tcp_time_to_recover(struct sock *sk)
L
Linus Torvalds 已提交
2083
{
2084
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2085 2086
	__u32 packets_out;

2087
	/* Do not perform any recovery during F-RTO algorithm */
2088 2089 2090
	if (tp->frto_counter)
		return 0;

L
Linus Torvalds 已提交
2091 2092 2093 2094 2095
	/* Trick#1: The loss is proven. */
	if (tp->lost_out)
		return 1;

	/* Not-A-Trick#2 : Classic rule... */
2096
	if (tcp_dupack_heurestics(tp) > tp->reordering)
L
Linus Torvalds 已提交
2097 2098 2099 2100 2101
		return 1;

	/* Trick#3 : when we use RFC2988 timer restart, fast
	 * retransmit can be triggered by timeout of queue head.
	 */
2102
	if (tcp_is_fack(tp) && tcp_head_timedout(sk))
L
Linus Torvalds 已提交
2103 2104 2105 2106 2107 2108 2109 2110
		return 1;

	/* Trick#4: It is still not OK... But will it be useful to delay
	 * recovery more?
	 */
	packets_out = tp->packets_out;
	if (packets_out <= tp->reordering &&
	    tp->sacked_out >= max_t(__u32, packets_out/2, sysctl_tcp_reordering) &&
2111
	    !tcp_may_send_now(sk)) {
L
Linus Torvalds 已提交
2112 2113 2114 2115 2116 2117 2118 2119 2120
		/* We have nothing to send. This connection is limited
		 * either by receiver window or by application.
		 */
		return 1;
	}

	return 0;
}

2121 2122 2123 2124 2125
/* RFC: This is from the original, I doubt that this is necessary at all:
 * clear xmit_retrans hint if seq of this skb is beyond hint. How could we
 * retransmitted past LOST markings in the first place? I'm not fully sure
 * about undo and end of connection cases, which can cause R without L?
 */
2126
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
2127 2128 2129
{
	if ((tp->retransmit_skb_hint != NULL) &&
	    before(TCP_SKB_CB(skb)->seq,
2130
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
2131
		tp->retransmit_skb_hint = NULL;
2132 2133
}

2134 2135 2136 2137
/* Mark head of queue up as lost. With RFC3517 SACK, the packets is
 * is against sacked "cnt", otherwise it's against facked "cnt"
 */
static void tcp_mark_head_lost(struct sock *sk, int packets, int fast_rexmit)
L
Linus Torvalds 已提交
2138
{
2139
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2140
	struct sk_buff *skb;
2141
	int cnt;
L
Linus Torvalds 已提交
2142

2143 2144 2145 2146 2147
	BUG_TRAP(packets <= tp->packets_out);
	if (tp->lost_skb_hint) {
		skb = tp->lost_skb_hint;
		cnt = tp->lost_cnt_hint;
	} else {
2148
		skb = tcp_write_queue_head(sk);
2149 2150
		cnt = 0;
	}
L
Linus Torvalds 已提交
2151

2152 2153 2154
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2155 2156 2157 2158
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2159

2160
		if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
2161 2162 2163 2164
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

		if (((!fast_rexmit || (tp->lost_out > 0)) && (cnt > packets)) ||
2165
		    after(TCP_SKB_CB(skb)->end_seq, tp->high_seq))
L
Linus Torvalds 已提交
2166
			break;
2167
		if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_SACKED_ACKED|TCPCB_LOST))) {
L
Linus Torvalds 已提交
2168 2169
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
2170
			tcp_verify_retransmit_hint(tp, skb);
L
Linus Torvalds 已提交
2171 2172
		}
	}
2173
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2174 2175 2176 2177
}

/* Account newly detected lost packet(s) */

2178
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2179
{
2180 2181
	struct tcp_sock *tp = tcp_sk(sk);

2182 2183 2184
	if (tcp_is_reno(tp)) {
		tcp_mark_head_lost(sk, 1, fast_rexmit);
	} else if (tcp_is_fack(tp)) {
L
Linus Torvalds 已提交
2185 2186 2187
		int lost = tp->fackets_out - tp->reordering;
		if (lost <= 0)
			lost = 1;
2188
		tcp_mark_head_lost(sk, lost, fast_rexmit);
L
Linus Torvalds 已提交
2189
	} else {
2190 2191 2192 2193
		int sacked_upto = tp->sacked_out - tp->reordering;
		if (sacked_upto < 0)
			sacked_upto = 0;
		tcp_mark_head_lost(sk, sacked_upto, fast_rexmit);
L
Linus Torvalds 已提交
2194 2195 2196 2197 2198 2199 2200
	}

	/* New heuristics: it is possible only after we switched
	 * to restart timer each time when something is ACKed.
	 * Hence, we can detect timed out packets during fast
	 * retransmit without falling to slow start.
	 */
2201
	if (tcp_is_fack(tp) && tcp_head_timedout(sk)) {
L
Linus Torvalds 已提交
2202 2203
		struct sk_buff *skb;

2204
		skb = tp->scoreboard_skb_hint ? tp->scoreboard_skb_hint
2205
			: tcp_write_queue_head(sk);
2206

2207 2208 2209
		tcp_for_write_queue_from(skb, sk) {
			if (skb == tcp_send_head(sk))
				break;
2210 2211 2212
			if (!tcp_skb_timedout(sk, skb))
				break;

2213
			if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_SACKED_ACKED|TCPCB_LOST))) {
L
Linus Torvalds 已提交
2214 2215
				TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
				tp->lost_out += tcp_skb_pcount(skb);
2216
				tcp_verify_retransmit_hint(tp, skb);
L
Linus Torvalds 已提交
2217 2218
			}
		}
2219 2220 2221

		tp->scoreboard_skb_hint = skb;

2222
		tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2223 2224 2225 2226 2227 2228 2229 2230 2231
	}
}

/* CWND moderation, preventing bursts due to too big ACKs
 * in dubious situations.
 */
static inline void tcp_moderate_cwnd(struct tcp_sock *tp)
{
	tp->snd_cwnd = min(tp->snd_cwnd,
2232
			   tcp_packets_in_flight(tp) + tcp_max_burst(tp));
L
Linus Torvalds 已提交
2233 2234 2235
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
/* Lower bound on congestion window is slow start threshold
 * unless congestion avoidance choice decides to overide it.
 */
static inline u32 tcp_cwnd_min(const struct sock *sk)
{
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;

	return ca_ops->min_cwnd ? ca_ops->min_cwnd(sk) : tcp_sk(sk)->snd_ssthresh;
}

L
Linus Torvalds 已提交
2246
/* Decrease cwnd each second ack. */
2247
static void tcp_cwnd_down(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2248
{
2249
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2250 2251
	int decr = tp->snd_cwnd_cnt + 1;

2252 2253 2254
	if ((flag & (FLAG_ANY_PROGRESS | FLAG_DSACKING_ACK)) ||
	    (tcp_is_reno(tp) && !(flag & FLAG_NOT_DUP))) {
		tp->snd_cwnd_cnt = decr & 1;
2255
		decr >>= 1;
L
Linus Torvalds 已提交
2256

2257 2258
		if (decr && tp->snd_cwnd > tcp_cwnd_min(sk))
			tp->snd_cwnd -= decr;
L
Linus Torvalds 已提交
2259

2260
		tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp) + 1);
2261 2262
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}
L
Linus Torvalds 已提交
2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
}

/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
static inline int tcp_packet_delayed(struct tcp_sock *tp)
{
	return !tp->retrans_stamp ||
		(tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		 (__s32)(tp->rx_opt.rcv_tsecr - tp->retrans_stamp) < 0);
}

/* Undo procedures. */

#if FASTRETRANS_DEBUG > 1
2278
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2279
{
2280
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2281
	struct inet_sock *inet = inet_sk(sk);
2282

L
Linus Torvalds 已提交
2283 2284 2285
	printk(KERN_DEBUG "Undo %s %u.%u.%u.%u/%u c%u l%u ss%u/%u p%u\n",
	       msg,
	       NIPQUAD(inet->daddr), ntohs(inet->dport),
2286
	       tp->snd_cwnd, tcp_left_out(tp),
L
Linus Torvalds 已提交
2287 2288 2289 2290 2291 2292 2293
	       tp->snd_ssthresh, tp->prior_ssthresh,
	       tp->packets_out);
}
#else
#define DBGUNDO(x...) do { } while (0)
#endif

2294
static void tcp_undo_cwr(struct sock *sk, const int undo)
L
Linus Torvalds 已提交
2295
{
2296 2297
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2298
	if (tp->prior_ssthresh) {
2299 2300 2301 2302
		const struct inet_connection_sock *icsk = inet_csk(sk);

		if (icsk->icsk_ca_ops->undo_cwnd)
			tp->snd_cwnd = icsk->icsk_ca_ops->undo_cwnd(sk);
L
Linus Torvalds 已提交
2303
		else
2304
			tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);
L
Linus Torvalds 已提交
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314

		if (undo && tp->prior_ssthresh > tp->snd_ssthresh) {
			tp->snd_ssthresh = tp->prior_ssthresh;
			TCP_ECN_withdraw_cwr(tp);
		}
	} else {
		tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);
	}
	tcp_moderate_cwnd(tp);
	tp->snd_cwnd_stamp = tcp_time_stamp;
2315 2316 2317

	/* There is something screwy going on with the retrans hints after
	   an undo */
2318
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
2319 2320 2321 2322
}

static inline int tcp_may_undo(struct tcp_sock *tp)
{
2323
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2324 2325 2326
}

/* People celebrate: "We love our President!" */
2327
static int tcp_try_undo_recovery(struct sock *sk)
L
Linus Torvalds 已提交
2328
{
2329 2330
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2331 2332 2333 2334
	if (tcp_may_undo(tp)) {
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2335
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2336 2337
		tcp_undo_cwr(sk, 1);
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
L
Linus Torvalds 已提交
2338 2339 2340 2341 2342
			NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO);
		else
			NET_INC_STATS_BH(LINUX_MIB_TCPFULLUNDO);
		tp->undo_marker = 0;
	}
2343
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2344 2345 2346 2347 2348 2349
		/* Hold old state until something *above* high_seq
		 * is ACKed. For Reno it is MUST to prevent false
		 * fast retransmits (RFC2582). SACK TCP is safe. */
		tcp_moderate_cwnd(tp);
		return 1;
	}
2350
	tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2351 2352 2353 2354
	return 0;
}

/* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
2355
static void tcp_try_undo_dsack(struct sock *sk)
L
Linus Torvalds 已提交
2356
{
2357 2358
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2359
	if (tp->undo_marker && !tp->undo_retrans) {
2360
		DBGUNDO(sk, "D-SACK");
2361
		tcp_undo_cwr(sk, 1);
L
Linus Torvalds 已提交
2362 2363 2364 2365 2366 2367 2368
		tp->undo_marker = 0;
		NET_INC_STATS_BH(LINUX_MIB_TCPDSACKUNDO);
	}
}

/* Undo during fast recovery after partial ACK. */

2369
static int tcp_try_undo_partial(struct sock *sk, int acked)
L
Linus Torvalds 已提交
2370
{
2371
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2372
	/* Partial ACK arrived. Force Hoe's retransmit. */
2373
	int failed = tcp_is_reno(tp) || (tcp_fackets_out(tp) > tp->reordering);
L
Linus Torvalds 已提交
2374 2375 2376 2377 2378 2379 2380 2381

	if (tcp_may_undo(tp)) {
		/* Plain luck! Hole if filled with delayed
		 * packet, rather than with a retransmit.
		 */
		if (tp->retrans_out == 0)
			tp->retrans_stamp = 0;

2382
		tcp_update_reordering(sk, tcp_fackets_out(tp) + acked, 1);
L
Linus Torvalds 已提交
2383

2384
		DBGUNDO(sk, "Hoe");
2385
		tcp_undo_cwr(sk, 0);
L
Linus Torvalds 已提交
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
		NET_INC_STATS_BH(LINUX_MIB_TCPPARTIALUNDO);

		/* So... Do not make Hoe's retransmit yet.
		 * If the first packet was delayed, the rest
		 * ones are most probably delayed as well.
		 */
		failed = 0;
	}
	return failed;
}

/* Undo during loss recovery after partial ACK. */
2398
static int tcp_try_undo_loss(struct sock *sk)
L
Linus Torvalds 已提交
2399
{
2400 2401
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2402 2403
	if (tcp_may_undo(tp)) {
		struct sk_buff *skb;
2404 2405 2406
		tcp_for_write_queue(skb, sk) {
			if (skb == tcp_send_head(sk))
				break;
L
Linus Torvalds 已提交
2407 2408
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
2409

2410
		tcp_clear_all_retrans_hints(tp);
2411

2412
		DBGUNDO(sk, "partial loss");
L
Linus Torvalds 已提交
2413
		tp->lost_out = 0;
2414
		tcp_undo_cwr(sk, 1);
L
Linus Torvalds 已提交
2415
		NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO);
2416
		inet_csk(sk)->icsk_retransmits = 0;
L
Linus Torvalds 已提交
2417
		tp->undo_marker = 0;
2418
		if (tcp_is_sack(tp))
2419
			tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2420 2421 2422 2423 2424
		return 1;
	}
	return 0;
}

2425
static inline void tcp_complete_cwr(struct sock *sk)
L
Linus Torvalds 已提交
2426
{
2427
	struct tcp_sock *tp = tcp_sk(sk);
2428
	tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
L
Linus Torvalds 已提交
2429
	tp->snd_cwnd_stamp = tcp_time_stamp;
2430
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2431 2432
}

2433
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2434
{
2435 2436
	struct tcp_sock *tp = tcp_sk(sk);

2437 2438
	tcp_verify_left_out(tp);

L
Linus Torvalds 已提交
2439 2440 2441
	if (tp->retrans_out == 0)
		tp->retrans_stamp = 0;

2442
	if (flag & FLAG_ECE)
2443
		tcp_enter_cwr(sk, 1);
L
Linus Torvalds 已提交
2444

2445
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
L
Linus Torvalds 已提交
2446 2447
		int state = TCP_CA_Open;

2448
		if (tcp_left_out(tp) || tp->retrans_out || tp->undo_marker)
L
Linus Torvalds 已提交
2449 2450
			state = TCP_CA_Disorder;

2451 2452
		if (inet_csk(sk)->icsk_ca_state != state) {
			tcp_set_ca_state(sk, state);
L
Linus Torvalds 已提交
2453 2454 2455 2456
			tp->high_seq = tp->snd_nxt;
		}
		tcp_moderate_cwnd(tp);
	} else {
2457
		tcp_cwnd_down(sk, flag);
L
Linus Torvalds 已提交
2458 2459 2460
	}
}

J
John Heffner 已提交
2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
static void tcp_mtup_probe_failed(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);

	icsk->icsk_mtup.search_high = icsk->icsk_mtup.probe_size - 1;
	icsk->icsk_mtup.probe_size = 0;
}

static void tcp_mtup_probe_success(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);

	/* FIXME: breaks with very large cwnd */
	tp->prior_ssthresh = tcp_current_ssthresh(sk);
	tp->snd_cwnd = tp->snd_cwnd *
		       tcp_mss_to_mtu(sk, tp->mss_cache) /
		       icsk->icsk_mtup.probe_size;
	tp->snd_cwnd_cnt = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;
	tp->rcv_ssthresh = tcp_current_ssthresh(sk);

	icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
	icsk->icsk_mtup.probe_size = 0;
	tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
}

L
Linus Torvalds 已提交
2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498
/* Process an event, which can update packets-in-flight not trivially.
 * Main goal of this function is to calculate new estimate for left_out,
 * taking into account both packets sitting in receiver's buffer and
 * packets lost by network.
 *
 * Besides that it does CWND reduction, when packet loss is detected
 * and changes state of machine.
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2499
static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked, int flag)
L
Linus Torvalds 已提交
2500
{
2501
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2502
	struct tcp_sock *tp = tcp_sk(sk);
2503 2504
	int is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
	int do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2505 2506
				    (tcp_fackets_out(tp) > tp->reordering));
	int fast_rexmit = 0;
L
Linus Torvalds 已提交
2507

2508
	if (WARN_ON(!tp->packets_out && tp->sacked_out))
L
Linus Torvalds 已提交
2509
		tp->sacked_out = 0;
I
Ilpo Järvinen 已提交
2510
	if (WARN_ON(!tp->sacked_out && tp->fackets_out))
L
Linus Torvalds 已提交
2511 2512
		tp->fackets_out = 0;

2513
	/* Now state machine starts.
L
Linus Torvalds 已提交
2514
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2515
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2516 2517 2518
		tp->prior_ssthresh = 0;

	/* B. In all the states check for reneging SACKs. */
2519
	if (tcp_check_sack_reneging(sk, flag))
L
Linus Torvalds 已提交
2520 2521 2522
		return;

	/* C. Process data loss notification, provided it is valid. */
2523
	if (tcp_is_fack(tp) && (flag & FLAG_DATA_LOST) &&
L
Linus Torvalds 已提交
2524
	    before(tp->snd_una, tp->high_seq) &&
2525
	    icsk->icsk_ca_state != TCP_CA_Open &&
L
Linus Torvalds 已提交
2526
	    tp->fackets_out > tp->reordering) {
2527
		tcp_mark_head_lost(sk, tp->fackets_out - tp->reordering, 0);
L
Linus Torvalds 已提交
2528 2529 2530
		NET_INC_STATS_BH(LINUX_MIB_TCPLOSS);
	}

2531 2532
	/* D. Check consistency of the current state. */
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2533 2534 2535

	/* E. Check state exit conditions. State can be terminated
	 *    when high_seq is ACKed. */
2536
	if (icsk->icsk_ca_state == TCP_CA_Open) {
2537
		BUG_TRAP(tp->retrans_out == 0);
L
Linus Torvalds 已提交
2538 2539
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
2540
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2541
		case TCP_CA_Loss:
2542
			icsk->icsk_retransmits = 0;
2543
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2544 2545 2546 2547 2548 2549 2550
				return;
			break;

		case TCP_CA_CWR:
			/* CWR is to be held something *above* high_seq
			 * is ACKed for CWR bit to reach receiver. */
			if (tp->snd_una != tp->high_seq) {
2551 2552
				tcp_complete_cwr(sk);
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2553 2554 2555 2556
			}
			break;

		case TCP_CA_Disorder:
2557
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2558 2559 2560
			if (!tp->undo_marker ||
			    /* For SACK case do not Open to allow to undo
			     * catching for all duplicate ACKs. */
2561
			    tcp_is_reno(tp) || tp->snd_una != tp->high_seq) {
L
Linus Torvalds 已提交
2562
				tp->undo_marker = 0;
2563
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2564 2565 2566 2567
			}
			break;

		case TCP_CA_Recovery:
2568
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2569
				tcp_reset_reno_sack(tp);
2570
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2571
				return;
2572
			tcp_complete_cwr(sk);
L
Linus Torvalds 已提交
2573 2574 2575 2576 2577
			break;
		}
	}

	/* F. Process state. */
2578
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2579
	case TCP_CA_Recovery:
2580
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
2581
			if (tcp_is_reno(tp) && is_dupack)
2582
				tcp_add_reno_sack(sk);
2583 2584
		} else
			do_lost = tcp_try_undo_partial(sk, pkts_acked);
L
Linus Torvalds 已提交
2585 2586
		break;
	case TCP_CA_Loss:
2587
		if (flag & FLAG_DATA_ACKED)
2588
			icsk->icsk_retransmits = 0;
2589
		if (!tcp_try_undo_loss(sk)) {
L
Linus Torvalds 已提交
2590 2591 2592 2593
			tcp_moderate_cwnd(tp);
			tcp_xmit_retransmit_queue(sk);
			return;
		}
2594
		if (icsk->icsk_ca_state != TCP_CA_Open)
L
Linus Torvalds 已提交
2595 2596 2597
			return;
		/* Loss is undone; fall through to processing in Open state. */
	default:
2598
		if (tcp_is_reno(tp)) {
2599
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
2600 2601
				tcp_reset_reno_sack(tp);
			if (is_dupack)
2602
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
2603 2604
		}

2605
		if (icsk->icsk_ca_state == TCP_CA_Disorder)
2606
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2607

2608 2609
		if (!tcp_time_to_recover(sk)) {
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2610 2611 2612
			return;
		}

J
John Heffner 已提交
2613 2614 2615
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
2616
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
2617 2618 2619 2620 2621 2622 2623
			tcp_mtup_probe_failed(sk);
			/* Restores the reduction we did in tcp_mtup_probe() */
			tp->snd_cwnd++;
			tcp_simple_retransmit(sk);
			return;
		}

L
Linus Torvalds 已提交
2624 2625
		/* Otherwise enter Recovery state */

2626
		if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2627 2628 2629 2630 2631 2632 2633 2634 2635
			NET_INC_STATS_BH(LINUX_MIB_TCPRENORECOVERY);
		else
			NET_INC_STATS_BH(LINUX_MIB_TCPSACKRECOVERY);

		tp->high_seq = tp->snd_nxt;
		tp->prior_ssthresh = 0;
		tp->undo_marker = tp->snd_una;
		tp->undo_retrans = tp->retrans_out;

2636
		if (icsk->icsk_ca_state < TCP_CA_CWR) {
2637
			if (!(flag & FLAG_ECE))
2638 2639
				tp->prior_ssthresh = tcp_current_ssthresh(sk);
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
L
Linus Torvalds 已提交
2640 2641 2642
			TCP_ECN_queue_cwr(tp);
		}

2643
		tp->bytes_acked = 0;
L
Linus Torvalds 已提交
2644
		tp->snd_cwnd_cnt = 0;
2645
		tcp_set_ca_state(sk, TCP_CA_Recovery);
2646
		fast_rexmit = 1;
L
Linus Torvalds 已提交
2647 2648
	}

2649 2650
	if (do_lost || (tcp_is_fack(tp) && tcp_head_timedout(sk)))
		tcp_update_scoreboard(sk, fast_rexmit);
2651
	tcp_cwnd_down(sk, flag);
L
Linus Torvalds 已提交
2652 2653 2654 2655
	tcp_xmit_retransmit_queue(sk);
}

/* Read draft-ietf-tcplw-high-performance before mucking
S
Stephen Hemminger 已提交
2656
 * with this code. (Supersedes RFC1323)
L
Linus Torvalds 已提交
2657
 */
2658
static void tcp_ack_saw_tstamp(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
{
	/* RTTM Rule: A TSecr value received in a segment is used to
	 * update the averaged RTT measurement only if the segment
	 * acknowledges some new data, i.e., only if it advances the
	 * left edge of the send window.
	 *
	 * See draft-ietf-tcplw-high-performance-00, section 3.3.
	 * 1998/04/10 Andrey V. Savochkin <saw@msu.ru>
	 *
	 * Changed: reset backoff as soon as we see the first valid sample.
S
Stephen Hemminger 已提交
2669
	 * If we do not, we get strongly overestimated rto. With timestamps
L
Linus Torvalds 已提交
2670 2671 2672 2673 2674
	 * samples are accepted even from very old segments: f.e., when rtt=1
	 * increases to 8, we retransmit 5 times and after 8 seconds delayed
	 * answer arrives rto becomes 120 seconds! If at least one of segments
	 * in window is lost... Voila.	 			--ANK (010210)
	 */
2675 2676
	struct tcp_sock *tp = tcp_sk(sk);
	const __u32 seq_rtt = tcp_time_stamp - tp->rx_opt.rcv_tsecr;
2677
	tcp_rtt_estimator(sk, seq_rtt);
2678 2679 2680
	tcp_set_rto(sk);
	inet_csk(sk)->icsk_backoff = 0;
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
2681 2682
}

2683
static void tcp_ack_no_tstamp(struct sock *sk, u32 seq_rtt, int flag)
L
Linus Torvalds 已提交
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
{
	/* We don't have a timestamp. Can only use
	 * packets that are not retransmitted to determine
	 * rtt estimates. Also, we must not reset the
	 * backoff for rto until we get a non-retransmitted
	 * packet. This allows us to deal with a situation
	 * where the network delay has increased suddenly.
	 * I.e. Karn's algorithm. (SIGCOMM '87, p5.)
	 */

	if (flag & FLAG_RETRANS_DATA_ACKED)
		return;

2697
	tcp_rtt_estimator(sk, seq_rtt);
2698 2699 2700
	tcp_set_rto(sk);
	inet_csk(sk)->icsk_backoff = 0;
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
2701 2702
}

2703
static inline void tcp_ack_update_rtt(struct sock *sk, const int flag,
2704
				      const s32 seq_rtt)
L
Linus Torvalds 已提交
2705
{
2706
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2707 2708
	/* Note that peer MAY send zero echo. In this case it is ignored. (rfc1323) */
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
2709
		tcp_ack_saw_tstamp(sk, flag);
L
Linus Torvalds 已提交
2710
	else if (seq_rtt >= 0)
2711
		tcp_ack_no_tstamp(sk, seq_rtt, flag);
L
Linus Torvalds 已提交
2712 2713
}

2714
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
L
Linus Torvalds 已提交
2715
{
2716
	const struct inet_connection_sock *icsk = inet_csk(sk);
2717
	icsk->icsk_ca_ops->cong_avoid(sk, ack, in_flight);
2718
	tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
L
Linus Torvalds 已提交
2719 2720 2721 2722 2723
}

/* Restart timer after forward progress on connection.
 * RFC2988 recommends to restart timer to now+rto.
 */
2724
static void tcp_rearm_rto(struct sock *sk)
L
Linus Torvalds 已提交
2725
{
2726 2727
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2728
	if (!tp->packets_out) {
2729
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
2730
	} else {
2731 2732
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
					  inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
L
Linus Torvalds 已提交
2733 2734 2735
	}
}

2736
/* If we get here, the whole TSO packet has not been acked. */
2737
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
2738 2739
{
	struct tcp_sock *tp = tcp_sk(sk);
2740
	u32 packets_acked;
L
Linus Torvalds 已提交
2741

2742
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
2743 2744

	packets_acked = tcp_skb_pcount(skb);
2745
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
2746 2747 2748 2749 2750
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

	if (packets_acked) {
		BUG_ON(tcp_skb_pcount(skb) == 0);
2751
		BUG_ON(!before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq));
L
Linus Torvalds 已提交
2752 2753
	}

2754
	return packets_acked;
L
Linus Torvalds 已提交
2755 2756
}

2757 2758 2759 2760
/* Remove acknowledged frames from the retransmission queue. If our packet
 * is before the ack sequence we can discard it as it's confirmed to have
 * arrived at the other end.
 */
2761
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets)
L
Linus Torvalds 已提交
2762 2763
{
	struct tcp_sock *tp = tcp_sk(sk);
2764
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2765
	struct sk_buff *skb;
2766
	u32 now = tcp_time_stamp;
2767
	int fully_acked = 1;
2768
	int flag = 0;
2769
	u32 pkts_acked = 0;
2770
	u32 reord = tp->packets_out;
2771
	s32 seq_rtt = -1;
2772
	s32 ca_seq_rtt = -1;
2773
	ktime_t last_ackt = net_invalid_timestamp();
L
Linus Torvalds 已提交
2774

2775
	while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
2776
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
2777
		u32 end_seq;
2778
		u32 acked_pcount;
2779
		u8 sacked = scb->sacked;
L
Linus Torvalds 已提交
2780

2781
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
2782
		if (after(scb->end_seq, tp->snd_una)) {
2783 2784 2785 2786
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

2787 2788
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
2789 2790 2791 2792 2793
				break;

			fully_acked = 0;
			end_seq = tp->snd_una;
		} else {
2794
			acked_pcount = tcp_skb_pcount(skb);
2795
			end_seq = scb->end_seq;
L
Linus Torvalds 已提交
2796 2797
		}

J
John Heffner 已提交
2798
		/* MTU probing checks */
2799 2800 2801
		if (fully_acked && icsk->icsk_mtup.probe_size &&
		    !after(tp->mtu_probe.probe_seq_end, scb->end_seq)) {
			tcp_mtup_probe_success(sk, skb);
J
John Heffner 已提交
2802 2803
		}

2804 2805
		if (sacked & TCPCB_RETRANS) {
			if (sacked & TCPCB_SACKED_RETRANS)
2806
				tp->retrans_out -= acked_pcount;
2807 2808 2809
			flag |= FLAG_RETRANS_DATA_ACKED;
			ca_seq_rtt = -1;
			seq_rtt = -1;
2810
			if ((flag & FLAG_DATA_ACKED) || (acked_pcount > 1))
2811
				flag |= FLAG_NONHEAD_RETRANS_ACKED;
2812
		} else {
2813 2814
			ca_seq_rtt = now - scb->when;
			last_ackt = skb->tstamp;
2815
			if (seq_rtt < 0) {
2816
				seq_rtt = ca_seq_rtt;
2817
			}
2818
			if (!(sacked & TCPCB_SACKED_ACKED))
2819
				reord = min(pkts_acked, reord);
2820
		}
2821 2822

		if (sacked & TCPCB_SACKED_ACKED)
2823
			tp->sacked_out -= acked_pcount;
2824
		if (sacked & TCPCB_LOST)
2825
			tp->lost_out -= acked_pcount;
2826

2827
		if (unlikely(tp->urg_mode && !before(end_seq, tp->snd_up)))
2828 2829
			tp->urg_mode = 0;

2830 2831
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
2832

2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
		/* Initial outgoing SYN's get put onto the write_queue
		 * just like anything else we transmit.  It is not
		 * true data, and if we misinform our callers that
		 * this ACK acks real data, we will erroneously exit
		 * connection startup slow start one packet too
		 * quickly.  This is severely frowned upon behavior.
		 */
		if (!(scb->flags & TCPCB_FLAG_SYN)) {
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

2847 2848 2849
		if (!fully_acked)
			break;

2850
		tcp_unlink_write_queue(skb, sk);
2851
		sk_wmem_free_skb(sk, skb);
2852
		tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
2853 2854
	}

2855 2856 2857
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

2858
	if (flag & FLAG_ACKED) {
2859 2860 2861
		const struct tcp_congestion_ops *ca_ops
			= inet_csk(sk)->icsk_ca_ops;

2862
		tcp_ack_update_rtt(sk, flag, seq_rtt);
2863
		tcp_rearm_rto(sk);
2864

2865 2866 2867 2868 2869 2870 2871 2872
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
			/* Non-retransmitted hole got filled? That's reordering */
			if (reord < prior_fackets)
				tcp_update_reordering(sk, tp->fackets_out - reord, 0);
		}

I
Ilpo Järvinen 已提交
2873
		tp->fackets_out -= min(pkts_acked, tp->fackets_out);
2874

2875 2876 2877 2878
		if (ca_ops->pkts_acked) {
			s32 rtt_us = -1;

			/* Is the ACK triggering packet unambiguous? */
2879
			if (!(flag & FLAG_RETRANS_DATA_ACKED)) {
2880 2881 2882 2883 2884 2885
				/* High resolution needed and available? */
				if (ca_ops->flags & TCP_CONG_RTT_STAMP &&
				    !ktime_equal(last_ackt,
						 net_invalid_timestamp()))
					rtt_us = ktime_us_delta(ktime_get_real(),
								last_ackt);
2886 2887
				else if (ca_seq_rtt > 0)
					rtt_us = jiffies_to_usecs(ca_seq_rtt);
2888
			}
2889

2890 2891
			ca_ops->pkts_acked(sk, pkts_acked, rtt_us);
		}
L
Linus Torvalds 已提交
2892 2893 2894 2895 2896 2897
	}

#if FASTRETRANS_DEBUG > 0
	BUG_TRAP((int)tp->sacked_out >= 0);
	BUG_TRAP((int)tp->lost_out >= 0);
	BUG_TRAP((int)tp->retrans_out >= 0);
2898
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
2899
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2900 2901
		if (tp->lost_out) {
			printk(KERN_DEBUG "Leak l=%u %d\n",
2902
			       tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
2903 2904 2905 2906
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
			printk(KERN_DEBUG "Leak s=%u %d\n",
2907
			       tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
2908 2909 2910 2911
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
			printk(KERN_DEBUG "Leak r=%u %d\n",
2912
			       tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
2913 2914 2915 2916
			tp->retrans_out = 0;
		}
	}
#endif
2917
	return flag;
L
Linus Torvalds 已提交
2918 2919 2920 2921
}

static void tcp_ack_probe(struct sock *sk)
{
2922 2923
	const struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2924 2925 2926

	/* Was it a usable window open? */

2927
	if (!after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
2928 2929
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
2930 2931 2932 2933
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
2934
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
2935 2936
					  min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX),
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
2937 2938 2939
	}
}

2940
static inline int tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
2941 2942
{
	return (!(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
2943
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open);
L
Linus Torvalds 已提交
2944 2945
}

2946
static inline int tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
2947
{
2948
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2949
	return (!(flag & FLAG_ECE) || tp->snd_cwnd < tp->snd_ssthresh) &&
2950
		!((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR));
L
Linus Torvalds 已提交
2951 2952 2953 2954 2955
}

/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
2956 2957 2958
static inline int tcp_may_update_window(const struct tcp_sock *tp,
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
{
	return (after(ack, tp->snd_una) ||
		after(ack_seq, tp->snd_wl1) ||
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd));
}

/* Update our send window.
 *
 * Window update algorithm, described in RFC793/RFC1122 (used in linux-2.2
 * and in FreeBSD. NetBSD's one is even worse.) is wrong.
 */
2970 2971
static int tcp_ack_update_window(struct sock *sk, struct sk_buff *skb, u32 ack,
				 u32 ack_seq)
L
Linus Torvalds 已提交
2972
{
2973
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2974
	int flag = 0;
2975
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
2976

2977
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
		tcp_update_wl(tp, ack, ack_seq);

		if (tp->snd_wnd != nwin) {
			tp->snd_wnd = nwin;

			/* Note, it is the only place, where
			 * fast path is recovered for sending TCP.
			 */
2990
			tp->pred_flags = 0;
2991
			tcp_fast_path_check(sk);
L
Linus Torvalds 已提交
2992 2993 2994

			if (nwin > tp->max_window) {
				tp->max_window = nwin;
2995
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
2996 2997 2998 2999 3000 3001 3002 3003 3004
			}
		}
	}

	tp->snd_una = ack;

	return flag;
}

3005 3006 3007 3008 3009 3010
/* A very conservative spurious RTO response algorithm: reduce cwnd and
 * continue in congestion avoidance.
 */
static void tcp_conservative_spur_to_response(struct tcp_sock *tp)
{
	tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
3011
	tp->snd_cwnd_cnt = 0;
3012
	tp->bytes_acked = 0;
3013
	TCP_ECN_queue_cwr(tp);
3014 3015 3016
	tcp_moderate_cwnd(tp);
}

3017 3018 3019 3020 3021 3022 3023 3024
/* A conservative spurious RTO response algorithm: reduce cwnd using
 * rate halving and continue in congestion avoidance.
 */
static void tcp_ratehalving_spur_to_response(struct sock *sk)
{
	tcp_enter_cwr(sk, 0);
}

3025
static void tcp_undo_spur_to_response(struct sock *sk, int flag)
3026
{
3027
	if (flag & FLAG_ECE)
3028 3029 3030
		tcp_ratehalving_spur_to_response(sk);
	else
		tcp_undo_cwr(sk, 1);
3031 3032
}

3033 3034
/* F-RTO spurious RTO detection algorithm (RFC4138)
 *
3035 3036 3037
 * F-RTO affects during two new ACKs following RTO (well, almost, see inline
 * comments). State (ACK number) is kept in frto_counter. When ACK advances
 * window (but not to or beyond highest sequence sent before RTO):
3038 3039 3040 3041 3042
 *   On First ACK,  send two new segments out.
 *   On Second ACK, RTO was likely spurious. Do spurious response (response
 *                  algorithm is not part of the F-RTO detection algorithm
 *                  given in RFC4138 but can be selected separately).
 * Otherwise (basically on duplicate ACK), RTO was (likely) caused by a loss
3043 3044 3045
 * and TCP falls back to conventional RTO recovery. F-RTO allows overriding
 * of Nagle, this is done using frto_counter states 2 and 3, when a new data
 * segment of any size sent during F-RTO, state 2 is upgraded to 3.
3046 3047 3048 3049
 *
 * Rationale: if the RTO was spurious, new ACKs should arrive from the
 * original window even after we transmit two new data segments.
 *
I
Ilpo Järvinen 已提交
3050 3051 3052 3053
 * SACK version:
 *   on first step, wait until first cumulative ACK arrives, then move to
 *   the second step. In second step, the next ACK decides.
 *
3054 3055 3056 3057 3058 3059 3060 3061 3062
 * F-RTO is implemented (mainly) in four functions:
 *   - tcp_use_frto() is used to determine if TCP is can use F-RTO
 *   - tcp_enter_frto() prepares TCP state on RTO if F-RTO is used, it is
 *     called when tcp_use_frto() showed green light
 *   - tcp_process_frto() handles incoming ACKs during F-RTO algorithm
 *   - tcp_enter_frto_loss() is called if there is not enough evidence
 *     to prove that the RTO is indeed spurious. It transfers the control
 *     from F-RTO to the conventional RTO recovery
 */
3063
static int tcp_process_frto(struct sock *sk, int flag)
L
Linus Torvalds 已提交
3064 3065
{
	struct tcp_sock *tp = tcp_sk(sk);
3066

3067
	tcp_verify_left_out(tp);
3068

3069
	/* Duplicate the behavior from Loss state (fastretrans_alert) */
3070
	if (flag & FLAG_DATA_ACKED)
3071 3072
		inet_csk(sk)->icsk_retransmits = 0;

3073 3074 3075 3076
	if ((flag & FLAG_NONHEAD_RETRANS_ACKED) ||
	    ((tp->frto_counter >= 2) && (flag & FLAG_RETRANS_DATA_ACKED)))
		tp->undo_marker = 0;

3077
	if (!before(tp->snd_una, tp->frto_highmark)) {
3078
		tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 2 : 3), flag);
3079
		return 1;
3080 3081
	}

3082
	if (!IsSackFrto() || tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
3083 3084 3085 3086
		/* RFC4138 shortcoming in step 2; should also have case c):
		 * ACK isn't duplicate nor advances window, e.g., opposite dir
		 * data, winupdate
		 */
3087
		if (!(flag & FLAG_ANY_PROGRESS) && (flag & FLAG_NOT_DUP))
I
Ilpo Järvinen 已提交
3088 3089
			return 1;

3090
		if (!(flag & FLAG_DATA_ACKED)) {
I
Ilpo Järvinen 已提交
3091 3092 3093 3094 3095
			tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 0 : 3),
					    flag);
			return 1;
		}
	} else {
3096
		if (!(flag & FLAG_DATA_ACKED) && (tp->frto_counter == 1)) {
I
Ilpo Järvinen 已提交
3097 3098 3099 3100 3101
			/* Prevent sending of new data. */
			tp->snd_cwnd = min(tp->snd_cwnd,
					   tcp_packets_in_flight(tp));
			return 1;
		}
3102

3103
		if ((tp->frto_counter >= 2) &&
3104 3105 3106
		    (!(flag & FLAG_FORWARD_PROGRESS) ||
		     ((flag & FLAG_DATA_SACKED) &&
		      !(flag & FLAG_ONLY_ORIG_SACKED)))) {
I
Ilpo Järvinen 已提交
3107
			/* RFC4138 shortcoming (see comment above) */
3108 3109
			if (!(flag & FLAG_FORWARD_PROGRESS) &&
			    (flag & FLAG_NOT_DUP))
I
Ilpo Järvinen 已提交
3110 3111 3112 3113 3114
				return 1;

			tcp_enter_frto_loss(sk, 3, flag);
			return 1;
		}
L
Linus Torvalds 已提交
3115 3116 3117
	}

	if (tp->frto_counter == 1) {
3118
		/* tcp_may_send_now needs to see updated state */
L
Linus Torvalds 已提交
3119
		tp->snd_cwnd = tcp_packets_in_flight(tp) + 2;
3120
		tp->frto_counter = 2;
3121 3122 3123 3124

		if (!tcp_may_send_now(sk))
			tcp_enter_frto_loss(sk, 2, flag);

3125
		return 1;
3126
	} else {
3127 3128
		switch (sysctl_tcp_frto_response) {
		case 2:
3129
			tcp_undo_spur_to_response(sk, flag);
3130 3131 3132 3133 3134 3135 3136
			break;
		case 1:
			tcp_conservative_spur_to_response(tp);
			break;
		default:
			tcp_ratehalving_spur_to_response(sk);
			break;
3137
		}
3138
		tp->frto_counter = 0;
3139
		tp->undo_marker = 0;
3140
		NET_INC_STATS_BH(LINUX_MIB_TCPSPURIOUSRTOS);
L
Linus Torvalds 已提交
3141
	}
3142
	return 0;
L
Linus Torvalds 已提交
3143 3144 3145 3146 3147
}

/* This routine deals with incoming acks, but not outgoing ones. */
static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
{
3148
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3149 3150 3151 3152 3153
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_snd_una = tp->snd_una;
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
	u32 prior_in_flight;
3154
	u32 prior_fackets;
L
Linus Torvalds 已提交
3155
	int prior_packets;
3156
	int frto_cwnd = 0;
L
Linus Torvalds 已提交
3157 3158 3159 3160 3161 3162 3163 3164 3165 3166

	/* If the ack is newer than sent or older than previous acks
	 * then we can probably ignore it.
	 */
	if (after(ack, tp->snd_nxt))
		goto uninteresting_ack;

	if (before(ack, prior_snd_una))
		goto old_ack;

3167 3168 3169
	if (after(ack, prior_snd_una))
		flag |= FLAG_SND_UNA_ADVANCED;

3170 3171 3172 3173 3174
	if (sysctl_tcp_abc) {
		if (icsk->icsk_ca_state < TCP_CA_CWR)
			tp->bytes_acked += ack - prior_snd_una;
		else if (icsk->icsk_ca_state == TCP_CA_Loss)
			/* we assume just one segment left network */
3175 3176
			tp->bytes_acked += min(ack - prior_snd_una,
					       tp->mss_cache);
3177
	}
3178

3179
	prior_fackets = tp->fackets_out;
3180
	prior_in_flight = tcp_packets_in_flight(tp);
3181

3182
	if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
L
Linus Torvalds 已提交
3183 3184 3185 3186 3187 3188 3189 3190
		/* Window is constant, pure forward advance.
		 * No more checks are required.
		 * Note, we use the fact that SND.UNA>=SND.WL2.
		 */
		tcp_update_wl(tp, ack, ack_seq);
		tp->snd_una = ack;
		flag |= FLAG_WIN_UPDATE;

3191
		tcp_ca_event(sk, CA_EVENT_FAST_ACK);
3192

L
Linus Torvalds 已提交
3193 3194 3195 3196 3197 3198 3199
		NET_INC_STATS_BH(LINUX_MIB_TCPHPACKS);
	} else {
		if (ack_seq != TCP_SKB_CB(skb)->end_seq)
			flag |= FLAG_DATA;
		else
			NET_INC_STATS_BH(LINUX_MIB_TCPPUREACKS);

3200
		flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
L
Linus Torvalds 已提交
3201 3202 3203 3204

		if (TCP_SKB_CB(skb)->sacked)
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una);

3205
		if (TCP_ECN_rcv_ecn_echo(tp, tcp_hdr(skb)))
L
Linus Torvalds 已提交
3206 3207
			flag |= FLAG_ECE;

3208
		tcp_ca_event(sk, CA_EVENT_SLOW_ACK);
L
Linus Torvalds 已提交
3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
	}

	/* We passed data and got it acked, remove any soft error
	 * log. Something worked...
	 */
	sk->sk_err_soft = 0;
	tp->rcv_tstamp = tcp_time_stamp;
	prior_packets = tp->packets_out;
	if (!prior_packets)
		goto no_queue;

	/* See if we can take anything off of the retransmit queue. */
3221
	flag |= tcp_clean_rtx_queue(sk, prior_fackets);
L
Linus Torvalds 已提交
3222

3223 3224
	if (tp->frto_counter)
		frto_cwnd = tcp_process_frto(sk, flag);
3225 3226 3227
	/* Guarantee sacktag reordering detection against wrap-arounds */
	if (before(tp->frto_highmark, tp->snd_una))
		tp->frto_highmark = 0;
L
Linus Torvalds 已提交
3228

3229
	if (tcp_ack_is_dubious(sk, flag)) {
S
Stephen Hemminger 已提交
3230
		/* Advance CWND, if state allows this. */
3231 3232
		if ((flag & FLAG_DATA_ACKED) && !frto_cwnd &&
		    tcp_may_raise_cwnd(sk, flag))
3233
			tcp_cong_avoid(sk, ack, prior_in_flight);
3234 3235
		tcp_fastretrans_alert(sk, prior_packets - tp->packets_out,
				      flag);
L
Linus Torvalds 已提交
3236
	} else {
3237
		if ((flag & FLAG_DATA_ACKED) && !frto_cwnd)
3238
			tcp_cong_avoid(sk, ack, prior_in_flight);
L
Linus Torvalds 已提交
3239 3240
	}

3241
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
L
Linus Torvalds 已提交
3242 3243 3244 3245 3246
		dst_confirm(sk->sk_dst_cache);

	return 1;

no_queue:
3247
	icsk->icsk_probes_out = 0;
L
Linus Torvalds 已提交
3248 3249 3250 3251 3252

	/* If this ack opens up a zero window, clear backoff.  It was
	 * being used to time the probes, and is probably far higher than
	 * it needs to be for normal retransmission.
	 */
3253
	if (tcp_send_head(sk))
L
Linus Torvalds 已提交
3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
		tcp_ack_probe(sk);
	return 1;

old_ack:
	if (TCP_SKB_CB(skb)->sacked)
		tcp_sacktag_write_queue(sk, skb, prior_snd_una);

uninteresting_ack:
	SOCK_DEBUG(sk, "Ack %u out of %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return 0;
}

/* Look for tcp options. Normally only called on SYN and SYNACK packets.
 * But, this can also be called on packets in the established flow when
 * the fast version below fails.
 */
3270 3271
void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
		       int estab)
L
Linus Torvalds 已提交
3272 3273
{
	unsigned char *ptr;
3274
	struct tcphdr *th = tcp_hdr(skb);
3275
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3276 3277 3278 3279

	ptr = (unsigned char *)(th + 1);
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3280
	while (length > 0) {
3281
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3282 3283 3284
		int opsize;

		switch (opcode) {
3285 3286 3287 3288 3289 3290 3291 3292
		case TCPOPT_EOL:
			return;
		case TCPOPT_NOP:	/* Ref: RFC 793 section 3.1 */
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2) /* "silly options" */
L
Linus Torvalds 已提交
3293
				return;
3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
					u16 in_mss = ntohs(get_unaligned((__be16 *)ptr));
					if (in_mss) {
						if (opt_rx->user_mss &&
						    opt_rx->user_mss < in_mss)
							in_mss = opt_rx->user_mss;
						opt_rx->mss_clamp = in_mss;
L
Linus Torvalds 已提交
3305
					}
3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
				    !estab && sysctl_tcp_window_scaling) {
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
					if (snd_wscale > 14) {
						if (net_ratelimit())
							printk(KERN_INFO "tcp_parse_options: Illegal window "
							       "scaling value %d >14 received.\n",
							       snd_wscale);
						snd_wscale = 14;
L
Linus Torvalds 已提交
3319
					}
3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
				     (!estab && sysctl_tcp_timestamps))) {
					opt_rx->saw_tstamp = 1;
					opt_rx->rcv_tsval = ntohl(get_unaligned((__be32 *)ptr));
					opt_rx->rcv_tsecr = ntohl(get_unaligned((__be32 *)(ptr+4)));
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
				    !estab && sysctl_tcp_sack) {
					opt_rx->sack_ok = 1;
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3339

3340 3341 3342 3343 3344 3345 3346
			case TCPOPT_SACK:
				if ((opsize >= (TCPOLEN_SACK_BASE + TCPOLEN_SACK_PERBLOCK)) &&
				   !((opsize - TCPOLEN_SACK_BASE) % TCPOLEN_SACK_PERBLOCK) &&
				   opt_rx->sack_ok) {
					TCP_SKB_CB(skb)->sacked = (ptr - 2) - (unsigned char *)th;
				}
				break;
3347
#ifdef CONFIG_TCP_MD5SIG
3348 3349 3350 3351 3352 3353
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3354
#endif
3355
			}
3356

3357 3358
			ptr += opsize-2;
			length -= opsize;
3359
		}
L
Linus Torvalds 已提交
3360 3361 3362 3363 3364 3365
	}
}

/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
S
Stephen Hemminger 已提交
3366 3367
static int tcp_fast_parse_options(struct sk_buff *skb, struct tcphdr *th,
				  struct tcp_sock *tp)
L
Linus Torvalds 已提交
3368
{
3369
	if (th->doff == sizeof(struct tcphdr) >> 2) {
L
Linus Torvalds 已提交
3370 3371 3372 3373
		tp->rx_opt.saw_tstamp = 0;
		return 0;
	} else if (tp->rx_opt.tstamp_ok &&
		   th->doff == (sizeof(struct tcphdr)>>2)+(TCPOLEN_TSTAMP_ALIGNED>>2)) {
3374 3375
		__be32 *ptr = (__be32 *)(th + 1);
		if (*ptr == htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
L
Linus Torvalds 已提交
3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
				  | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP)) {
			tp->rx_opt.saw_tstamp = 1;
			++ptr;
			tp->rx_opt.rcv_tsval = ntohl(*ptr);
			++ptr;
			tp->rx_opt.rcv_tsecr = ntohl(*ptr);
			return 1;
		}
	}
	tcp_parse_options(skb, &tp->rx_opt, 1);
	return 1;
}

static inline void tcp_store_ts_recent(struct tcp_sock *tp)
{
	tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
3392
	tp->rx_opt.ts_recent_stamp = get_seconds();
L
Linus Torvalds 已提交
3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404
}

static inline void tcp_replace_ts_recent(struct tcp_sock *tp, u32 seq)
{
	if (tp->rx_opt.saw_tstamp && !after(seq, tp->rcv_wup)) {
		/* PAWS bug workaround wrt. ACK frames, the PAWS discard
		 * extra check below makes sure this can only happen
		 * for pure ACK frames.  -DaveM
		 *
		 * Not only, also it occurs for expired timestamps.
		 */

S
Stephen Hemminger 已提交
3405
		if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) >= 0 ||
3406
		   get_seconds() >= tp->rx_opt.ts_recent_stamp + TCP_PAWS_24DAYS)
L
Linus Torvalds 已提交
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433
			tcp_store_ts_recent(tp);
	}
}

/* Sorry, PAWS as specified is broken wrt. pure-ACKs -DaveM
 *
 * It is not fatal. If this ACK does _not_ change critical state (seqs, window)
 * it can pass through stack. So, the following predicate verifies that
 * this segment is not used for anything but congestion avoidance or
 * fast retransmit. Moreover, we even are able to eliminate most of such
 * second order effects, if we apply some small "replay" window (~RTO)
 * to timestamp space.
 *
 * All these measures still do not guarantee that we reject wrapped ACKs
 * on networks with high bandwidth, when sequence space is recycled fastly,
 * but it guarantees that such events will be very rare and do not affect
 * connection seriously. This doesn't look nice, but alas, PAWS is really
 * buggy extension.
 *
 * [ Later note. Even worse! It is buggy for segments _with_ data. RFC
 * states that events when retransmit arrives after original data are rare.
 * It is a blatant lie. VJ forgot about fast retransmit! 8)8) It is
 * the biggest problem on large power networks even with minor reordering.
 * OK, let's give it small replay window. If peer clock is even 1hz, it is safe
 * up to bandwidth of 18Gigabit/sec. 8) ]
 */

3434
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3435
{
3436
	struct tcp_sock *tp = tcp_sk(sk);
3437
	struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
	u32 seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;

	return (/* 1. Pure ACK with correct sequence number. */
		(th->ack && seq == TCP_SKB_CB(skb)->end_seq && seq == tp->rcv_nxt) &&

		/* 2. ... and duplicate ACK. */
		ack == tp->snd_una &&

		/* 3. ... and does not update window. */
		!tcp_may_update_window(tp, ack, seq, ntohs(th->window) << tp->rx_opt.snd_wscale) &&

		/* 4. ... and sits in replay window. */
3451
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
3452 3453
}

3454 3455
static inline int tcp_paws_discard(const struct sock *sk,
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
3456
{
3457
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3458
	return ((s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) > TCP_PAWS_WINDOW &&
3459
		get_seconds() < tp->rx_opt.ts_recent_stamp + TCP_PAWS_24DAYS &&
3460
		!tcp_disordered_ack(sk, skb));
L
Linus Torvalds 已提交
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486
}

/* Check segment sequence number for validity.
 *
 * Segment controls are considered valid, if the segment
 * fits to the window after truncation to the window. Acceptability
 * of data (and SYN, FIN, of course) is checked separately.
 * See tcp_data_queue(), for example.
 *
 * Also, controls (RST is main one) are accepted using RCV.WUP instead
 * of RCV.NXT. Peer still did not advance his SND.UNA when we
 * delayed ACK, so that hisSND.UNA<=ourRCV.WUP.
 * (borrowed from freebsd)
 */

static inline int tcp_sequence(struct tcp_sock *tp, u32 seq, u32 end_seq)
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
static void tcp_reset(struct sock *sk)
{
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
3487 3488 3489 3490 3491 3492 3493 3494 3495 3496
	case TCP_SYN_SENT:
		sk->sk_err = ECONNREFUSED;
		break;
	case TCP_CLOSE_WAIT:
		sk->sk_err = EPIPE;
		break;
	case TCP_CLOSE:
		return;
	default:
		sk->sk_err = ECONNRESET;
L
Linus Torvalds 已提交
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522
	}

	if (!sock_flag(sk, SOCK_DEAD))
		sk->sk_error_report(sk);

	tcp_done(sk);
}

/*
 * 	Process the FIN bit. This now behaves as it is supposed to work
 *	and the FIN takes effect when it is validly part of sequence
 *	space. Not before when we get holes.
 *
 *	If we are ESTABLISHED, a received fin moves us to CLOSE-WAIT
 *	(and thence onto LAST-ACK and finally, CLOSE, we never enter
 *	TIME-WAIT)
 *
 *	If we are in FINWAIT-1, a received FIN indicates simultaneous
 *	close and we go into CLOSING (and later onto TIME-WAIT)
 *
 *	If we are in FINWAIT-2, a received FIN moves us to TIME-WAIT.
 */
static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
{
	struct tcp_sock *tp = tcp_sk(sk);

3523
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
3524 3525 3526 3527 3528

	sk->sk_shutdown |= RCV_SHUTDOWN;
	sock_set_flag(sk, SOCK_DONE);

	switch (sk->sk_state) {
3529 3530 3531 3532 3533 3534
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
		inet_csk(sk)->icsk_ack.pingpong = 1;
		break;
L
Linus Torvalds 已提交
3535

3536 3537 3538 3539 3540 3541 3542 3543 3544
	case TCP_CLOSE_WAIT:
	case TCP_CLOSING:
		/* Received a retransmission of the FIN, do
		 * nothing.
		 */
		break;
	case TCP_LAST_ACK:
		/* RFC793: Remain in the LAST-ACK state. */
		break;
L
Linus Torvalds 已提交
3545

3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
	case TCP_FIN_WAIT1:
		/* This case occurs when a simultaneous close
		 * happens, we must ack the received FIN and
		 * enter the CLOSING state.
		 */
		tcp_send_ack(sk);
		tcp_set_state(sk, TCP_CLOSING);
		break;
	case TCP_FIN_WAIT2:
		/* Received a FIN -- send ACK and enter TIME_WAIT. */
		tcp_send_ack(sk);
		tcp_time_wait(sk, TCP_TIME_WAIT, 0);
		break;
	default:
		/* Only TCP_LISTEN and TCP_CLOSE are left, in these
		 * cases we should never reach this piece of code.
		 */
		printk(KERN_ERR "%s: Impossible, sk->sk_state=%d\n",
		       __FUNCTION__, sk->sk_state);
		break;
3566
	}
L
Linus Torvalds 已提交
3567 3568 3569 3570 3571

	/* It _is_ possible, that we have something out-of-order _after_ FIN.
	 * Probably, we should reset in this case. For now drop them.
	 */
	__skb_queue_purge(&tp->out_of_order_queue);
3572
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
3573
		tcp_sack_reset(&tp->rx_opt);
3574
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
3575 3576 3577 3578 3579 3580 3581

	if (!sock_flag(sk, SOCK_DEAD)) {
		sk->sk_state_change(sk);

		/* Do not send POLL_HUP for half duplex close. */
		if (sk->sk_shutdown == SHUTDOWN_MASK ||
		    sk->sk_state == TCP_CLOSE)
3582
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
3583
		else
3584
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
3585 3586 3587
	}
}

3588 3589
static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
				  u32 end_seq)
L
Linus Torvalds 已提交
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600
{
	if (!after(seq, sp->end_seq) && !after(sp->start_seq, end_seq)) {
		if (before(seq, sp->start_seq))
			sp->start_seq = seq;
		if (after(end_seq, sp->end_seq))
			sp->end_seq = end_seq;
		return 1;
	}
	return 0;
}

S
Stephen Hemminger 已提交
3601
static void tcp_dsack_set(struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
3602
{
3603
	if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
3604 3605 3606 3607 3608 3609 3610 3611
		if (before(seq, tp->rcv_nxt))
			NET_INC_STATS_BH(LINUX_MIB_TCPDSACKOLDSENT);
		else
			NET_INC_STATS_BH(LINUX_MIB_TCPDSACKOFOSENT);

		tp->rx_opt.dsack = 1;
		tp->duplicate_sack[0].start_seq = seq;
		tp->duplicate_sack[0].end_seq = end_seq;
3612 3613
		tp->rx_opt.eff_sacks = min(tp->rx_opt.num_sacks + 1,
					   4 - tp->rx_opt.tstamp_ok);
L
Linus Torvalds 已提交
3614 3615 3616
	}
}

S
Stephen Hemminger 已提交
3617
static void tcp_dsack_extend(struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631
{
	if (!tp->rx_opt.dsack)
		tcp_dsack_set(tp, seq, end_seq);
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

static void tcp_send_dupack(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);

	if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
	    before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
		NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOST);
3632
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
3633

3634
		if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652
			u32 end_seq = TCP_SKB_CB(skb)->end_seq;

			if (after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))
				end_seq = tp->rcv_nxt;
			tcp_dsack_set(tp, TCP_SKB_CB(skb)->seq, end_seq);
		}
	}

	tcp_send_ack(sk);
}

/* These routines update the SACK block as out-of-order packets arrive or
 * in-order packets close up the sequence space.
 */
static void tcp_sack_maybe_coalesce(struct tcp_sock *tp)
{
	int this_sack;
	struct tcp_sack_block *sp = &tp->selective_acks[0];
3653
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
3654 3655 3656 3657

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
3658
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
3659 3660 3661 3662 3663 3664 3665
		if (tcp_sack_extend(sp, swalk->start_seq, swalk->end_seq)) {
			int i;

			/* Zap SWALK, by moving every further SACK up by one slot.
			 * Decrease num_sacks.
			 */
			tp->rx_opt.num_sacks--;
3666 3667 3668 3669 3670
			tp->rx_opt.eff_sacks = min(tp->rx_opt.num_sacks +
						   tp->rx_opt.dsack,
						   4 - tp->rx_opt.tstamp_ok);
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
3671 3672 3673 3674 3675 3676
			continue;
		}
		this_sack++, swalk++;
	}
}

3677 3678
static inline void tcp_sack_swap(struct tcp_sack_block *sack1,
				 struct tcp_sack_block *sack2)
L
Linus Torvalds 已提交
3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700
{
	__u32 tmp;

	tmp = sack1->start_seq;
	sack1->start_seq = sack2->start_seq;
	sack2->start_seq = tmp;

	tmp = sack1->end_seq;
	sack1->end_seq = sack2->end_seq;
	sack2->end_seq = tmp;
}

static void tcp_sack_new_ofo_skb(struct sock *sk, u32 seq, u32 end_seq)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct tcp_sack_block *sp = &tp->selective_acks[0];
	int cur_sacks = tp->rx_opt.num_sacks;
	int this_sack;

	if (!cur_sacks)
		goto new_sack;

3701
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
3702 3703
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
3704 3705
			for (; this_sack > 0; this_sack--, sp--)
				tcp_sack_swap(sp, sp - 1);
L
Linus Torvalds 已提交
3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722
			if (cur_sacks > 1)
				tcp_sack_maybe_coalesce(tp);
			return;
		}
	}

	/* Could not find an adjacent existing SACK, build a new one,
	 * put it at the front, and shift everyone else down.  We
	 * always know there is at least one SACK present already here.
	 *
	 * If the sack array is full, forget about the last one.
	 */
	if (this_sack >= 4) {
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
3723
	for (; this_sack > 0; this_sack--, sp--)
3724
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
3725 3726 3727 3728 3729 3730

new_sack:
	/* Build the new head SACK, and we're done. */
	sp->start_seq = seq;
	sp->end_seq = end_seq;
	tp->rx_opt.num_sacks++;
3731 3732
	tp->rx_opt.eff_sacks = min(tp->rx_opt.num_sacks + tp->rx_opt.dsack,
				   4 - tp->rx_opt.tstamp_ok);
L
Linus Torvalds 已提交
3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743
}

/* RCV.NXT advances, some SACKs should be eaten. */

static void tcp_sack_remove(struct tcp_sock *tp)
{
	struct tcp_sack_block *sp = &tp->selective_acks[0];
	int num_sacks = tp->rx_opt.num_sacks;
	int this_sack;

	/* Empty ofo queue, hence, all the SACKs are eaten. Clear. */
3744
	if (skb_queue_empty(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
3745 3746 3747 3748 3749
		tp->rx_opt.num_sacks = 0;
		tp->rx_opt.eff_sacks = tp->rx_opt.dsack;
		return;
	}

3750
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768
		/* Check if the start of the sack is covered by RCV.NXT. */
		if (!before(tp->rcv_nxt, sp->start_seq)) {
			int i;

			/* RCV.NXT must cover all the block! */
			BUG_TRAP(!before(tp->rcv_nxt, sp->end_seq));

			/* Zap this SACK, by moving forward any other SACKS. */
			for (i=this_sack+1; i < num_sacks; i++)
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
	if (num_sacks != tp->rx_opt.num_sacks) {
		tp->rx_opt.num_sacks = num_sacks;
3769 3770 3771
		tp->rx_opt.eff_sacks = min(tp->rx_opt.num_sacks +
					   tp->rx_opt.dsack,
					   4 - tp->rx_opt.tstamp_ok);
L
Linus Torvalds 已提交
3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
	}
}

/* This one checks to see if we can put data from the
 * out_of_order queue into the receive_queue.
 */
static void tcp_ofo_queue(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	__u32 dsack_high = tp->rcv_nxt;
	struct sk_buff *skb;

	while ((skb = skb_peek(&tp->out_of_order_queue)) != NULL) {
		if (after(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
			break;

		if (before(TCP_SKB_CB(skb)->seq, dsack_high)) {
			__u32 dsack = dsack_high;
			if (before(TCP_SKB_CB(skb)->end_seq, dsack_high))
				dsack_high = TCP_SKB_CB(skb)->end_seq;
			tcp_dsack_extend(tp, TCP_SKB_CB(skb)->seq, dsack);
		}

		if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
			SOCK_DEBUG(sk, "ofo packet was already received \n");
D
David S. Miller 已提交
3797
			__skb_unlink(skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
3798 3799 3800 3801 3802 3803 3804
			__kfree_skb(skb);
			continue;
		}
		SOCK_DEBUG(sk, "ofo requeuing : rcv_next %X seq %X - %X\n",
			   tp->rcv_nxt, TCP_SKB_CB(skb)->seq,
			   TCP_SKB_CB(skb)->end_seq);

D
David S. Miller 已提交
3805
		__skb_unlink(skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
3806 3807
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
3808 3809
		if (tcp_hdr(skb)->fin)
			tcp_fin(skb, sk, tcp_hdr(skb));
L
Linus Torvalds 已提交
3810 3811 3812 3813 3814 3815 3816
	}
}

static int tcp_prune_queue(struct sock *sk);

static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
3817
	struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3818 3819 3820 3821 3822 3823
	struct tcp_sock *tp = tcp_sk(sk);
	int eaten = -1;

	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq)
		goto drop;

3824
	__skb_pull(skb, th->doff * 4);
L
Linus Torvalds 已提交
3825 3826 3827 3828 3829 3830

	TCP_ECN_accept_cwr(tp, skb);

	if (tp->rx_opt.dsack) {
		tp->rx_opt.dsack = 0;
		tp->rx_opt.eff_sacks = min_t(unsigned int, tp->rx_opt.num_sacks,
3831
					     4 - tp->rx_opt.tstamp_ok);
L
Linus Torvalds 已提交
3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846
	}

	/*  Queue data for delivery to the user.
	 *  Packets in sequence go to the receive queue.
	 *  Out of sequence packets to the out_of_order_queue.
	 */
	if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
		if (tcp_receive_window(tp) == 0)
			goto out_of_window;

		/* Ok. In sequence. In window. */
		if (tp->ucopy.task == current &&
		    tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&
		    sock_owned_by_user(sk) && !tp->urg_data) {
			int chunk = min_t(unsigned int, skb->len,
3847
					  tp->ucopy.len);
L
Linus Torvalds 已提交
3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864

			__set_current_state(TASK_RUNNING);

			local_bh_enable();
			if (!skb_copy_datagram_iovec(skb, 0, tp->ucopy.iov, chunk)) {
				tp->ucopy.len -= chunk;
				tp->copied_seq += chunk;
				eaten = (chunk == skb->len && !th->fin);
				tcp_rcv_space_adjust(sk);
			}
			local_bh_disable();
		}

		if (eaten <= 0) {
queue_and_out:
			if (eaten < 0 &&
			    (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
3865
			     !sk_rmem_schedule(sk, skb->truesize))) {
L
Linus Torvalds 已提交
3866
				if (tcp_prune_queue(sk) < 0 ||
3867
				    !sk_rmem_schedule(sk, skb->truesize))
L
Linus Torvalds 已提交
3868 3869
					goto drop;
			}
3870
			skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
3871 3872 3873
			__skb_queue_tail(&sk->sk_receive_queue, skb);
		}
		tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
S
Stephen Hemminger 已提交
3874
		if (skb->len)
3875
			tcp_event_data_recv(sk, skb);
S
Stephen Hemminger 已提交
3876
		if (th->fin)
L
Linus Torvalds 已提交
3877 3878
			tcp_fin(skb, sk, th);

3879
		if (!skb_queue_empty(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
3880 3881 3882 3883 3884
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
3885
			if (skb_queue_empty(&tp->out_of_order_queue))
3886
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
3887 3888 3889 3890 3891
		}

		if (tp->rx_opt.num_sacks)
			tcp_sack_remove(tp);

3892
		tcp_fast_path_check(sk);
L
Linus Torvalds 已提交
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906

		if (eaten > 0)
			__kfree_skb(skb);
		else if (!sock_flag(sk, SOCK_DEAD))
			sk->sk_data_ready(sk, 0);
		return;
	}

	if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
		/* A retransmit, 2nd most common case.  Force an immediate ack. */
		NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOST);
		tcp_dsack_set(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);

out_of_window:
3907 3908
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
3909 3910 3911 3912 3913 3914 3915 3916 3917
drop:
		__kfree_skb(skb);
		return;
	}

	/* Out of window. F.e. zero window probe. */
	if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp)))
		goto out_of_window;

3918
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
3919 3920 3921 3922 3923 3924 3925 3926

	if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
		/* Partial packet, seq < rcv_next < end_seq */
		SOCK_DEBUG(sk, "partial packet: rcv_next %X seq %X - %X\n",
			   tp->rcv_nxt, TCP_SKB_CB(skb)->seq,
			   TCP_SKB_CB(skb)->end_seq);

		tcp_dsack_set(tp, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
3927

L
Linus Torvalds 已提交
3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938
		/* If window is closed, drop tail of packet. But after
		 * remembering D-SACK for its head made in previous line.
		 */
		if (!tcp_receive_window(tp))
			goto out_of_window;
		goto queue_and_out;
	}

	TCP_ECN_check_ce(tp, skb);

	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
3939
	    !sk_rmem_schedule(sk, skb->truesize)) {
L
Linus Torvalds 已提交
3940
		if (tcp_prune_queue(sk) < 0 ||
3941
		    !sk_rmem_schedule(sk, skb->truesize))
L
Linus Torvalds 已提交
3942 3943 3944 3945 3946
			goto drop;
	}

	/* Disable header prediction. */
	tp->pred_flags = 0;
3947
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
3948 3949 3950 3951

	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
		   tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);

3952
	skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
3953 3954 3955

	if (!skb_peek(&tp->out_of_order_queue)) {
		/* Initial out of order segment, build 1 SACK. */
3956
		if (tcp_is_sack(tp)) {
L
Linus Torvalds 已提交
3957 3958 3959 3960 3961 3962 3963
			tp->rx_opt.num_sacks = 1;
			tp->rx_opt.dsack     = 0;
			tp->rx_opt.eff_sacks = 1;
			tp->selective_acks[0].start_seq = TCP_SKB_CB(skb)->seq;
			tp->selective_acks[0].end_seq =
						TCP_SKB_CB(skb)->end_seq;
		}
3964
		__skb_queue_head(&tp->out_of_order_queue, skb);
L
Linus Torvalds 已提交
3965 3966 3967 3968 3969 3970
	} else {
		struct sk_buff *skb1 = tp->out_of_order_queue.prev;
		u32 seq = TCP_SKB_CB(skb)->seq;
		u32 end_seq = TCP_SKB_CB(skb)->end_seq;

		if (seq == TCP_SKB_CB(skb1)->end_seq) {
D
David S. Miller 已提交
3971
			__skb_append(skb1, skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986

			if (!tp->rx_opt.num_sacks ||
			    tp->selective_acks[0].end_seq != seq)
				goto add_sack;

			/* Common case: data arrive in order after hole. */
			tp->selective_acks[0].end_seq = end_seq;
			return;
		}

		/* Find place to insert this segment. */
		do {
			if (!after(TCP_SKB_CB(skb1)->seq, seq))
				break;
		} while ((skb1 = skb1->prev) !=
3987
			 (struct sk_buff *)&tp->out_of_order_queue);
L
Linus Torvalds 已提交
3988 3989

		/* Do skb overlap to previous one? */
3990
		if (skb1 != (struct sk_buff *)&tp->out_of_order_queue &&
L
Linus Torvalds 已提交
3991 3992 3993 3994 3995 3996 3997 3998 3999
		    before(seq, TCP_SKB_CB(skb1)->end_seq)) {
			if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
				/* All the bits are present. Drop. */
				__kfree_skb(skb);
				tcp_dsack_set(tp, seq, end_seq);
				goto add_sack;
			}
			if (after(seq, TCP_SKB_CB(skb1)->seq)) {
				/* Partial overlap. */
4000 4001
				tcp_dsack_set(tp, seq,
					      TCP_SKB_CB(skb1)->end_seq);
L
Linus Torvalds 已提交
4002 4003 4004 4005 4006
			} else {
				skb1 = skb1->prev;
			}
		}
		__skb_insert(skb, skb1, skb1->next, &tp->out_of_order_queue);
4007

L
Linus Torvalds 已提交
4008 4009
		/* And clean segments covered by new one as whole. */
		while ((skb1 = skb->next) !=
4010
		       (struct sk_buff *)&tp->out_of_order_queue &&
L
Linus Torvalds 已提交
4011
		       after(end_seq, TCP_SKB_CB(skb1)->seq)) {
4012 4013 4014 4015 4016 4017 4018 4019 4020
			if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
				tcp_dsack_extend(tp, TCP_SKB_CB(skb1)->seq,
						 end_seq);
				break;
			}
			__skb_unlink(skb1, &tp->out_of_order_queue);
			tcp_dsack_extend(tp, TCP_SKB_CB(skb1)->seq,
					 TCP_SKB_CB(skb1)->end_seq);
			__kfree_skb(skb1);
L
Linus Torvalds 已提交
4021 4022 4023
		}

add_sack:
4024
		if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
			tcp_sack_new_ofo_skb(sk, seq, end_seq);
	}
}

/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
D
David S. Miller 已提交
4035 4036 4037
tcp_collapse(struct sock *sk, struct sk_buff_head *list,
	     struct sk_buff *head, struct sk_buff *tail,
	     u32 start, u32 end)
L
Linus Torvalds 已提交
4038 4039 4040
{
	struct sk_buff *skb;

S
Stephen Hemminger 已提交
4041
	/* First, check that queue is collapsible and find
L
Linus Torvalds 已提交
4042
	 * the point where collapsing can be useful. */
4043
	for (skb = head; skb != tail;) {
L
Linus Torvalds 已提交
4044 4045 4046
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
			struct sk_buff *next = skb->next;
D
David S. Miller 已提交
4047
			__skb_unlink(skb, list);
L
Linus Torvalds 已提交
4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
			__kfree_skb(skb);
			NET_INC_STATS_BH(LINUX_MIB_TCPRCVCOLLAPSED);
			skb = next;
			continue;
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4059
		if (!tcp_hdr(skb)->syn && !tcp_hdr(skb)->fin &&
L
Linus Torvalds 已提交
4060 4061 4062 4063 4064 4065 4066 4067 4068 4069
		    (tcp_win_from_space(skb->truesize) > skb->len ||
		     before(TCP_SKB_CB(skb)->seq, start) ||
		     (skb->next != tail &&
		      TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb->next)->seq)))
			break;

		/* Decided to skip this, advance start seq. */
		start = TCP_SKB_CB(skb)->end_seq;
		skb = skb->next;
	}
4070
	if (skb == tail || tcp_hdr(skb)->syn || tcp_hdr(skb)->fin)
L
Linus Torvalds 已提交
4071 4072 4073 4074
		return;

	while (before(start, end)) {
		struct sk_buff *nskb;
4075
		unsigned int header = skb_headroom(skb);
L
Linus Torvalds 已提交
4076 4077 4078 4079 4080
		int copy = SKB_MAX_ORDER(header, 0);

		/* Too big header? This can happen with IPv6. */
		if (copy < 0)
			return;
4081 4082 4083
		if (end - start < copy)
			copy = end - start;
		nskb = alloc_skb(copy + header, GFP_ATOMIC);
L
Linus Torvalds 已提交
4084 4085
		if (!nskb)
			return;
4086

4087
		skb_set_mac_header(nskb, skb_mac_header(skb) - skb->head);
4088 4089 4090 4091
		skb_set_network_header(nskb, (skb_network_header(skb) -
					      skb->head));
		skb_set_transport_header(nskb, (skb_transport_header(skb) -
						skb->head));
L
Linus Torvalds 已提交
4092 4093 4094 4095
		skb_reserve(nskb, header);
		memcpy(nskb->head, skb->head, header);
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
D
David S. Miller 已提交
4096
		__skb_insert(nskb, skb->prev, skb, list);
4097
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4098 4099 4100 4101 4102 4103

		/* Copy data, releasing collapsed skbs. */
		while (copy > 0) {
			int offset = start - TCP_SKB_CB(skb)->seq;
			int size = TCP_SKB_CB(skb)->end_seq - start;

4104
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4105 4106 4107 4108 4109 4110 4111 4112 4113 4114
			if (size > 0) {
				size = min(copy, size);
				if (skb_copy_bits(skb, offset, skb_put(nskb, size), size))
					BUG();
				TCP_SKB_CB(nskb)->end_seq += size;
				copy -= size;
				start += size;
			}
			if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
				struct sk_buff *next = skb->next;
D
David S. Miller 已提交
4115
				__skb_unlink(skb, list);
L
Linus Torvalds 已提交
4116 4117 4118
				__kfree_skb(skb);
				NET_INC_STATS_BH(LINUX_MIB_TCPRCVCOLLAPSED);
				skb = next;
4119 4120 4121
				if (skb == tail ||
				    tcp_hdr(skb)->syn ||
				    tcp_hdr(skb)->fin)
L
Linus Torvalds 已提交
4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152
					return;
			}
		}
	}
}

/* Collapse ofo queue. Algorithm: select contiguous sequence of skbs
 * and tcp_collapse() them until all the queue is collapsed.
 */
static void tcp_collapse_ofo_queue(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb = skb_peek(&tp->out_of_order_queue);
	struct sk_buff *head;
	u32 start, end;

	if (skb == NULL)
		return;

	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
	head = skb;

	for (;;) {
		skb = skb->next;

		/* Segment is terminated when we see gap or when
		 * we are at the end of all the queue. */
		if (skb == (struct sk_buff *)&tp->out_of_order_queue ||
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
D
David S. Miller 已提交
4153 4154
			tcp_collapse(sk, &tp->out_of_order_queue,
				     head, skb, start, end);
L
Linus Torvalds 已提交
4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178
			head = skb;
			if (skb == (struct sk_buff *)&tp->out_of_order_queue)
				break;
			/* Start new segment */
			start = TCP_SKB_CB(skb)->seq;
			end = TCP_SKB_CB(skb)->end_seq;
		} else {
			if (before(TCP_SKB_CB(skb)->seq, start))
				start = TCP_SKB_CB(skb)->seq;
			if (after(TCP_SKB_CB(skb)->end_seq, end))
				end = TCP_SKB_CB(skb)->end_seq;
		}
	}
}

/* Reduce allocated memory if we can, trying to get
 * the socket within its memory limits again.
 *
 * Return less than zero if we should start dropping frames
 * until the socket owning process reads some of the data
 * to stabilize the situation.
 */
static int tcp_prune_queue(struct sock *sk)
{
4179
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4180 4181 4182 4183 4184 4185

	SOCK_DEBUG(sk, "prune_queue: c=%x\n", tp->copied_seq);

	NET_INC_STATS_BH(LINUX_MIB_PRUNECALLED);

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4186
		tcp_clamp_window(sk);
L
Linus Torvalds 已提交
4187 4188 4189 4190
	else if (tcp_memory_pressure)
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
D
David S. Miller 已提交
4191 4192
	tcp_collapse(sk, &sk->sk_receive_queue,
		     sk->sk_receive_queue.next,
4193
		     (struct sk_buff *)&sk->sk_receive_queue,
L
Linus Torvalds 已提交
4194
		     tp->copied_seq, tp->rcv_nxt);
4195
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4196 4197 4198 4199 4200 4201 4202 4203

	if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
		return 0;

	/* Collapsing did not help, destructive actions follow.
	 * This must not ever occur. */

	/* First, purge the out_of_order queue. */
4204 4205
	if (!skb_queue_empty(&tp->out_of_order_queue)) {
		NET_INC_STATS_BH(LINUX_MIB_OFOPRUNED);
L
Linus Torvalds 已提交
4206 4207 4208 4209 4210 4211 4212
		__skb_queue_purge(&tp->out_of_order_queue);

		/* Reset SACK state.  A conforming SACK implementation will
		 * do the same at a timeout based retransmit.  When a connection
		 * is in a sad state like this, we care only about integrity
		 * of the connection not performance.
		 */
4213
		if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4214
			tcp_sack_reset(&tp->rx_opt);
4215
		sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239
	}

	if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
		return 0;

	/* If we are really being abused, tell the caller to silently
	 * drop receive data on the floor.  It will get retransmitted
	 * and hopefully then we'll have sufficient space.
	 */
	NET_INC_STATS_BH(LINUX_MIB_RCVPRUNED);

	/* Massive buffer overcommit. */
	tp->pred_flags = 0;
	return -1;
}

/* RFC2861, slow part. Adjust cwnd, after it was not full during one rto.
 * As additional protections, we do not touch cwnd in retransmission phases,
 * and if application hit its sndbuf limit recently.
 */
void tcp_cwnd_application_limited(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

4240
	if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
L
Linus Torvalds 已提交
4241 4242
	    sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
		/* Limited by application or receiver window. */
4243 4244
		u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
		u32 win_used = max(tp->snd_cwnd_used, init_win);
L
Linus Torvalds 已提交
4245
		if (win_used < tp->snd_cwnd) {
4246
			tp->snd_ssthresh = tcp_current_ssthresh(sk);
L
Linus Torvalds 已提交
4247 4248 4249 4250 4251 4252 4253
			tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
		}
		tp->snd_cwnd_used = 0;
	}
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

4254
static int tcp_should_expand_sndbuf(struct sock *sk)
4255
{
4256 4257
	struct tcp_sock *tp = tcp_sk(sk);

4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
		return 0;

	/* If we are under global TCP memory pressure, do not expand.  */
	if (tcp_memory_pressure)
		return 0;

	/* If we are under soft global TCP memory pressure, do not expand.  */
	if (atomic_read(&tcp_memory_allocated) >= sysctl_tcp_mem[0])
		return 0;

	/* If we filled the congestion window, do not expand.  */
	if (tp->packets_out >= tp->snd_cwnd)
		return 0;

	return 1;
}
L
Linus Torvalds 已提交
4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288

/* When incoming ACK allowed to free some skb from write_queue,
 * we remember this event in flag SOCK_QUEUE_SHRUNK and wake up socket
 * on the exit from tcp input handler.
 *
 * PROBLEM: sndbuf expansion does not work well with largesend.
 */
static void tcp_new_space(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

4289
	if (tcp_should_expand_sndbuf(sk)) {
4290
		int sndmem = max_t(u32, tp->rx_opt.mss_clamp, tp->mss_cache) +
L
Linus Torvalds 已提交
4291 4292
			MAX_TCP_HEADER + 16 + sizeof(struct sk_buff),
		    demanded = max_t(unsigned int, tp->snd_cwnd,
4293 4294
				     tp->reordering + 1);
		sndmem *= 2 * demanded;
L
Linus Torvalds 已提交
4295 4296 4297 4298 4299 4300 4301 4302
		if (sndmem > sk->sk_sndbuf)
			sk->sk_sndbuf = min(sndmem, sysctl_tcp_wmem[2]);
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
4303
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
4304 4305 4306 4307 4308 4309 4310 4311 4312
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
		if (sk->sk_socket &&
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
			tcp_new_space(sk);
	}
}

4313
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4314
{
4315
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
	tcp_check_space(sk);
}

/*
 * Check if sending an ack is needed.
 */
static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible)
{
	struct tcp_sock *tp = tcp_sk(sk);

	    /* More than one full frame received... */
4327
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss
L
Linus Torvalds 已提交
4328 4329 4330 4331 4332
	     /* ... and right edge of window advances far enough.
	      * (tcp_recvmsg() will send ACK otherwise). Or...
	      */
	     && __tcp_select_window(sk) >= tp->rcv_wnd) ||
	    /* We ACK each frame or... */
4333
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
4334
	    /* We have out of order data. */
4335
	    (ofo_possible && skb_peek(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
4336 4337 4338 4339 4340 4341 4342 4343
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
4344
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4345
{
4346
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
4347 4348 4349 4350 4351 4352 4353 4354
		/* We sent a data segment already. */
		return;
	}
	__tcp_ack_snd_check(sk, 1);
}

/*
 *	This routine is only called when we have urgent data
S
Stephen Hemminger 已提交
4355
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
4356 4357 4358 4359 4360 4361
 *	moved inline now as tcp_urg is only called from one
 *	place. We handle URGent data wrong. We have to - as
 *	BSD still doesn't use the correction from RFC961.
 *	For 1003.1g we should support a new option TCP_STDURG to permit
 *	either form (or just set the sysctl tcp_stdurg).
 */
4362

4363
static void tcp_check_urg(struct sock *sk, struct tcphdr *th)
L
Linus Torvalds 已提交
4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 ptr = ntohs(th->urg_ptr);

	if (ptr && !sysctl_tcp_stdurg)
		ptr--;
	ptr += ntohl(th->seq);

	/* Ignore urgent data that we've already seen and read. */
	if (after(tp->copied_seq, ptr))
		return;

	/* Do not replay urg ptr.
	 *
	 * NOTE: interesting situation not covered by specs.
	 * Misbehaving sender may send urg ptr, pointing to segment,
	 * which we already have in ofo queue. We are not able to fetch
	 * such data and will stay in TCP_URG_NOTYET until will be eaten
	 * by recvmsg(). Seems, we are not obliged to handle such wicked
	 * situations. But it is worth to think about possibility of some
	 * DoSes using some hypothetical application level deadlock.
	 */
	if (before(ptr, tp->rcv_nxt))
		return;

	/* Do we already have a newer (or duplicate) urgent pointer? */
	if (tp->urg_data && !after(ptr, tp->urg_seq))
		return;

	/* Tell the world about our new urgent pointer. */
	sk_send_sigurg(sk);

	/* We may be adding urgent data when the last byte read was
	 * urgent. To do this requires some care. We cannot just ignore
	 * tp->copied_seq since we would read the last urgent byte again
	 * as data, nor can we alter copied_seq until this data arrives
S
Stephen Hemminger 已提交
4400
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
	 *
	 * NOTE. Double Dutch. Rendering to plain English: author of comment
	 * above did something sort of 	send("A", MSG_OOB); send("B", MSG_OOB);
	 * and expect that both A and B disappear from stream. This is _wrong_.
	 * Though this happens in BSD with high probability, this is occasional.
	 * Any application relying on this is buggy. Note also, that fix "works"
	 * only in this artificial test. Insert some normal data between A and B and we will
	 * decline of BSD again. Verdict: it is better to remove to trap
	 * buggy users.
	 */
	if (tp->urg_seq == tp->copied_seq && tp->urg_data &&
4412
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
4413 4414 4415
		struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
		tp->copied_seq++;
		if (skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq)) {
D
David S. Miller 已提交
4416
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
4417 4418 4419 4420
			__kfree_skb(skb);
		}
	}

4421 4422
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
L
Linus Torvalds 已提交
4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434

	/* Disable header prediction. */
	tp->pred_flags = 0;
}

/* This is the 'fast' part of urgent handling. */
static void tcp_urg(struct sock *sk, struct sk_buff *skb, struct tcphdr *th)
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
4435
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
4436 4437 4438 4439 4440 4441

	/* Do we wait for any urgent data? - normally not... */
	if (tp->urg_data == TCP_URG_NOTYET) {
		u32 ptr = tp->urg_seq - ntohl(th->seq) + (th->doff * 4) -
			  th->syn;

4442
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460
		if (ptr < skb->len) {
			u8 tmp;
			if (skb_copy_bits(skb, ptr, &tmp, 1))
				BUG();
			tp->urg_data = TCP_URG_VALID | tmp;
			if (!sock_flag(sk, SOCK_DEAD))
				sk->sk_data_ready(sk, 0);
		}
	}
}

static int tcp_copy_to_iovec(struct sock *sk, struct sk_buff *skb, int hlen)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int chunk = skb->len - hlen;
	int err;

	local_bh_enable();
4461
	if (skb_csum_unnecessary(skb))
L
Linus Torvalds 已提交
4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
		err = skb_copy_datagram_iovec(skb, hlen, tp->ucopy.iov, chunk);
	else
		err = skb_copy_and_csum_datagram_iovec(skb, hlen,
						       tp->ucopy.iov);

	if (!err) {
		tp->ucopy.len -= chunk;
		tp->copied_seq += chunk;
		tcp_rcv_space_adjust(sk);
	}

	local_bh_disable();
	return err;
}

4477 4478
static __sum16 __tcp_checksum_complete_user(struct sock *sk,
					    struct sk_buff *skb)
L
Linus Torvalds 已提交
4479
{
4480
	__sum16 result;
L
Linus Torvalds 已提交
4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491

	if (sock_owned_by_user(sk)) {
		local_bh_enable();
		result = __tcp_checksum_complete(skb);
		local_bh_disable();
	} else {
		result = __tcp_checksum_complete(skb);
	}
	return result;
}

4492 4493
static inline int tcp_checksum_complete_user(struct sock *sk,
					     struct sk_buff *skb)
L
Linus Torvalds 已提交
4494
{
4495
	return !skb_csum_unnecessary(skb) &&
4496
	       __tcp_checksum_complete_user(sk, skb);
L
Linus Torvalds 已提交
4497 4498
}

C
Chris Leech 已提交
4499
#ifdef CONFIG_NET_DMA
4500 4501
static int tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb,
				  int hlen)
C
Chris Leech 已提交
4502 4503 4504 4505 4506 4507 4508
{
	struct tcp_sock *tp = tcp_sk(sk);
	int chunk = skb->len - hlen;
	int dma_cookie;
	int copied_early = 0;

	if (tp->ucopy.wakeup)
4509
		return 0;
C
Chris Leech 已提交
4510 4511 4512 4513

	if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
		tp->ucopy.dma_chan = get_softnet_dma();

4514
	if (tp->ucopy.dma_chan && skb_csum_unnecessary(skb)) {
C
Chris Leech 已提交
4515 4516

		dma_cookie = dma_skb_copy_datagram_iovec(tp->ucopy.dma_chan,
4517 4518 4519
							 skb, hlen,
							 tp->ucopy.iov, chunk,
							 tp->ucopy.pinned_list);
C
Chris Leech 已提交
4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531

		if (dma_cookie < 0)
			goto out;

		tp->ucopy.dma_cookie = dma_cookie;
		copied_early = 1;

		tp->ucopy.len -= chunk;
		tp->copied_seq += chunk;
		tcp_rcv_space_adjust(sk);

		if ((tp->ucopy.len == 0) ||
4532
		    (tcp_flag_word(tcp_hdr(skb)) & TCP_FLAG_PSH) ||
C
Chris Leech 已提交
4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545
		    (atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1))) {
			tp->ucopy.wakeup = 1;
			sk->sk_data_ready(sk, 0);
		}
	} else if (chunk > 0) {
		tp->ucopy.wakeup = 1;
		sk->sk_data_ready(sk, 0);
	}
out:
	return copied_early;
}
#endif /* CONFIG_NET_DMA */

L
Linus Torvalds 已提交
4546
/*
4547
 *	TCP receive function for the ESTABLISHED state.
L
Linus Torvalds 已提交
4548
 *
4549
 *	It is split into a fast path and a slow path. The fast path is
L
Linus Torvalds 已提交
4550 4551
 * 	disabled when:
 *	- A zero window was announced from us - zero window probing
4552
 *        is only handled properly in the slow path.
L
Linus Torvalds 已提交
4553 4554 4555 4556
 *	- Out of order segments arrived.
 *	- Urgent data is expected.
 *	- There is no buffer space left
 *	- Unexpected TCP flags/window values/header lengths are received
4557
 *	  (detected by checking the TCP header against pred_flags)
L
Linus Torvalds 已提交
4558 4559 4560 4561 4562
 *	- Data is sent in both directions. Fast path only supports pure senders
 *	  or pure receivers (this means either the sequence number or the ack
 *	  value must stay constant)
 *	- Unexpected TCP option.
 *
4563
 *	When these conditions are not satisfied it drops into a standard
L
Linus Torvalds 已提交
4564 4565
 *	receive procedure patterned after RFC793 to handle all cases.
 *	The first three cases are guaranteed by proper pred_flags setting,
4566
 *	the rest is checked inline. Fast processing is turned on in
L
Linus Torvalds 已提交
4567 4568 4569 4570 4571 4572 4573 4574 4575
 *	tcp_data_queue when everything is OK.
 */
int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
			struct tcphdr *th, unsigned len)
{
	struct tcp_sock *tp = tcp_sk(sk);

	/*
	 *	Header prediction.
4576
	 *	The code loosely follows the one in the famous
L
Linus Torvalds 已提交
4577
	 *	"30 instruction TCP receive" Van Jacobson mail.
4578 4579
	 *
	 *	Van's trick is to deposit buffers into socket queue
L
Linus Torvalds 已提交
4580 4581 4582 4583
	 *	on a device interrupt, to call tcp_recv function
	 *	on the receive process context and checksum and copy
	 *	the buffer to user space. smart...
	 *
4584
	 *	Our current scheme is not silly either but we take the
L
Linus Torvalds 已提交
4585 4586 4587 4588 4589 4590 4591
	 *	extra cost of the net_bh soft interrupt processing...
	 *	We do checksum and copy also but from device to kernel.
	 */

	tp->rx_opt.saw_tstamp = 0;

	/*	pred_flags is 0xS?10 << 16 + snd_wnd
S
Stephen Hemminger 已提交
4592
	 *	if header_prediction is to be made
L
Linus Torvalds 已提交
4593 4594
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
4595
	 *  turn it off	(when there are holes in the receive
L
Linus Torvalds 已提交
4596 4597 4598 4599 4600
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
4601
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
L
Linus Torvalds 已提交
4602 4603 4604 4605 4606 4607 4608 4609 4610
		int tcp_header_len = tp->tcp_header_len;

		/* Timestamp header prediction: tcp_header_len
		 * is automatically equal to th->doff*4 due to pred_flags
		 * match.
		 */

		/* Check timestamp */
		if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
4611
			__be32 *ptr = (__be32 *)(th + 1);
L
Linus Torvalds 已提交
4612 4613

			/* No? Slow path! */
4614
			if (*ptr != htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
L
Linus Torvalds 已提交
4615 4616 4617 4618
					  | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP))
				goto slow_path;

			tp->rx_opt.saw_tstamp = 1;
4619
			++ptr;
L
Linus Torvalds 已提交
4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650
			tp->rx_opt.rcv_tsval = ntohl(*ptr);
			++ptr;
			tp->rx_opt.rcv_tsecr = ntohl(*ptr);

			/* If PAWS failed, check it more carefully in slow path */
			if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) < 0)
				goto slow_path;

			/* DO NOT update ts_recent here, if checksum fails
			 * and timestamp was corrupted part, it will result
			 * in a hung connection since we will drop all
			 * future packets due to the PAWS test.
			 */
		}

		if (len <= tcp_header_len) {
			/* Bulk data transfer: sender */
			if (len == tcp_header_len) {
				/* Predicted packet is in window by definition.
				 * seq == rcv_nxt and rcv_wup <= rcv_nxt.
				 * Hence, check seq<=rcv_wup reduces to:
				 */
				if (tcp_header_len ==
				    (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
				    tp->rcv_nxt == tp->rcv_wup)
					tcp_store_ts_recent(tp);

				/* We know that such packets are checksummed
				 * on entry.
				 */
				tcp_ack(sk, skb, 0);
4651
				__kfree_skb(skb);
4652
				tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
4653 4654 4655 4656 4657 4658 4659
				return 0;
			} else { /* Header too small */
				TCP_INC_STATS_BH(TCP_MIB_INERRS);
				goto discard;
			}
		} else {
			int eaten = 0;
C
Chris Leech 已提交
4660
			int copied_early = 0;
L
Linus Torvalds 已提交
4661

C
Chris Leech 已提交
4662 4663 4664 4665 4666 4667 4668 4669
			if (tp->copied_seq == tp->rcv_nxt &&
			    len - tcp_header_len <= tp->ucopy.len) {
#ifdef CONFIG_NET_DMA
				if (tcp_dma_try_early_copy(sk, skb, tcp_header_len)) {
					copied_early = 1;
					eaten = 1;
				}
#endif
4670 4671
				if (tp->ucopy.task == current &&
				    sock_owned_by_user(sk) && !copied_early) {
C
Chris Leech 已提交
4672
					__set_current_state(TASK_RUNNING);
L
Linus Torvalds 已提交
4673

C
Chris Leech 已提交
4674 4675 4676 4677
					if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))
						eaten = 1;
				}
				if (eaten) {
L
Linus Torvalds 已提交
4678 4679 4680 4681 4682 4683 4684 4685 4686 4687
					/* Predicted packet is in window by definition.
					 * seq == rcv_nxt and rcv_wup <= rcv_nxt.
					 * Hence, check seq<=rcv_wup reduces to:
					 */
					if (tcp_header_len ==
					    (sizeof(struct tcphdr) +
					     TCPOLEN_TSTAMP_ALIGNED) &&
					    tp->rcv_nxt == tp->rcv_wup)
						tcp_store_ts_recent(tp);

4688
					tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
4689 4690 4691 4692 4693

					__skb_pull(skb, tcp_header_len);
					tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
					NET_INC_STATS_BH(LINUX_MIB_TCPHPHITSTOUSER);
				}
C
Chris Leech 已提交
4694 4695
				if (copied_early)
					tcp_cleanup_rbuf(sk, skb->len);
L
Linus Torvalds 已提交
4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709
			}
			if (!eaten) {
				if (tcp_checksum_complete_user(sk, skb))
					goto csum_error;

				/* Predicted packet is in window by definition.
				 * seq == rcv_nxt and rcv_wup <= rcv_nxt.
				 * Hence, check seq<=rcv_wup reduces to:
				 */
				if (tcp_header_len ==
				    (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
				    tp->rcv_nxt == tp->rcv_wup)
					tcp_store_ts_recent(tp);

4710
				tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
4711 4712 4713 4714 4715 4716 4717

				if ((int)skb->truesize > sk->sk_forward_alloc)
					goto step5;

				NET_INC_STATS_BH(LINUX_MIB_TCPHPHITS);

				/* Bulk data transfer: receiver */
4718
				__skb_pull(skb, tcp_header_len);
L
Linus Torvalds 已提交
4719
				__skb_queue_tail(&sk->sk_receive_queue, skb);
4720
				skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
4721 4722 4723
				tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
			}

4724
			tcp_event_data_recv(sk, skb);
L
Linus Torvalds 已提交
4725 4726 4727 4728

			if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {
				/* Well, only one small jumplet in fast path... */
				tcp_ack(sk, skb, FLAG_DATA);
4729
				tcp_data_snd_check(sk);
4730
				if (!inet_csk_ack_scheduled(sk))
L
Linus Torvalds 已提交
4731 4732 4733
					goto no_ack;
			}

4734
			__tcp_ack_snd_check(sk, 0);
L
Linus Torvalds 已提交
4735
no_ack:
C
Chris Leech 已提交
4736 4737 4738 4739 4740
#ifdef CONFIG_NET_DMA
			if (copied_early)
				__skb_queue_tail(&sk->sk_async_wait_queue, skb);
			else
#endif
L
Linus Torvalds 已提交
4741 4742 4743 4744 4745 4746 4747 4748 4749
			if (eaten)
				__kfree_skb(skb);
			else
				sk->sk_data_ready(sk, 0);
			return 0;
		}
	}

slow_path:
4750
	if (len < (th->doff << 2) || tcp_checksum_complete_user(sk, skb))
L
Linus Torvalds 已提交
4751 4752 4753 4754 4755 4756
		goto csum_error;

	/*
	 * RFC1323: H1. Apply PAWS check first.
	 */
	if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
4757
	    tcp_paws_discard(sk, skb)) {
L
Linus Torvalds 已提交
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785
		if (!th->rst) {
			NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
			tcp_send_dupack(sk, skb);
			goto discard;
		}
		/* Resets are accepted even if PAWS failed.

		   ts_recent update must be made after we are sure
		   that the packet is in window.
		 */
	}

	/*
	 *	Standard slow path.
	 */

	if (!tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq)) {
		/* RFC793, page 37: "In all states except SYN-SENT, all reset
		 * (RST) segments are validated by checking their SEQ-fields."
		 * And page 69: "If an incoming segment is not acceptable,
		 * an acknowledgment should be sent in reply (unless the RST bit
		 * is set, if so drop the segment and return)".
		 */
		if (!th->rst)
			tcp_send_dupack(sk, skb);
		goto discard;
	}

S
Stephen Hemminger 已提交
4786
	if (th->rst) {
L
Linus Torvalds 已提交
4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800
		tcp_reset(sk);
		goto discard;
	}

	tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);

	if (th->syn && !before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
		TCP_INC_STATS_BH(TCP_MIB_INERRS);
		NET_INC_STATS_BH(LINUX_MIB_TCPABORTONSYN);
		tcp_reset(sk);
		return 1;
	}

step5:
S
Stephen Hemminger 已提交
4801
	if (th->ack)
L
Linus Torvalds 已提交
4802 4803
		tcp_ack(sk, skb, FLAG_SLOWPATH);

4804
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
4805 4806 4807 4808 4809 4810 4811

	/* Process urgent data. */
	tcp_urg(sk, skb, th);

	/* step 7: process the segment text */
	tcp_data_queue(sk, skb);

4812
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827
	tcp_ack_snd_check(sk);
	return 0;

csum_error:
	TCP_INC_STATS_BH(TCP_MIB_INERRS);

discard:
	__kfree_skb(skb);
	return 0;
}

static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
					 struct tcphdr *th, unsigned len)
{
	struct tcp_sock *tp = tcp_sk(sk);
4828
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916
	int saved_clamp = tp->rx_opt.mss_clamp;

	tcp_parse_options(skb, &tp->rx_opt, 0);

	if (th->ack) {
		/* rfc793:
		 * "If the state is SYN-SENT then
		 *    first check the ACK bit
		 *      If the ACK bit is set
		 *	  If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send
		 *        a reset (unless the RST bit is set, if so drop
		 *        the segment and return)"
		 *
		 *  We do not send data with SYN, so that RFC-correct
		 *  test reduces to:
		 */
		if (TCP_SKB_CB(skb)->ack_seq != tp->snd_nxt)
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
			     tcp_time_stamp)) {
			NET_INC_STATS_BH(LINUX_MIB_PAWSACTIVEREJECTED);
			goto reset_and_undo;
		}

		/* Now ACK is acceptable.
		 *
		 * "If the RST bit is set
		 *    If the ACK was acceptable then signal the user "error:
		 *    connection reset", drop the segment, enter CLOSED state,
		 *    delete TCB, and return."
		 */

		if (th->rst) {
			tcp_reset(sk);
			goto discard;
		}

		/* rfc793:
		 *   "fifth, if neither of the SYN or RST bits is set then
		 *    drop the segment and return."
		 *
		 *    See note below!
		 *                                        --ANK(990513)
		 */
		if (!th->syn)
			goto discard_and_undo;

		/* rfc793:
		 *   "If the SYN bit is on ...
		 *    are acceptable then ...
		 *    (our SYN has been ACKed), change the connection
		 *    state to ESTABLISHED..."
		 */

		TCP_ECN_rcv_synack(tp, th);

		tp->snd_wl1 = TCP_SKB_CB(skb)->seq;
		tcp_ack(sk, skb, FLAG_SLOWPATH);

		/* Ok.. it's good. Set up sequence numbers and
		 * move to established.
		 */
		tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
		tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;

		/* RFC1323: The window in SYN & SYN/ACK segments is
		 * never scaled.
		 */
		tp->snd_wnd = ntohs(th->window);
		tcp_init_wl(tp, TCP_SKB_CB(skb)->ack_seq, TCP_SKB_CB(skb)->seq);

		if (!tp->rx_opt.wscale_ok) {
			tp->rx_opt.snd_wscale = tp->rx_opt.rcv_wscale = 0;
			tp->window_clamp = min(tp->window_clamp, 65535U);
		}

		if (tp->rx_opt.saw_tstamp) {
			tp->rx_opt.tstamp_ok	   = 1;
			tp->tcp_header_len =
				sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
			tp->advmss	    -= TCPOLEN_TSTAMP_ALIGNED;
			tcp_store_ts_recent(tp);
		} else {
			tp->tcp_header_len = sizeof(struct tcphdr);
		}

4917 4918
		if (tcp_is_sack(tp) && sysctl_tcp_fack)
			tcp_enable_fack(tp);
L
Linus Torvalds 已提交
4919

J
John Heffner 已提交
4920
		tcp_mtup_init(sk);
4921
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
4922 4923 4924 4925 4926 4927
		tcp_initialize_rcv_mss(sk);

		/* Remember, tcp_poll() does not lock socket!
		 * Change state from SYN-SENT only after copied_seq
		 * is initialized. */
		tp->copied_seq = tp->rcv_nxt;
R
Ralf Baechle 已提交
4928
		smp_mb();
L
Linus Torvalds 已提交
4929 4930
		tcp_set_state(sk, TCP_ESTABLISHED);

4931 4932
		security_inet_conn_established(sk, skb);

L
Linus Torvalds 已提交
4933
		/* Make sure socket is routed, for correct metrics.  */
4934
		icsk->icsk_af_ops->rebuild_header(sk);
L
Linus Torvalds 已提交
4935 4936 4937

		tcp_init_metrics(sk);

4938
		tcp_init_congestion_control(sk);
4939

L
Linus Torvalds 已提交
4940 4941 4942 4943 4944 4945 4946 4947
		/* Prevent spurious tcp_cwnd_restart() on first data
		 * packet.
		 */
		tp->lsndtime = tcp_time_stamp;

		tcp_init_buffer_space(sk);

		if (sock_flag(sk, SOCK_KEEPOPEN))
4948
			inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
L
Linus Torvalds 已提交
4949 4950 4951 4952 4953 4954 4955 4956

		if (!tp->rx_opt.snd_wscale)
			__tcp_fast_path_on(tp, tp->snd_wnd);
		else
			tp->pred_flags = 0;

		if (!sock_flag(sk, SOCK_DEAD)) {
			sk->sk_state_change(sk);
4957
			sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
L
Linus Torvalds 已提交
4958 4959
		}

4960 4961 4962
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
4963 4964 4965 4966 4967 4968 4969
			/* Save one ACK. Data will be ready after
			 * several ticks, if write_pending is set.
			 *
			 * It may be deleted, but with this feature tcpdumps
			 * look so _wonderfully_ clever, that I was not able
			 * to stand against the temptation 8)     --ANK
			 */
4970
			inet_csk_schedule_ack(sk);
4971 4972
			icsk->icsk_ack.lrcvtime = tcp_time_stamp;
			icsk->icsk_ack.ato	 = TCP_ATO_MIN;
4973 4974
			tcp_incr_quickack(sk);
			tcp_enter_quickack_mode(sk);
4975 4976
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999

discard:
			__kfree_skb(skb);
			return 0;
		} else {
			tcp_send_ack(sk);
		}
		return -1;
	}

	/* No ACK in the segment */

	if (th->rst) {
		/* rfc793:
		 * "If the RST bit is set
		 *
		 *      Otherwise (no ACK) drop the segment and return."
		 */

		goto discard_and_undo;
	}

	/* PAWS check. */
5000 5001
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
	    tcp_paws_check(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031
		goto discard_and_undo;

	if (th->syn) {
		/* We see SYN without ACK. It is attempt of
		 * simultaneous connect with crossed SYNs.
		 * Particularly, it can be connect to self.
		 */
		tcp_set_state(sk, TCP_SYN_RECV);

		if (tp->rx_opt.saw_tstamp) {
			tp->rx_opt.tstamp_ok = 1;
			tcp_store_ts_recent(tp);
			tp->tcp_header_len =
				sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
		} else {
			tp->tcp_header_len = sizeof(struct tcphdr);
		}

		tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
		tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;

		/* RFC1323: The window in SYN & SYN/ACK segments is
		 * never scaled.
		 */
		tp->snd_wnd    = ntohs(th->window);
		tp->snd_wl1    = TCP_SKB_CB(skb)->seq;
		tp->max_window = tp->snd_wnd;

		TCP_ECN_rcv_syn(tp, th);

J
John Heffner 已提交
5032
		tcp_mtup_init(sk);
5033
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
		 * There are no obstacles to make this.
		 *
		 * However, if we ignore data in ACKless segments sometimes,
		 * we have no reasons to accept it sometimes.
		 * Also, seems the code doing it in step6 of tcp_rcv_state_process
		 * is not flawless. So, discard packet for sanity.
		 * Uncomment this return to process the data.
		 */
		return -1;
#else
		goto discard;
#endif
	}
	/* "fifth, if neither of the SYN or RST bits is set then
	 * drop the segment and return."
	 */

discard_and_undo:
	tcp_clear_options(&tp->rx_opt);
	tp->rx_opt.mss_clamp = saved_clamp;
	goto discard;

reset_and_undo:
	tcp_clear_options(&tp->rx_opt);
	tp->rx_opt.mss_clamp = saved_clamp;
	return 1;
}

/*
 *	This function implements the receiving procedure of RFC 793 for
5069
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5070 5071 5072
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5073

L
Linus Torvalds 已提交
5074 5075 5076 5077
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
			  struct tcphdr *th, unsigned len)
{
	struct tcp_sock *tp = tcp_sk(sk);
5078
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
5079 5080 5081 5082 5083 5084 5085 5086 5087
	int queued = 0;

	tp->rx_opt.saw_tstamp = 0;

	switch (sk->sk_state) {
	case TCP_CLOSE:
		goto discard;

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5088
		if (th->ack)
L
Linus Torvalds 已提交
5089 5090
			return 1;

S
Stephen Hemminger 已提交
5091
		if (th->rst)
L
Linus Torvalds 已提交
5092 5093
			goto discard;

S
Stephen Hemminger 已提交
5094
		if (th->syn) {
5095
			if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
L
Linus Torvalds 已提交
5096 5097
				return 1;

5098 5099
			/* Now we have several options: In theory there is
			 * nothing else in the frame. KA9Q has an option to
L
Linus Torvalds 已提交
5100
			 * send data with the syn, BSD accepts data with the
5101 5102 5103
			 * syn up to the [to be] advertised window and
			 * Solaris 2.1 gives you a protocol error. For now
			 * we just ignore it, that fits the spec precisely
L
Linus Torvalds 已提交
5104 5105 5106
			 * and avoids incompatibilities. It would be nice in
			 * future to drop through and process the data.
			 *
5107
			 * Now that TTCP is starting to be used we ought to
L
Linus Torvalds 已提交
5108 5109
			 * queue this data.
			 * But, this leaves one open to an easy denial of
5110
			 * service attack, and SYN cookies can't defend
L
Linus Torvalds 已提交
5111
			 * against this problem. So, we drop the data
5112 5113
			 * in the interest of security over speed unless
			 * it's still in use.
L
Linus Torvalds 已提交
5114
			 */
5115 5116
			kfree_skb(skb);
			return 0;
L
Linus Torvalds 已提交
5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127
		}
		goto discard;

	case TCP_SYN_SENT:
		queued = tcp_rcv_synsent_state_process(sk, skb, th, len);
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5128
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5129 5130 5131 5132
		return 0;
	}

	if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
5133
	    tcp_paws_discard(sk, skb)) {
L
Linus Torvalds 已提交
5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149
		if (!th->rst) {
			NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
			tcp_send_dupack(sk, skb);
			goto discard;
		}
		/* Reset is accepted even if it did not pass PAWS. */
	}

	/* step 1: check sequence number */
	if (!tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq)) {
		if (!th->rst)
			tcp_send_dupack(sk, skb);
		goto discard;
	}

	/* step 2: check RST bit */
S
Stephen Hemminger 已提交
5150
	if (th->rst) {
L
Linus Torvalds 已提交
5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
		tcp_reset(sk);
		goto discard;
	}

	tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);

	/* step 3: check security and precedence [ignored] */

	/*	step 4:
	 *
	 *	Check for a SYN in window.
	 */
	if (th->syn && !before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
		NET_INC_STATS_BH(LINUX_MIB_TCPABORTONSYN);
		tcp_reset(sk);
		return 1;
	}

	/* step 5: check the ACK field */
	if (th->ack) {
		int acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH);

S
Stephen Hemminger 已提交
5173
		switch (sk->sk_state) {
L
Linus Torvalds 已提交
5174 5175 5176
		case TCP_SYN_RECV:
			if (acceptable) {
				tp->copied_seq = tp->rcv_nxt;
R
Ralf Baechle 已提交
5177
				smp_mb();
L
Linus Torvalds 已提交
5178 5179 5180 5181 5182 5183 5184 5185
				tcp_set_state(sk, TCP_ESTABLISHED);
				sk->sk_state_change(sk);

				/* Note, that this wakeup is only for marginal
				 * crossed SYN case. Passively open sockets
				 * are not waked up, because sk->sk_sleep ==
				 * NULL and sk->sk_socket == NULL.
				 */
5186 5187
				if (sk->sk_socket)
					sk_wake_async(sk,
5188
						      SOCK_WAKE_IO, POLL_OUT);
L
Linus Torvalds 已提交
5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199

				tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
				tp->snd_wnd = ntohs(th->window) <<
					      tp->rx_opt.snd_wscale;
				tcp_init_wl(tp, TCP_SKB_CB(skb)->ack_seq,
					    TCP_SKB_CB(skb)->seq);

				/* tcp_ack considers this ACK as duplicate
				 * and does not calculate rtt.
				 * Fix it at least with timestamps.
				 */
5200 5201
				if (tp->rx_opt.saw_tstamp &&
				    tp->rx_opt.rcv_tsecr && !tp->srtt)
5202
					tcp_ack_saw_tstamp(sk, 0);
L
Linus Torvalds 已提交
5203 5204 5205 5206 5207 5208 5209

				if (tp->rx_opt.tstamp_ok)
					tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;

				/* Make sure socket is routed, for
				 * correct metrics.
				 */
5210
				icsk->icsk_af_ops->rebuild_header(sk);
L
Linus Torvalds 已提交
5211 5212 5213

				tcp_init_metrics(sk);

5214
				tcp_init_congestion_control(sk);
5215

L
Linus Torvalds 已提交
5216 5217 5218 5219 5220
				/* Prevent spurious tcp_cwnd_restart() on
				 * first data packet.
				 */
				tp->lsndtime = tcp_time_stamp;

J
John Heffner 已提交
5221
				tcp_mtup_init(sk);
L
Linus Torvalds 已提交
5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249
				tcp_initialize_rcv_mss(sk);
				tcp_init_buffer_space(sk);
				tcp_fast_path_on(tp);
			} else {
				return 1;
			}
			break;

		case TCP_FIN_WAIT1:
			if (tp->snd_una == tp->write_seq) {
				tcp_set_state(sk, TCP_FIN_WAIT2);
				sk->sk_shutdown |= SEND_SHUTDOWN;
				dst_confirm(sk->sk_dst_cache);

				if (!sock_flag(sk, SOCK_DEAD))
					/* Wake up lingering close() */
					sk->sk_state_change(sk);
				else {
					int tmo;

					if (tp->linger2 < 0 ||
					    (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
					     after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt))) {
						tcp_done(sk);
						NET_INC_STATS_BH(LINUX_MIB_TCPABORTONDATA);
						return 1;
					}

5250
					tmo = tcp_fin_time(sk);
L
Linus Torvalds 已提交
5251
					if (tmo > TCP_TIMEWAIT_LEN) {
5252
						inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
L
Linus Torvalds 已提交
5253 5254 5255 5256 5257 5258 5259
					} else if (th->fin || sock_owned_by_user(sk)) {
						/* Bad case. We could lose such FIN otherwise.
						 * It is not a big problem, but it looks confusing
						 * and not so rare event. We still can lose it now,
						 * if it spins in bh_lock_sock(), but it is really
						 * marginal case.
						 */
5260
						inet_csk_reset_keepalive_timer(sk, tmo);
L
Linus Torvalds 已提交
5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299
					} else {
						tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
						goto discard;
					}
				}
			}
			break;

		case TCP_CLOSING:
			if (tp->snd_una == tp->write_seq) {
				tcp_time_wait(sk, TCP_TIME_WAIT, 0);
				goto discard;
			}
			break;

		case TCP_LAST_ACK:
			if (tp->snd_una == tp->write_seq) {
				tcp_update_metrics(sk);
				tcp_done(sk);
				goto discard;
			}
			break;
		}
	} else
		goto discard;

	/* step 6: check the URG bit */
	tcp_urg(sk, skb, th);

	/* step 7: process the segment text */
	switch (sk->sk_state) {
	case TCP_CLOSE_WAIT:
	case TCP_CLOSING:
	case TCP_LAST_ACK:
		if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
			break;
	case TCP_FIN_WAIT1:
	case TCP_FIN_WAIT2:
		/* RFC 793 says to queue data in these states,
5300
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311
		 * BSD 4.4 also does reset.
		 */
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
			    after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
				NET_INC_STATS_BH(LINUX_MIB_TCPABORTONDATA);
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
5312
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
5313 5314 5315 5316 5317 5318 5319
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
5320
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5321 5322 5323
		tcp_ack_snd_check(sk);
	}

5324
	if (!queued) {
L
Linus Torvalds 已提交
5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335
discard:
		__kfree_skb(skb);
	}
	return 0;
}

EXPORT_SYMBOL(sysctl_tcp_ecn);
EXPORT_SYMBOL(sysctl_tcp_reordering);
EXPORT_SYMBOL(tcp_parse_options);
EXPORT_SYMBOL(tcp_rcv_established);
EXPORT_SYMBOL(tcp_rcv_state_process);
S
Stephen Hemminger 已提交
5336
EXPORT_SYMBOL(tcp_initialize_rcv_mss);