tcp_input.c 179.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7
/*
 * 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).
 *
8
 * Authors:	Ross Biro
L
Linus Torvalds 已提交
9 10 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
 *		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 已提交
43
 *		Andrey Savochkin:	Fix RTT measurements in the presence of
L
Linus Torvalds 已提交
44 45 46 47 48 49 50
 *					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.
51
 *		Andi Kleen:		Add tcp_measure_rcv_mss to make
L
Linus Torvalds 已提交
52
 *					connections with MSS<min(MTU,ann. MSS)
53
 *					work without delayed acks.
L
Linus Torvalds 已提交
54 55 56 57 58 59 60 61 62 63
 *		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
 */

64 65
#define pr_fmt(fmt) "TCP: " fmt

L
Linus Torvalds 已提交
66
#include <linux/mm.h>
67
#include <linux/slab.h>
L
Linus Torvalds 已提交
68 69
#include <linux/module.h>
#include <linux/sysctl.h>
70
#include <linux/kernel.h>
71
#include <linux/prefetch.h>
72
#include <net/dst.h>
L
Linus Torvalds 已提交
73 74 75 76
#include <net/tcp.h>
#include <net/inet_common.h>
#include <linux/ipsec.h>
#include <asm/unaligned.h>
77
#include <linux/errqueue.h>
L
Linus Torvalds 已提交
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;
84
int sysctl_tcp_max_reordering __read_mostly = 300;
E
Eric Dumazet 已提交
85
EXPORT_SYMBOL(sysctl_tcp_reordering);
86 87
int sysctl_tcp_dsack __read_mostly = 1;
int sysctl_tcp_app_win __read_mostly = 31;
88
int sysctl_tcp_adv_win_scale __read_mostly = 1;
E
Eric Dumazet 已提交
89
EXPORT_SYMBOL(sysctl_tcp_adv_win_scale);
L
Linus Torvalds 已提交
90

E
Eric Dumazet 已提交
91 92 93
/* rfc5961 challenge ack rate limiting */
int sysctl_tcp_challenge_ack_limit = 100;

94 95 96
int sysctl_tcp_stdurg __read_mostly;
int sysctl_tcp_rfc1337 __read_mostly;
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
97
int sysctl_tcp_frto __read_mostly = 2;
98
int sysctl_tcp_min_rtt_wlen __read_mostly = 300;
L
Linus Torvalds 已提交
99

A
Andreas Petlund 已提交
100 101
int sysctl_tcp_thin_dupack __read_mostly;

102
int sysctl_tcp_moderate_rcvbuf __read_mostly = 1;
N
Nandita Dukkipati 已提交
103
int sysctl_tcp_early_retrans __read_mostly = 3;
104
int sysctl_tcp_invalid_ratelimit __read_mostly = HZ/2;
L
Linus Torvalds 已提交
105 106 107 108 109 110 111 112

#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				*/
113
#define FLAG_LOST_RETRANS	0x80 /* This ACK marks some retransmission lost */
L
Linus Torvalds 已提交
114
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
Y
Yuchung Cheng 已提交
115
#define FLAG_ORIG_SACK_ACKED	0x200 /* Never retransmitted data are (s)acked	*/
116
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
117
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
118
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
119
#define FLAG_UPDATE_TS_RECENT	0x4000 /* tcp_replace_ts_recent() */
L
Linus Torvalds 已提交
120 121 122 123 124 125 126

#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)

#define TCP_REMNANT (TCP_FLAG_FIN|TCP_FLAG_URG|TCP_FLAG_SYN|TCP_FLAG_PSH)
127
#define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
L
Linus Torvalds 已提交
128

129
/* Adapt the MSS value used to make delayed ack decision to the
L
Linus Torvalds 已提交
130
 * real world.
131
 */
132
static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
133
{
134
	struct inet_connection_sock *icsk = inet_csk(sk);
135
	const unsigned int lss = icsk->icsk_ack.last_seg_size;
136
	unsigned int len;
L
Linus Torvalds 已提交
137

138
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
139 140 141 142

	/* skb->len may jitter because of SACKs, even if peer
	 * sends good full-sized frames.
	 */
143
	len = skb_shinfo(skb)->gso_size ? : skb->len;
144 145
	if (len >= icsk->icsk_ack.rcv_mss) {
		icsk->icsk_ack.rcv_mss = len;
L
Linus Torvalds 已提交
146 147 148 149 150 151
	} else {
		/* Otherwise, we make more careful check taking into account,
		 * that SACKs block is variable.
		 *
		 * "len" is invariant segment length, including TCP header.
		 */
152
		len += skb->data - skb_transport_header(skb);
153
		if (len >= TCP_MSS_DEFAULT + sizeof(struct tcphdr) ||
L
Linus Torvalds 已提交
154 155 156 157 158 159
		    /* 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) &&
160
		     !(tcp_flag_word(tcp_hdr(skb)) & TCP_REMNANT))) {
L
Linus Torvalds 已提交
161 162 163 164
			/* Subtract also invariant (if peer is RFC compliant),
			 * tcp header plus fixed timestamp option length.
			 * Resulting "len" is MSS free of SACK jitter.
			 */
165 166
			len -= tcp_sk(sk)->tcp_header_len;
			icsk->icsk_ack.last_seg_size = len;
L
Linus Torvalds 已提交
167
			if (len == lss) {
168
				icsk->icsk_ack.rcv_mss = len;
L
Linus Torvalds 已提交
169 170 171
				return;
			}
		}
172 173
		if (icsk->icsk_ack.pending & ICSK_ACK_PUSHED)
			icsk->icsk_ack.pending |= ICSK_ACK_PUSHED2;
174
		icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
L
Linus Torvalds 已提交
175 176 177
	}
}

178
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
179
{
180
	struct inet_connection_sock *icsk = inet_csk(sk);
181
	unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
182

183 184
	if (quickacks == 0)
		quickacks = 2;
185 186
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
187 188
}

189
static void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
190
{
191 192 193 194
	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 已提交
195 196 197 198 199 200
}

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

201
static bool tcp_in_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
202
{
203
	const struct inet_connection_sock *icsk = inet_csk(sk);
204
	const struct dst_entry *dst = __sk_dst_get(sk);
E
Eric Dumazet 已提交
205

206 207
	return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong);
L
Linus Torvalds 已提交
208 209
}

210
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
211
{
212
	if (tp->ecn_flags & TCP_ECN_OK)
213 214 215
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

216
static void tcp_ecn_accept_cwr(struct tcp_sock *tp, const struct sk_buff *skb)
217 218 219 220 221
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

222
static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
223 224 225 226
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

227
static void __tcp_ecn_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
228
{
229
	switch (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK) {
230
	case INET_ECN_NOT_ECT:
231
		/* Funny extension: if ECT is not set on a segment,
232 233 234 235
		 * and we already seen ECT on a previous segment,
		 * it is probably a retransmit.
		 */
		if (tp->ecn_flags & TCP_ECN_SEEN)
236
			tcp_enter_quickack_mode((struct sock *)tp);
237 238
		break;
	case INET_ECN_CE:
239 240 241
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_IS_CE);

242 243 244 245 246
		if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
			/* Better not delay acks, sender can have a very low cwnd */
			tcp_enter_quickack_mode((struct sock *)tp);
			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
		}
247 248
		tp->ecn_flags |= TCP_ECN_SEEN;
		break;
249
	default:
250 251
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_NO_CE);
252
		tp->ecn_flags |= TCP_ECN_SEEN;
253
		break;
254 255 256
	}
}

257 258 259 260 261 262 263
static void tcp_ecn_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
{
	if (tp->ecn_flags & TCP_ECN_OK)
		__tcp_ecn_check_ce(tp, skb);
}

static void tcp_ecn_rcv_synack(struct tcp_sock *tp, const struct tcphdr *th)
264
{
265
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
266 267 268
		tp->ecn_flags &= ~TCP_ECN_OK;
}

269
static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
270
{
271
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
272 273 274
		tp->ecn_flags &= ~TCP_ECN_OK;
}

275
static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
276
{
277
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
E
Eric Dumazet 已提交
278 279
		return true;
	return false;
280 281
}

L
Linus Torvalds 已提交
282 283 284 285 286
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

E
Eric Dumazet 已提交
287
static void tcp_sndbuf_expand(struct sock *sk)
L
Linus Torvalds 已提交
288
{
E
Eric Dumazet 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
	const struct tcp_sock *tp = tcp_sk(sk);
	int sndmem, per_mss;
	u32 nr_segs;

	/* Worst case is non GSO/TSO : each frame consumes one skb
	 * and skb->head is kmalloced using power of two area of memory
	 */
	per_mss = max_t(u32, tp->rx_opt.mss_clamp, tp->mss_cache) +
		  MAX_TCP_HEADER +
		  SKB_DATA_ALIGN(sizeof(struct skb_shared_info));

	per_mss = roundup_pow_of_two(per_mss) +
		  SKB_DATA_ALIGN(sizeof(struct sk_buff));

	nr_segs = max_t(u32, TCP_INIT_CWND, tp->snd_cwnd);
	nr_segs = max_t(u32, nr_segs, tp->reordering + 1);

	/* Fast Recovery (RFC 5681 3.2) :
	 * Cubic needs 1.7 factor, rounded to 2 to include
	 * extra cushion (application might react slowly to POLLOUT)
	 */
	sndmem = 2 * nr_segs * per_mss;
L
Linus Torvalds 已提交
311

312 313
	if (sk->sk_sndbuf < sndmem)
		sk->sk_sndbuf = min(sndmem, sysctl_tcp_wmem[2]);
L
Linus Torvalds 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
}

/* 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 已提交
337
 * window and then starts to feed us spaghetti. But it should work
L
Linus Torvalds 已提交
338 339 340 341
 * in common situations. Otherwise, we have to rely on queue collapsing.
 */

/* Slow part of check#2. */
342
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
343
{
344
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
345
	/* Optimize this! */
346 347
	int truesize = tcp_win_from_space(skb->truesize) >> 1;
	int window = tcp_win_from_space(sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
348 349 350

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
351
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
352 353 354 355 356 357 358

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

359
static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
360
{
361 362
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
363 364 365
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
366
	    !tcp_under_memory_pressure(sk)) {
L
Linus Torvalds 已提交
367 368 369 370 371 372
		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)
373
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
374
		else
375
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
376 377

		if (incr) {
378
			incr = max_t(int, incr, 2 * skb->len);
379 380
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
381
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
382 383 384 385 386 387 388
		}
	}
}

/* 3. Tuning rcvbuf, when connection enters established state. */
static void tcp_fixup_rcvbuf(struct sock *sk)
{
389 390
	u32 mss = tcp_sk(sk)->advmss;
	int rcvmem;
L
Linus Torvalds 已提交
391

392 393
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
394

E
Eric Dumazet 已提交
395 396 397 398 399 400
	/* Dynamic Right Sizing (DRS) has 2 to 3 RTT latency
	 * Allow enough cushion so that sender is not limited by our window
	 */
	if (sysctl_tcp_moderate_rcvbuf)
		rcvmem <<= 2;

401 402
	if (sk->sk_rcvbuf < rcvmem)
		sk->sk_rcvbuf = min(rcvmem, sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
403 404
}

S
Stephen Hemminger 已提交
405
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
406 407
 *    established state.
 */
408
void tcp_init_buffer_space(struct sock *sk)
L
Linus Torvalds 已提交
409 410 411 412 413 414 415
{
	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))
E
Eric Dumazet 已提交
416
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
417 418

	tp->rcvq_space.space = tp->rcv_wnd;
E
Eric Dumazet 已提交
419 420
	tp->rcvq_space.time = tcp_time_stamp;
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

	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. */
444
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
445
{
446
	struct tcp_sock *tp = tcp_sk(sk);
447
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
448

449
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
450

451 452
	if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
453
	    !tcp_under_memory_pressure(sk) &&
454
	    sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
455 456
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
				    sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
457
	}
458
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
459
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
460 461
}

S
Stephen Hemminger 已提交
462 463 464 465 466 467 468 469 470
/* 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)
{
471
	const struct tcp_sock *tp = tcp_sk(sk);
S
Stephen Hemminger 已提交
472 473
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

474
	hint = min(hint, tp->rcv_wnd / 2);
475
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
476 477 478 479
	hint = max(hint, TCP_MIN_MSS);

	inet_csk(sk)->icsk_ack.rcv_mss = hint;
}
E
Eric Dumazet 已提交
480
EXPORT_SYMBOL(tcp_initialize_rcv_mss);
S
Stephen Hemminger 已提交
481

L
Linus Torvalds 已提交
482 483 484 485
/* 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.
486
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
L
Linus Torvalds 已提交
487 488
 *
 * More detail on this code can be found at
489
 * <http://staff.psc.edu/jheffner/>,
L
Linus Torvalds 已提交
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
 * 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 已提交
508
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
509
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
510 511 512 513 514
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
515 516 517 518 519
		} else {
			m <<= 3;
			if (m < new_sample)
				new_sample = m;
		}
L
Linus Torvalds 已提交
520
	} else {
S
Stephen Hemminger 已提交
521
		/* No previous measure. */
L
Linus Torvalds 已提交
522 523 524 525 526 527 528 529 530 531 532 533 534
		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;
535
	tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rcv_rtt_est.time, 1);
L
Linus Torvalds 已提交
536 537 538 539 540 541

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

542 543
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
544
{
545
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
546 547
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
548
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
L
Linus Torvalds 已提交
549 550 551 552 553 554 555 556 557 558 559
		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;
E
Eric Dumazet 已提交
560
	int copied;
561

L
Linus Torvalds 已提交
562
	time = tcp_time_stamp - tp->rcvq_space.time;
563
	if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
L
Linus Torvalds 已提交
564
		return;
565

E
Eric Dumazet 已提交
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
	/* Number of bytes copied to user in last RTT */
	copied = tp->copied_seq - tp->rcvq_space.seq;
	if (copied <= tp->rcvq_space.space)
		goto new_measure;

	/* A bit of theory :
	 * copied = bytes received in previous RTT, our base window
	 * To cope with packet losses, we need a 2x factor
	 * To cope with slow start, and sender growing its cwin by 100 %
	 * every RTT, we need a 4x factor, because the ACK we are sending
	 * now is for the next RTT, not the current one :
	 * <prev RTT . ><current RTT .. ><next RTT .... >
	 */

	if (sysctl_tcp_moderate_rcvbuf &&
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
		int rcvwin, rcvmem, rcvbuf;
L
Linus Torvalds 已提交
583

E
Eric Dumazet 已提交
584 585 586 587
		/* minimal window to cope with packet losses, assuming
		 * steady state. Add some cushion because of small variations.
		 */
		rcvwin = (copied << 1) + 16 * tp->advmss;
L
Linus Torvalds 已提交
588

E
Eric Dumazet 已提交
589 590 591 592 593 594 595 596 597 598 599 600 601
		/* If rate increased by 25%,
		 *	assume slow start, rcvwin = 3 * copied
		 * If rate increased by 50%,
		 *	assume sender can use 2x growth, rcvwin = 4 * copied
		 */
		if (copied >=
		    tp->rcvq_space.space + (tp->rcvq_space.space >> 2)) {
			if (copied >=
			    tp->rcvq_space.space + (tp->rcvq_space.space >> 1))
				rcvwin <<= 1;
			else
				rcvwin += (rcvwin >> 1);
		}
L
Linus Torvalds 已提交
602

E
Eric Dumazet 已提交
603 604 605
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
		while (tcp_win_from_space(rcvmem) < tp->advmss)
			rcvmem += 128;
L
Linus Torvalds 已提交
606

E
Eric Dumazet 已提交
607 608 609
		rcvbuf = min(rcvwin / tp->advmss * rcvmem, sysctl_tcp_rmem[2]);
		if (rcvbuf > sk->sk_rcvbuf) {
			sk->sk_rcvbuf = rcvbuf;
L
Linus Torvalds 已提交
610

E
Eric Dumazet 已提交
611 612
			/* Make the window clamp follow along.  */
			tp->window_clamp = rcvwin;
L
Linus Torvalds 已提交
613 614
		}
	}
E
Eric Dumazet 已提交
615
	tp->rcvq_space.space = copied;
616

L
Linus Torvalds 已提交
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
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
 */
632
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
633
{
634
	struct tcp_sock *tp = tcp_sk(sk);
635
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
636 637
	u32 now;

638
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
639

640
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
641 642

	tcp_rcv_rtt_measure(tp);
643

L
Linus Torvalds 已提交
644 645
	now = tcp_time_stamp;

646
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
647 648 649
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
650 651
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
652
	} else {
653
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
654

655
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
656
			/* The fastest case is the first. */
657 658 659 660 661 662
			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 已提交
663
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
664 665
			 * restart window, so that we send ACKs quickly.
			 */
666
			tcp_incr_quickack(sk);
667
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
668 669
		}
	}
670
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
671

672
	tcp_ecn_check_ce(tp, skb);
L
Linus Torvalds 已提交
673 674

	if (skb->len >= 128)
675
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683 684 685 686
}

/* 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
 */
687
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
688
{
689
	struct tcp_sock *tp = tcp_sk(sk);
690 691
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
692 693 694 695

	/*	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.
696
	 *	This is designed to be as fast as possible
L
Linus Torvalds 已提交
697 698 699 700 701 702 703
	 *	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 已提交
704
	 * too slowly, when it should be increased quickly, decrease too quickly
L
Linus Torvalds 已提交
705 706 707 708
	 * 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)
	 */
709 710 711
	if (srtt != 0) {
		m -= (srtt >> 3);	/* m is now error in rtt est */
		srtt += m;		/* rtt = 7/8 rtt + 1/8 new */
L
Linus Torvalds 已提交
712 713
		if (m < 0) {
			m = -m;		/* m is now abs(error) */
714
			m -= (tp->mdev_us >> 2);   /* similar update on mdev */
L
Linus Torvalds 已提交
715 716 717 718 719 720 721 722 723 724 725
			/* 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 {
726
			m -= (tp->mdev_us >> 2);   /* similar update on mdev */
L
Linus Torvalds 已提交
727
		}
728 729 730 731 732
		tp->mdev_us += m;		/* mdev = 3/4 mdev + 1/4 new */
		if (tp->mdev_us > tp->mdev_max_us) {
			tp->mdev_max_us = tp->mdev_us;
			if (tp->mdev_max_us > tp->rttvar_us)
				tp->rttvar_us = tp->mdev_max_us;
L
Linus Torvalds 已提交
733 734
		}
		if (after(tp->snd_una, tp->rtt_seq)) {
735 736
			if (tp->mdev_max_us < tp->rttvar_us)
				tp->rttvar_us -= (tp->rttvar_us - tp->mdev_max_us) >> 2;
L
Linus Torvalds 已提交
737
			tp->rtt_seq = tp->snd_nxt;
738
			tp->mdev_max_us = tcp_rto_min_us(sk);
L
Linus Torvalds 已提交
739 740 741
		}
	} else {
		/* no previous measure. */
742
		srtt = m << 3;		/* take the measured time to be rtt */
743 744 745
		tp->mdev_us = m << 1;	/* make sure rto = 3*rtt */
		tp->rttvar_us = max(tp->mdev_us, tcp_rto_min_us(sk));
		tp->mdev_max_us = tp->rttvar_us;
L
Linus Torvalds 已提交
746 747
		tp->rtt_seq = tp->snd_nxt;
	}
748
	tp->srtt_us = max(1U, srtt);
L
Linus Torvalds 已提交
749 750
}

E
Eric Dumazet 已提交
751 752 753 754 755 756
/* Set the sk_pacing_rate to allow proper sizing of TSO packets.
 * Note: TCP stack does not yet implement pacing.
 * FQ packet scheduler can be used to implement cheap but effective
 * TCP pacing, to smooth the burst on large writes when packets
 * in flight is significantly lower than cwnd (or rwin)
 */
757 758 759
int sysctl_tcp_pacing_ss_ratio __read_mostly = 200;
int sysctl_tcp_pacing_ca_ratio __read_mostly = 120;

E
Eric Dumazet 已提交
760 761 762 763 764 765
static void tcp_update_pacing_rate(struct sock *sk)
{
	const struct tcp_sock *tp = tcp_sk(sk);
	u64 rate;

	/* set sk_pacing_rate to 200 % of current rate (mss * cwnd / srtt) */
766 767 768 769 770 771 772 773 774 775 776 777 778 779
	rate = (u64)tp->mss_cache * ((USEC_PER_SEC / 100) << 3);

	/* current rate is (cwnd * mss) / srtt
	 * In Slow Start [1], set sk_pacing_rate to 200 % the current rate.
	 * In Congestion Avoidance phase, set it to 120 % the current rate.
	 *
	 * [1] : Normal Slow Start condition is (tp->snd_cwnd < tp->snd_ssthresh)
	 *	 If snd_cwnd >= (tp->snd_ssthresh / 2), we are approaching
	 *	 end of slow start and should slow down.
	 */
	if (tp->snd_cwnd < tp->snd_ssthresh / 2)
		rate *= sysctl_tcp_pacing_ss_ratio;
	else
		rate *= sysctl_tcp_pacing_ca_ratio;
E
Eric Dumazet 已提交
780 781 782

	rate *= max(tp->snd_cwnd, tp->packets_out);

783 784
	if (likely(tp->srtt_us))
		do_div(rate, tp->srtt_us);
E
Eric Dumazet 已提交
785

786 787 788 789 790 791
	/* ACCESS_ONCE() is needed because sch_fq fetches sk_pacing_rate
	 * without any lock. We want to make sure compiler wont store
	 * intermediate values in this location.
	 */
	ACCESS_ONCE(sk->sk_pacing_rate) = min_t(u64, rate,
						sk->sk_max_pacing_rate);
E
Eric Dumazet 已提交
792 793
}

L
Linus Torvalds 已提交
794 795 796
/* Calculate rto without backoff.  This is the second half of Van Jacobson's
 * routine referred to above.
 */
797
static void tcp_set_rto(struct sock *sk)
L
Linus Torvalds 已提交
798
{
799
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
800 801 802 803 804 805 806 807
	/* 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 已提交
808
	 *    ACKs in some circumstances.
L
Linus Torvalds 已提交
809
	 */
810
	inet_csk(sk)->icsk_rto = __tcp_set_rto(tp);
L
Linus Torvalds 已提交
811 812 813 814

	/* 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 已提交
815
	 *    with correct one. It is exactly, which we pretend to do.
L
Linus Torvalds 已提交
816 817
	 */

818 819 820
	/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
	 * guarantees that rto is higher.
	 */
821
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
822 823
}

824
__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
L
Linus Torvalds 已提交
825 826 827
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

828
	if (!cwnd)
829
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
830 831 832
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

833 834 835 836
/*
 * Packet counting of FACK is based on in-order assumptions, therefore TCP
 * disables it when reordering is detected
 */
837
void tcp_disable_fack(struct tcp_sock *tp)
838
{
839 840 841
	/* RFC3517 uses different metric in lost marker => reset on change */
	if (tcp_is_fack(tp))
		tp->lost_skb_hint = NULL;
842
	tp->rx_opt.sack_ok &= ~TCP_FACK_ENABLED;
843 844
}

845
/* Take a notice that peer is sending D-SACKs */
846 847
static void tcp_dsack_seen(struct tcp_sock *tp)
{
848
	tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
849 850
}

851 852
static void tcp_update_reordering(struct sock *sk, const int metric,
				  const int ts)
L
Linus Torvalds 已提交
853
{
854
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
855
	if (metric > tp->reordering) {
856 857
		int mib_idx;

858
		tp->reordering = min(sysctl_tcp_max_reordering, metric);
L
Linus Torvalds 已提交
859 860 861

		/* This exciting event is worth to be remembered. 8) */
		if (ts)
862
			mib_idx = LINUX_MIB_TCPTSREORDER;
863
		else if (tcp_is_reno(tp))
864
			mib_idx = LINUX_MIB_TCPRENOREORDER;
865
		else if (tcp_is_fack(tp))
866
			mib_idx = LINUX_MIB_TCPFACKREORDER;
L
Linus Torvalds 已提交
867
		else
868 869
			mib_idx = LINUX_MIB_TCPSACKREORDER;

870
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
871
#if FASTRETRANS_DEBUG > 1
872 873 874 875 876 877
		pr_debug("Disorder%d %d %u f%u s%u rr%d\n",
			 tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
			 tp->reordering,
			 tp->fackets_out,
			 tp->sacked_out,
			 tp->undo_marker ? tp->undo_retrans : 0);
L
Linus Torvalds 已提交
878
#endif
879
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
880
	}
Y
Yuchung Cheng 已提交
881 882 883

	if (metric > 0)
		tcp_disable_early_retrans(tp);
Y
Yuchung Cheng 已提交
884
	tp->rack.reord = 1;
L
Linus Torvalds 已提交
885 886
}

887
/* This must be called before lost_out is incremented */
888 889
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
890
	if (!tp->retransmit_skb_hint ||
891 892
	    before(TCP_SKB_CB(skb)->seq,
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
893 894 895 896 897
		tp->retransmit_skb_hint = skb;

	if (!tp->lost_out ||
	    after(TCP_SKB_CB(skb)->end_seq, tp->retransmit_high))
		tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
898 899
}

900 901 902 903 904 905 906 907 908 909
static void tcp_skb_mark_lost(struct tcp_sock *tp, struct sk_buff *skb)
{
	if (!(TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_ACKED))) {
		tcp_verify_retransmit_hint(tp, skb);

		tp->lost_out += tcp_skb_pcount(skb);
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

Y
Yuchung Cheng 已提交
910
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
911 912 913 914 915 916 917 918 919
{
	tcp_verify_retransmit_hint(tp, skb);

	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;
	}
}

L
Linus Torvalds 已提交
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
/* 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())
941
 * 3. Loss detection event of two flavors:
L
Linus Torvalds 已提交
942 943
 *	A. Scoreboard estimator decided the packet is lost.
 *	   A'. Reno "three dupacks" marks head of queue lost.
944 945
 *	   A''. Its FACK modification, head until snd.fack is lost.
 *	B. SACK arrives sacking SND.NXT at the moment, when the
L
Linus Torvalds 已提交
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964
 *	   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 已提交
965 966 967 968 969 970 971
 *
 * 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
972 973 974 975 976 977 978 979 980
 * 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 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
 *
 * 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
1003
 * again, D-SACK block must not to go across snd_una (for the same reason as
I
Ilpo Järvinen 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012
 * 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 已提交
1013
 */
E
Eric Dumazet 已提交
1014 1015
static bool tcp_is_sackblock_valid(struct tcp_sock *tp, bool is_dsack,
				   u32 start_seq, u32 end_seq)
I
Ilpo Järvinen 已提交
1016 1017 1018
{
	/* Too far in future, or reversed (interpretation is ambiguous) */
	if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
E
Eric Dumazet 已提交
1019
		return false;
I
Ilpo Järvinen 已提交
1020 1021 1022

	/* Nasty start_seq wrap-around check (see comments above) */
	if (!before(start_seq, tp->snd_nxt))
E
Eric Dumazet 已提交
1023
		return false;
I
Ilpo Järvinen 已提交
1024

1025
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1026 1027 1028
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
E
Eric Dumazet 已提交
1029
		return true;
I
Ilpo Järvinen 已提交
1030 1031

	if (!is_dsack || !tp->undo_marker)
E
Eric Dumazet 已提交
1032
		return false;
I
Ilpo Järvinen 已提交
1033 1034

	/* ...Then it's D-SACK, and must reside below snd_una completely */
Z
Zheng Yan 已提交
1035
	if (after(end_seq, tp->snd_una))
E
Eric Dumazet 已提交
1036
		return false;
I
Ilpo Järvinen 已提交
1037 1038

	if (!before(start_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1039
		return true;
I
Ilpo Järvinen 已提交
1040 1041 1042

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1043
		return false;
I
Ilpo Järvinen 已提交
1044 1045 1046 1047 1048 1049 1050

	/* 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);
}

E
Eric Dumazet 已提交
1051 1052 1053
static bool tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
			    struct tcp_sack_block_wire *sp, int num_sacks,
			    u32 prior_snd_una)
1054
{
1055
	struct tcp_sock *tp = tcp_sk(sk);
1056 1057
	u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);
	u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);
E
Eric Dumazet 已提交
1058
	bool dup_sack = false;
1059 1060

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
E
Eric Dumazet 已提交
1061
		dup_sack = true;
1062
		tcp_dsack_seen(tp);
1063
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1064
	} else if (num_sacks > 1) {
1065 1066
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1067 1068 1069

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
E
Eric Dumazet 已提交
1070
			dup_sack = true;
1071
			tcp_dsack_seen(tp);
1072 1073
			NET_INC_STATS_BH(sock_net(sk),
					LINUX_MIB_TCPDSACKOFORECV);
1074 1075 1076 1077
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1078
	if (dup_sack && tp->undo_marker && tp->undo_retrans > 0 &&
1079 1080 1081 1082 1083 1084 1085
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1086
struct tcp_sacktag_state {
1087 1088
	int	reord;
	int	fack_count;
1089 1090 1091 1092 1093 1094
	/* Timestamps for earliest and latest never-retransmitted segment
	 * that was SACKed. RTO needs the earliest RTT to stay conservative,
	 * but congestion control should still get an accurate delay signal.
	 */
	struct skb_mstamp first_sackt;
	struct skb_mstamp last_sackt;
1095
	int	flag;
1096 1097
};

1098 1099 1100 1101 1102
/* 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).
1103 1104
 *
 * FIXME: this could be merged to shift decision code
1105
 */
1106
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
E
Eric Dumazet 已提交
1107
				  u32 start_seq, u32 end_seq)
1108
{
E
Eric Dumazet 已提交
1109 1110
	int err;
	bool in_sack;
1111
	unsigned int pkt_len;
1112
	unsigned int mss;
1113 1114 1115 1116 1117 1118

	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)) {
1119
		mss = tcp_skb_mss(skb);
1120 1121
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1122
		if (!in_sack) {
1123
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1124 1125 1126
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1127
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138
			if (pkt_len < mss)
				return -EINVAL;
		}

		/* Round if necessary so that SACKs cover only full MSSes
		 * and/or the remaining small portion (if present)
		 */
		if (pkt_len > mss) {
			unsigned int new_len = (pkt_len / mss) * mss;
			if (!in_sack && new_len < pkt_len) {
				new_len += mss;
1139
				if (new_len >= skb->len)
1140 1141 1142 1143
					return 0;
			}
			pkt_len = new_len;
		}
1144
		err = tcp_fragment(sk, skb, pkt_len, mss, GFP_ATOMIC);
1145 1146 1147 1148 1149 1150 1151
		if (err < 0)
			return err;
	}

	return in_sack;
}

1152 1153 1154 1155
/* Mark the given newly-SACKed range as such, adjusting counters and hints. */
static u8 tcp_sacktag_one(struct sock *sk,
			  struct tcp_sacktag_state *state, u8 sacked,
			  u32 start_seq, u32 end_seq,
1156 1157
			  int dup_sack, int pcount,
			  const struct skb_mstamp *xmit_time)
1158
{
1159
	struct tcp_sock *tp = tcp_sk(sk);
1160
	int fack_count = state->fack_count;
1161 1162 1163

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1164
		if (tp->undo_marker && tp->undo_retrans > 0 &&
1165
		    after(end_seq, tp->undo_marker))
1166
			tp->undo_retrans--;
1167
		if (sacked & TCPCB_SACKED_ACKED)
1168
			state->reord = min(fack_count, state->reord);
1169 1170 1171
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
1172
	if (!after(end_seq, tp->snd_una))
1173
		return sacked;
1174 1175

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1176 1177
		tcp_rack_advance(tp, xmit_time, sacked);

1178 1179 1180 1181 1182 1183
		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) {
1184
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1185 1186
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1187 1188 1189 1190 1191 1192
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
1193
				if (before(start_seq,
1194
					   tcp_highest_sack_seq(tp)))
1195 1196
					state->reord = min(fack_count,
							   state->reord);
Y
Yuchung Cheng 已提交
1197 1198
				if (!after(end_seq, tp->high_seq))
					state->flag |= FLAG_ORIG_SACK_ACKED;
1199 1200 1201
				if (state->first_sackt.v64 == 0)
					state->first_sackt = *xmit_time;
				state->last_sackt = *xmit_time;
1202 1203 1204
			}

			if (sacked & TCPCB_LOST) {
1205
				sacked &= ~TCPCB_LOST;
1206
				tp->lost_out -= pcount;
1207 1208 1209
			}
		}

1210 1211
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1212
		tp->sacked_out += pcount;
1213

1214
		fack_count += pcount;
1215 1216

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
1217
		if (!tcp_is_fack(tp) && tp->lost_skb_hint &&
1218
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1219
			tp->lost_cnt_hint += pcount;
1220 1221 1222 1223 1224 1225 1226 1227 1228

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

	/* 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.
	 */
1229 1230
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1231
		tp->retrans_out -= pcount;
1232 1233
	}

1234
	return sacked;
1235 1236
}

1237 1238 1239
/* Shift newly-SACKed bytes from this skb to the immediately previous
 * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
 */
E
Eric Dumazet 已提交
1240 1241 1242 1243
static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
			    struct tcp_sacktag_state *state,
			    unsigned int pcount, int shifted, int mss,
			    bool dup_sack)
1244 1245
{
	struct tcp_sock *tp = tcp_sk(sk);
1246
	struct sk_buff *prev = tcp_write_queue_prev(sk, skb);
1247 1248
	u32 start_seq = TCP_SKB_CB(skb)->seq;	/* start of newly-SACKed */
	u32 end_seq = start_seq + shifted;	/* end of newly-SACKed */
1249 1250 1251

	BUG_ON(!pcount);

1252 1253 1254 1255 1256 1257 1258
	/* Adjust counters and hints for the newly sacked sequence
	 * range but discard the return value since prev is already
	 * marked. We must tag the range first because the seq
	 * advancement below implicitly advances
	 * tcp_highest_sack_seq() when skb is highest_sack.
	 */
	tcp_sacktag_one(sk, state, TCP_SKB_CB(skb)->sacked,
Y
Yuchung Cheng 已提交
1259
			start_seq, end_seq, dup_sack, pcount,
1260
			&skb->skb_mstamp);
1261 1262

	if (skb == tp->lost_skb_hint)
1263 1264
		tp->lost_cnt_hint += pcount;

1265 1266 1267
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

1268 1269 1270
	tcp_skb_pcount_add(prev, pcount);
	BUG_ON(tcp_skb_pcount(skb) < pcount);
	tcp_skb_pcount_add(skb, -pcount);
1271 1272 1273 1274 1275 1276

	/* When we're adding to gso_segs == 1, gso_size will be zero,
	 * in theory this shouldn't be necessary but as long as DSACK
	 * code can come after this skb later on it's better to keep
	 * setting gso_size to something.
	 */
1277 1278
	if (!TCP_SKB_CB(prev)->tcp_gso_size)
		TCP_SKB_CB(prev)->tcp_gso_size = mss;
1279 1280

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
1281
	if (tcp_skb_pcount(skb) <= 1)
1282
		TCP_SKB_CB(skb)->tcp_gso_size = 0;
1283 1284 1285 1286 1287 1288

	/* Difference in this won't matter, both ACKed by the same cumul. ACK */
	TCP_SKB_CB(prev)->sacked |= (TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS);

	if (skb->len > 0) {
		BUG_ON(!tcp_skb_pcount(skb));
1289
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTED);
E
Eric Dumazet 已提交
1290
		return false;
1291 1292 1293 1294
	}

	/* Whole SKB was eaten :-) */

1295 1296 1297 1298 1299 1300 1301
	if (skb == tp->retransmit_skb_hint)
		tp->retransmit_skb_hint = prev;
	if (skb == tp->lost_skb_hint) {
		tp->lost_skb_hint = prev;
		tp->lost_cnt_hint -= tcp_skb_pcount(prev);
	}

1302 1303 1304 1305
	TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
		TCP_SKB_CB(prev)->end_seq++;

1306 1307 1308 1309 1310 1311
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

	tcp_unlink_write_queue(skb, sk);
	sk_wmem_free_skb(sk, skb);

1312 1313
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKMERGED);

E
Eric Dumazet 已提交
1314
	return true;
1315 1316 1317 1318 1319
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1320
static int tcp_skb_seglen(const struct sk_buff *skb)
1321
{
1322
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1323 1324 1325
}

/* Shifting pages past head area doesn't work */
1326
static int skb_can_shift(const struct sk_buff *skb)
1327 1328 1329 1330 1331 1332 1333 1334
{
	return !skb_headlen(skb) && skb_is_nonlinear(skb);
}

/* Try collapsing SACK blocks spanning across multiple skbs to a single
 * skb.
 */
static struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb,
1335
					  struct tcp_sacktag_state *state,
1336
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1337
					  bool dup_sack)
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *prev;
	int mss;
	int pcount = 0;
	int len;
	int in_sack;

	if (!sk_can_gso(sk))
		goto fallback;

	/* Normally R but no L won't result in plain S */
	if (!dup_sack &&
1351
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
		goto fallback;
	if (!skb_can_shift(skb))
		goto fallback;
	/* This frame is about to be dropped (was ACKed). */
	if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
		goto fallback;

	/* Can only happen with delayed DSACK + discard craziness */
	if (unlikely(skb == tcp_write_queue_head(sk)))
		goto fallback;
	prev = tcp_write_queue_prev(sk, skb);

	if ((TCP_SKB_CB(prev)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED)
		goto fallback;

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

	if (in_sack) {
		len = skb->len;
		pcount = tcp_skb_pcount(skb);
1373
		mss = tcp_skb_seglen(skb);
1374 1375 1376 1377

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1378
		if (mss != tcp_skb_seglen(prev))
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
			goto fallback;
	} else {
		if (!after(TCP_SKB_CB(skb)->end_seq, start_seq))
			goto noop;
		/* CHECKME: This is non-MSS split case only?, this will
		 * cause skipped skbs due to advancing loop btw, original
		 * has that feature too
		 */
		if (tcp_skb_pcount(skb) <= 1)
			goto noop;

		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);
		if (!in_sack) {
			/* TODO: head merge to next could be attempted here
			 * if (!after(TCP_SKB_CB(skb)->end_seq, end_seq)),
			 * though it might not be worth of the additional hassle
			 *
			 * ...we can probably just fallback to what was done
			 * previously. We could try merging non-SACKed ones
			 * as well but it probably isn't going to buy off
			 * because later SACKs might again split them, and
			 * it would make skb timestamp tracking considerably
			 * harder problem.
			 */
			goto fallback;
		}

		len = end_seq - TCP_SKB_CB(skb)->seq;
		BUG_ON(len < 0);
		BUG_ON(len > skb->len);

		/* MSS boundaries should be honoured or else pcount will
		 * severely break even though it makes things bit trickier.
		 * Optimize common case to avoid most of the divides
		 */
		mss = tcp_skb_mss(skb);

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1419
		if (mss != tcp_skb_seglen(prev))
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
			goto fallback;

		if (len == mss) {
			pcount = 1;
		} else if (len < mss) {
			goto noop;
		} else {
			pcount = len / mss;
			len = pcount * mss;
		}
	}

1432 1433 1434 1435
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1436 1437
	if (!skb_shift(prev, skb, len))
		goto fallback;
I
Ilpo Järvinen 已提交
1438
	if (!tcp_shifted_skb(sk, skb, state, pcount, len, mss, dup_sack))
1439 1440 1441 1442 1443 1444 1445 1446 1447
		goto out;

	/* Hole filled allows collapsing with the next as well, this is very
	 * useful when hole on every nth skb pattern happens
	 */
	if (prev == tcp_write_queue_tail(sk))
		goto out;
	skb = tcp_write_queue_next(sk, prev);

1448 1449 1450
	if (!skb_can_shift(skb) ||
	    (skb == tcp_send_head(sk)) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1451
	    (mss != tcp_skb_seglen(skb)))
1452 1453 1454 1455 1456
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
I
Ilpo Järvinen 已提交
1457
		tcp_shifted_skb(sk, skb, state, tcp_skb_pcount(skb), len, mss, 0);
1458 1459 1460
	}

out:
1461
	state->fack_count += pcount;
1462 1463 1464 1465 1466 1467
	return prev;

noop:
	return skb;

fallback:
1468
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1469 1470 1471
	return NULL;
}

1472 1473
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1474
					struct tcp_sacktag_state *state,
1475
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1476
					bool dup_sack_in)
1477
{
1478 1479 1480
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1481 1482
	tcp_for_write_queue_from(skb, sk) {
		int in_sack = 0;
E
Eric Dumazet 已提交
1483
		bool dup_sack = dup_sack_in;
1484 1485 1486 1487 1488 1489 1490 1491

		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;

1492
		if (next_dup  &&
1493 1494 1495 1496 1497
		    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)
E
Eric Dumazet 已提交
1498
				dup_sack = true;
1499 1500
		}

1501 1502 1503 1504 1505
		/* skb reference here is a bit tricky to get right, since
		 * shifting can eat and free both this skb and the next,
		 * so not even _safe variant of the loop is enough.
		 */
		if (in_sack <= 0) {
1506 1507
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1508
			if (tmp) {
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

				in_sack = 0;
			} else {
				in_sack = tcp_match_skb_to_sack(sk, skb,
								start_seq,
								end_seq);
			}
		}

1522 1523 1524
		if (unlikely(in_sack < 0))
			break;

1525
		if (in_sack) {
1526 1527 1528 1529 1530 1531 1532
			TCP_SKB_CB(skb)->sacked =
				tcp_sacktag_one(sk,
						state,
						TCP_SKB_CB(skb)->sacked,
						TCP_SKB_CB(skb)->seq,
						TCP_SKB_CB(skb)->end_seq,
						dup_sack,
Y
Yuchung Cheng 已提交
1533
						tcp_skb_pcount(skb),
1534
						&skb->skb_mstamp);
1535

1536 1537 1538 1539 1540
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}

1541
		state->fack_count += tcp_skb_pcount(skb);
1542 1543 1544 1545 1546 1547 1548 1549
	}
	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,
1550 1551
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1552 1553 1554 1555 1556
{
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;

I
Ilpo Järvinen 已提交
1557
		if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq))
1558
			break;
1559

1560
		state->fack_count += tcp_skb_pcount(skb);
1561 1562 1563 1564 1565 1566 1567
	}
	return skb;
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1568 1569
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1570
{
1571
	if (!next_dup)
1572 1573 1574
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1575 1576 1577 1578
		skb = tcp_sacktag_skip(skb, sk, state, next_dup->start_seq);
		skb = tcp_sacktag_walk(skb, sk, NULL, state,
				       next_dup->start_seq, next_dup->end_seq,
				       1);
1579 1580 1581 1582 1583
	}

	return skb;
}

1584
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1585 1586 1587 1588
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1589
static int
1590
tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
1591
			u32 prior_snd_una, struct tcp_sacktag_state *state)
L
Linus Torvalds 已提交
1592 1593
{
	struct tcp_sock *tp = tcp_sk(sk);
1594 1595
	const unsigned char *ptr = (skb_transport_header(ack_skb) +
				    TCP_SKB_CB(ack_skb)->sacked);
1596
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1597
	struct tcp_sack_block sp[TCP_NUM_SACKS];
1598 1599
	struct tcp_sack_block *cache;
	struct sk_buff *skb;
1600
	int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1601
	int used_sacks;
E
Eric Dumazet 已提交
1602
	bool found_dup_sack = false;
1603
	int i, j;
1604
	int first_sack_index;
L
Linus Torvalds 已提交
1605

1606 1607
	state->flag = 0;
	state->reord = tp->packets_out;
1608

1609
	if (!tp->sacked_out) {
1610 1611
		if (WARN_ON(tp->fackets_out))
			tp->fackets_out = 0;
1612
		tcp_highest_sack_reset(sk);
1613
	}
L
Linus Torvalds 已提交
1614

1615
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1616 1617
					 num_sacks, prior_snd_una);
	if (found_dup_sack)
1618
		state->flag |= FLAG_DSACKING_ACK;
1619 1620 1621 1622 1623 1624 1625 1626

	/* 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;

1627 1628 1629
	if (!tp->packets_out)
		goto out;

1630 1631 1632
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
E
Eric Dumazet 已提交
1633
		bool dup_sack = !i && found_dup_sack;
1634

1635 1636
		sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq);
		sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq);
1637 1638 1639 1640

		if (!tcp_is_sackblock_valid(tp, dup_sack,
					    sp[used_sacks].start_seq,
					    sp[used_sacks].end_seq)) {
1641 1642
			int mib_idx;

1643 1644
			if (dup_sack) {
				if (!tp->undo_marker)
1645
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1646
				else
1647
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1648 1649 1650 1651 1652
			} 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;
1653
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1654
			}
1655

1656
			NET_INC_STATS_BH(sock_net(sk), mib_idx);
1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
			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++;
	}

1669 1670
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1671 1672
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1673
				swap(sp[j], sp[j + 1]);
1674

1675 1676
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1677
					first_sack_index = j + 1;
1678 1679 1680 1681
			}
		}
	}

1682
	skb = tcp_write_queue_head(sk);
1683
	state->fack_count = 0;
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
	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++;
1695 1696
	}

1697
	while (i < used_sacks) {
1698 1699
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
E
Eric Dumazet 已提交
1700
		bool dup_sack = (found_dup_sack && (i == first_sack_index));
1701
		struct tcp_sack_block *next_dup = NULL;
1702

1703 1704
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1705

1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
		/* 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)) {
1717
				skb = tcp_sacktag_skip(skb, sk, state,
1718
						       start_seq);
1719
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1720
						       state,
1721 1722
						       start_seq,
						       cache->start_seq,
1723
						       dup_sack);
1724
			}
1725

1726
			/* Rest of the block already fully processed? */
1727
			if (!after(end_seq, cache->end_seq))
1728
				goto advance_sp;
1729

1730
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1731
						       state,
1732
						       cache->end_seq);
1733

1734
			/* ...tail remains todo... */
1735
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1736
				/* ...but better entrypoint exists! */
1737
				skb = tcp_highest_sack(sk);
1738
				if (!skb)
1739
					break;
1740
				state->fack_count = tp->fackets_out;
1741 1742
				cache++;
				goto walk;
1743 1744
			}

1745
			skb = tcp_sacktag_skip(skb, sk, state, cache->end_seq);
1746 1747 1748 1749
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1750

1751 1752
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
1753
			if (!skb)
1754
				break;
1755
			state->fack_count = tp->fackets_out;
L
Linus Torvalds 已提交
1756
		}
1757
		skb = tcp_sacktag_skip(skb, sk, state, start_seq);
1758 1759

walk:
1760
		skb = tcp_sacktag_walk(skb, sk, next_dup, state,
1761
				       start_seq, end_seq, dup_sack);
1762

1763 1764
advance_sp:
		i++;
L
Linus Torvalds 已提交
1765 1766
	}

1767 1768 1769 1770 1771 1772 1773 1774
	/* 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];

1775
	if ((state->reord < tp->fackets_out) &&
Y
Yuchung Cheng 已提交
1776
	    ((inet_csk(sk)->icsk_ca_state != TCP_CA_Loss) || tp->undo_marker))
1777
		tcp_update_reordering(sk, tp->fackets_out - state->reord, 0);
L
Linus Torvalds 已提交
1778

1779
	tcp_verify_left_out(tp);
1780 1781
out:

L
Linus Torvalds 已提交
1782
#if FASTRETRANS_DEBUG > 0
1783 1784 1785 1786
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
	WARN_ON((int)tcp_packets_in_flight(tp) < 0);
L
Linus Torvalds 已提交
1787
#endif
1788
	return state->flag;
L
Linus Torvalds 已提交
1789 1790
}

1791
/* Limits sacked_out so that sum with lost_out isn't ever larger than
E
Eric Dumazet 已提交
1792
 * packets_out. Returns false if sacked_out adjustement wasn't necessary.
1793
 */
E
Eric Dumazet 已提交
1794
static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
1795 1796 1797 1798 1799 1800 1801 1802
{
	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;
E
Eric Dumazet 已提交
1803
		return true;
1804
	}
E
Eric Dumazet 已提交
1805
	return false;
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
}

/* 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.
 */
static void tcp_check_reno_reordering(struct sock *sk, const int addend)
{
	struct tcp_sock *tp = tcp_sk(sk);
	if (tcp_limit_reno_sacked(tp))
		tcp_update_reordering(sk, tp->packets_out + addend, 0);
1817 1818 1819 1820 1821 1822 1823 1824 1825
}

/* 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);
1826
	tcp_verify_left_out(tp);
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
}

/* 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. */
1837
		if (acked - 1 >= tp->sacked_out)
1838 1839
			tp->sacked_out = 0;
		else
1840
			tp->sacked_out -= acked - 1;
1841 1842
	}
	tcp_check_reno_reordering(sk, acked);
1843
	tcp_verify_left_out(tp);
1844 1845 1846 1847 1848 1849 1850
}

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

Y
Yuchung Cheng 已提交
1851
void tcp_clear_retrans(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1852 1853 1854 1855
{
	tp->retrans_out = 0;
	tp->lost_out = 0;
	tp->undo_marker = 0;
Y
Yuchung Cheng 已提交
1856
	tp->undo_retrans = -1;
Y
Yuchung Cheng 已提交
1857 1858
	tp->fackets_out = 0;
	tp->sacked_out = 0;
L
Linus Torvalds 已提交
1859 1860
}

Y
Yuchung Cheng 已提交
1861
static inline void tcp_init_undo(struct tcp_sock *tp)
1862
{
Y
Yuchung Cheng 已提交
1863 1864 1865
	tp->undo_marker = tp->snd_una;
	/* Retransmission still in flight may cause DSACKs later. */
	tp->undo_retrans = tp->retrans_out ? : -1;
1866 1867
}

1868
/* Enter Loss state. If we detect SACK reneging, forget all SACK information
L
Linus Torvalds 已提交
1869 1870 1871
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
1872
void tcp_enter_loss(struct sock *sk)
L
Linus Torvalds 已提交
1873
{
1874
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1875 1876
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;
1877
	bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
1878
	bool is_reneg;			/* is receiver reneging on SACKs? */
L
Linus Torvalds 已提交
1879 1880

	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1881 1882
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1883 1884 1885 1886
	    (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);
Y
Yuchung Cheng 已提交
1887
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1888 1889 1890 1891 1892
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;

Y
Yuchung Cheng 已提交
1893 1894
	tp->retrans_out = 0;
	tp->lost_out = 0;
1895 1896 1897

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

1899 1900 1901 1902
	skb = tcp_write_queue_head(sk);
	is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
	if (is_reneg) {
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
1903 1904
		tp->sacked_out = 0;
		tp->fackets_out = 0;
1905
	}
1906
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
1907

1908 1909 1910
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1911

L
Linus Torvalds 已提交
1912
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
1913
		if (!(TCP_SKB_CB(skb)->sacked&TCPCB_SACKED_ACKED) || is_reneg) {
L
Linus Torvalds 已提交
1914 1915 1916
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
1917
			tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
L
Linus Torvalds 已提交
1918 1919
		}
	}
1920
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1921

1922 1923 1924 1925 1926 1927 1928
	/* Timeout in disordered state after receiving substantial DUPACKs
	 * suggests that the degree of reordering is over-estimated.
	 */
	if (icsk->icsk_ca_state <= TCP_CA_Disorder &&
	    tp->sacked_out >= sysctl_tcp_reordering)
		tp->reordering = min_t(unsigned int, tp->reordering,
				       sysctl_tcp_reordering);
1929
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1930
	tp->high_seq = tp->snd_nxt;
1931
	tcp_ecn_queue_cwr(tp);
Y
Yuchung Cheng 已提交
1932 1933 1934 1935 1936 1937 1938 1939

	/* F-RTO RFC5682 sec 3.1 step 1: retransmit SND.UNA if no previous
	 * loss recovery is underway except recurring timeout(s) on
	 * the same SND.UNA (sec 3.2). Disable F-RTO on path MTU probing
	 */
	tp->frto = sysctl_tcp_frto &&
		   (new_recovery || icsk->icsk_retransmits) &&
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
1940 1941
}

1942 1943 1944 1945
/* 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).
 *
1946 1947 1948 1949 1950
 * To avoid big spurious retransmission bursts due to transient SACK
 * scoreboard oddities that look like reneging, we give the receiver a
 * little time (max(RTT/2, 10ms)) to send us some more ACKs that will
 * restore sanity to the SACK scoreboard. If the apparent reneging
 * persists until this RTO then we'll clear the SACK scoreboard.
1951
 */
E
Eric Dumazet 已提交
1952
static bool tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
1953
{
1954
	if (flag & FLAG_SACK_RENEGING) {
1955 1956 1957
		struct tcp_sock *tp = tcp_sk(sk);
		unsigned long delay = max(usecs_to_jiffies(tp->srtt_us >> 4),
					  msecs_to_jiffies(10));
L
Linus Torvalds 已提交
1958

1959
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
1960
					  delay, TCP_RTO_MAX);
E
Eric Dumazet 已提交
1961
		return true;
L
Linus Torvalds 已提交
1962
	}
E
Eric Dumazet 已提交
1963
	return false;
L
Linus Torvalds 已提交
1964 1965
}

1966
static inline int tcp_fackets_out(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
1967
{
1968
	return tcp_is_reno(tp) ? tp->sacked_out + 1 : tp->fackets_out;
L
Linus Torvalds 已提交
1969 1970
}

1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
/* 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.
 */
1986
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
1987 1988 1989 1990
{
	return tcp_is_fack(tp) ? tp->fackets_out : tp->sacked_out + 1;
}

1991 1992 1993 1994 1995 1996 1997 1998 1999
static bool tcp_pause_early_retransmit(struct sock *sk, int flag)
{
	struct tcp_sock *tp = tcp_sk(sk);
	unsigned long delay;

	/* Delay early retransmit and entering fast recovery for
	 * max(RTT/4, 2msec) unless ack has ECE mark, no RTT samples
	 * available, or RTO is scheduled to fire first.
	 */
N
Nandita Dukkipati 已提交
2000
	if (sysctl_tcp_early_retrans < 2 || sysctl_tcp_early_retrans > 3 ||
2001
	    (flag & FLAG_ECE) || !tp->srtt_us)
2002 2003
		return false;

2004 2005 2006
	delay = max(usecs_to_jiffies(tp->srtt_us >> 5),
		    msecs_to_jiffies(2));

2007 2008 2009
	if (!time_after(inet_csk(sk)->icsk_timeout, (jiffies + delay)))
		return false;

N
Nandita Dukkipati 已提交
2010 2011
	inet_csk_reset_xmit_timer(sk, ICSK_TIME_EARLY_RETRANS, delay,
				  TCP_RTO_MAX);
2012 2013 2014
	return true;
}

L
Linus Torvalds 已提交
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 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107
/* 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?
 */
E
Eric Dumazet 已提交
2108
static bool tcp_time_to_recover(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2109
{
2110
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2111 2112 2113 2114
	__u32 packets_out;

	/* Trick#1: The loss is proven. */
	if (tp->lost_out)
E
Eric Dumazet 已提交
2115
		return true;
L
Linus Torvalds 已提交
2116 2117

	/* Not-A-Trick#2 : Classic rule... */
2118
	if (tcp_dupack_heuristics(tp) > tp->reordering)
E
Eric Dumazet 已提交
2119
		return true;
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125 2126

	/* 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) &&
2127
	    !tcp_may_send_now(sk)) {
L
Linus Torvalds 已提交
2128 2129 2130
		/* We have nothing to send. This connection is limited
		 * either by receiver window or by application.
		 */
E
Eric Dumazet 已提交
2131
		return true;
L
Linus Torvalds 已提交
2132 2133
	}

A
Andreas Petlund 已提交
2134 2135 2136 2137 2138 2139 2140 2141
	/* If a thin stream is detected, retransmit after first
	 * received dupack. Employ only if SACK is supported in order
	 * to avoid possible corner-case series of spurious retransmissions
	 * Use only if there are no unsent data.
	 */
	if ((tp->thin_dupack || sysctl_tcp_thin_dupack) &&
	    tcp_stream_is_thin(tp) && tcp_dupack_heuristics(tp) > 1 &&
	    tcp_is_sack(tp) && !tcp_send_head(sk))
E
Eric Dumazet 已提交
2142
		return true;
A
Andreas Petlund 已提交
2143

Y
Yuchung Cheng 已提交
2144 2145 2146 2147 2148 2149
	/* Trick#6: TCP early retransmit, per RFC5827.  To avoid spurious
	 * retransmissions due to small network reorderings, we implement
	 * Mitigation A.3 in the RFC and delay the retransmission for a short
	 * interval if appropriate.
	 */
	if (tp->do_early_retrans && !tp->retrans_out && tp->sacked_out &&
N
Nandita Dukkipati 已提交
2150
	    (tp->packets_out >= (tp->sacked_out + 1) && tp->packets_out < 4) &&
Y
Yuchung Cheng 已提交
2151
	    !tcp_may_send_now(sk))
2152
		return !tcp_pause_early_retransmit(sk, flag);
Y
Yuchung Cheng 已提交
2153

E
Eric Dumazet 已提交
2154
	return false;
L
Linus Torvalds 已提交
2155 2156
}

2157 2158 2159 2160 2161
/* Detect loss in event "A" above by marking head of queue up as lost.
 * For FACK or non-SACK(Reno) senders, the first "packets" number of segments
 * are considered lost. For RFC3517 SACK, a segment is considered lost if it
 * has at least tp->reordering SACKed seqments above it; "packets" refers to
 * the maximum SACKed segments to pass before reaching this limit.
2162
 */
I
Ilpo Järvinen 已提交
2163
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2164
{
2165
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2166
	struct sk_buff *skb;
2167
	int cnt, oldcnt, lost;
2168
	unsigned int mss;
2169 2170
	/* Use SACK to deduce losses of new sequences sent during recovery */
	const u32 loss_high = tcp_is_sack(tp) ?  tp->snd_nxt : tp->high_seq;
L
Linus Torvalds 已提交
2171

2172
	WARN_ON(packets > tp->packets_out);
2173 2174 2175
	if (tp->lost_skb_hint) {
		skb = tp->lost_skb_hint;
		cnt = tp->lost_cnt_hint;
I
Ilpo Järvinen 已提交
2176 2177 2178
		/* Head already handled? */
		if (mark_head && skb != tcp_write_queue_head(sk))
			return;
2179
	} else {
2180
		skb = tcp_write_queue_head(sk);
2181 2182
		cnt = 0;
	}
L
Linus Torvalds 已提交
2183

2184 2185 2186
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2187 2188 2189 2190
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2191

2192
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2193 2194 2195
			break;

		oldcnt = cnt;
2196
		if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
2197 2198 2199
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2200
		if (cnt > packets) {
2201
			if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) ||
2202
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2203
			    (oldcnt >= packets))
2204 2205
				break;

2206
			mss = tcp_skb_mss(skb);
2207 2208 2209 2210
			/* If needed, chop off the prefix to mark as lost. */
			lost = (packets - oldcnt) * mss;
			if (lost < skb->len &&
			    tcp_fragment(sk, skb, lost, mss, GFP_ATOMIC) < 0)
2211 2212 2213 2214
				break;
			cnt = packets;
		}

2215
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2216 2217 2218

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2219
	}
2220
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2221 2222 2223 2224
}

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

2225
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2226
{
2227 2228
	struct tcp_sock *tp = tcp_sk(sk);

2229
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2230
		tcp_mark_head_lost(sk, 1, 1);
2231
	} else if (tcp_is_fack(tp)) {
L
Linus Torvalds 已提交
2232 2233 2234
		int lost = tp->fackets_out - tp->reordering;
		if (lost <= 0)
			lost = 1;
I
Ilpo Järvinen 已提交
2235
		tcp_mark_head_lost(sk, lost, 0);
L
Linus Torvalds 已提交
2236
	} else {
2237
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2238 2239 2240 2241
		if (sacked_upto >= 0)
			tcp_mark_head_lost(sk, sacked_upto, 0);
		else if (fast_rexmit)
			tcp_mark_head_lost(sk, 1, 1);
L
Linus Torvalds 已提交
2242 2243 2244 2245 2246 2247 2248 2249 2250
	}
}

/* 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,
2251
			   tcp_packets_in_flight(tp) + tcp_max_burst(tp));
L
Linus Torvalds 已提交
2252 2253 2254
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

2255 2256 2257 2258 2259 2260
static bool tcp_tsopt_ecr_before(const struct tcp_sock *tp, u32 when)
{
	return tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
	       before(tp->rx_opt.rcv_tsecr, when);
}

2261 2262 2263 2264 2265 2266 2267 2268 2269 2270
/* skb is spurious retransmitted if the returned timestamp echo
 * reply is prior to the skb transmission time
 */
static bool tcp_skb_spurious_retrans(const struct tcp_sock *tp,
				     const struct sk_buff *skb)
{
	return (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS) &&
	       tcp_tsopt_ecr_before(tp, tcp_skb_timestamp(skb));
}

L
Linus Torvalds 已提交
2271 2272 2273
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2274
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2275 2276
{
	return !tp->retrans_stamp ||
2277
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2278 2279 2280 2281
}

/* Undo procedures. */

2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
/* We can clear retrans_stamp when there are no retransmissions in the
 * window. It would seem that it is trivially available for us in
 * tp->retrans_out, however, that kind of assumptions doesn't consider
 * what will happen if errors occur when sending retransmission for the
 * second time. ...It could the that such segment has only
 * TCPCB_EVER_RETRANS set at the present time. It seems that checking
 * the head skb is enough except for some reneging corner cases that
 * are not worth the effort.
 *
 * Main reason for all this complexity is the fact that connection dying
 * time now depends on the validity of the retrans_stamp, in particular,
 * that successive retransmissions of a segment must not advance
 * retrans_stamp under any conditions.
 */
static bool tcp_any_retrans_done(const struct sock *sk)
{
	const struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	if (tp->retrans_out)
		return true;

	skb = tcp_write_queue_head(sk);
	if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
		return true;

	return false;
}

L
Linus Torvalds 已提交
2311
#if FASTRETRANS_DEBUG > 1
2312
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2313
{
2314
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2315
	struct inet_sock *inet = inet_sk(sk);
2316

2317
	if (sk->sk_family == AF_INET) {
2318 2319 2320 2321 2322 2323
		pr_debug("Undo %s %pI4/%u c%u l%u ss%u/%u p%u\n",
			 msg,
			 &inet->inet_daddr, ntohs(inet->inet_dport),
			 tp->snd_cwnd, tcp_left_out(tp),
			 tp->snd_ssthresh, tp->prior_ssthresh,
			 tp->packets_out);
2324
	}
E
Eric Dumazet 已提交
2325
#if IS_ENABLED(CONFIG_IPV6)
2326 2327
	else if (sk->sk_family == AF_INET6) {
		struct ipv6_pinfo *np = inet6_sk(sk);
2328 2329 2330 2331 2332 2333
		pr_debug("Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
			 msg,
			 &np->daddr, ntohs(inet->inet_dport),
			 tp->snd_cwnd, tcp_left_out(tp),
			 tp->snd_ssthresh, tp->prior_ssthresh,
			 tp->packets_out);
2334 2335
	}
#endif
L
Linus Torvalds 已提交
2336 2337 2338 2339 2340
}
#else
#define DBGUNDO(x...) do { } while (0)
#endif

2341
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2342
{
2343 2344
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
	if (unmark_loss) {
		struct sk_buff *skb;

		tcp_for_write_queue(skb, sk) {
			if (skb == tcp_send_head(sk))
				break;
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
		tp->lost_out = 0;
		tcp_clear_all_retrans_hints(tp);
	}

L
Linus Torvalds 已提交
2357
	if (tp->prior_ssthresh) {
2358 2359 2360 2361
		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 已提交
2362
		else
2363
			tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);
L
Linus Torvalds 已提交
2364

2365
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2366
			tp->snd_ssthresh = tp->prior_ssthresh;
2367
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2368 2369 2370
		}
	}
	tp->snd_cwnd_stamp = tcp_time_stamp;
2371
	tp->undo_marker = 0;
L
Linus Torvalds 已提交
2372 2373
}

2374
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2375
{
2376
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2377 2378 2379
}

/* People celebrate: "We love our President!" */
E
Eric Dumazet 已提交
2380
static bool tcp_try_undo_recovery(struct sock *sk)
L
Linus Torvalds 已提交
2381
{
2382 2383
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2384
	if (tcp_may_undo(tp)) {
2385 2386
		int mib_idx;

L
Linus Torvalds 已提交
2387 2388 2389
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2390
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2391
		tcp_undo_cwnd_reduction(sk, false);
2392
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2393
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2394
		else
2395 2396
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2397
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
2398
	}
2399
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2400 2401 2402 2403
		/* 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);
2404 2405
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2406
		return true;
L
Linus Torvalds 已提交
2407
	}
2408
	tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2409
	return false;
L
Linus Torvalds 已提交
2410 2411 2412
}

/* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
2413
static bool tcp_try_undo_dsack(struct sock *sk)
L
Linus Torvalds 已提交
2414
{
2415 2416
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2417
	if (tp->undo_marker && !tp->undo_retrans) {
2418
		DBGUNDO(sk, "D-SACK");
2419
		tcp_undo_cwnd_reduction(sk, false);
2420
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2421
		return true;
L
Linus Torvalds 已提交
2422
	}
2423
	return false;
L
Linus Torvalds 已提交
2424 2425
}

Y
Yuchung Cheng 已提交
2426 2427
/* Undo during loss recovery after partial ACK or using F-RTO. */
static bool tcp_try_undo_loss(struct sock *sk, bool frto_undo)
L
Linus Torvalds 已提交
2428
{
2429 2430
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2431
	if (frto_undo || tcp_may_undo(tp)) {
2432
		tcp_undo_cwnd_reduction(sk, true);
2433

2434
		DBGUNDO(sk, "partial loss");
2435
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2436 2437 2438
		if (frto_undo)
			NET_INC_STATS_BH(sock_net(sk),
					 LINUX_MIB_TCPSPURIOUSRTOS);
2439
		inet_csk(sk)->icsk_retransmits = 0;
Y
Yuchung Cheng 已提交
2440
		if (frto_undo || tcp_is_sack(tp))
2441
			tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2442
		return true;
L
Linus Torvalds 已提交
2443
	}
E
Eric Dumazet 已提交
2444
	return false;
L
Linus Torvalds 已提交
2445 2446
}

2447
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2448 2449 2450 2451
 * It computes the number of packets to send (sndcnt) based on packets newly
 * delivered:
 *   1) If the packets in flight is larger than ssthresh, PRR spreads the
 *	cwnd reductions across a full RTT.
2452 2453 2454
 *   2) Otherwise PRR uses packet conservation to send as much as delivered.
 *      But when the retransmits are acked without further losses, PRR
 *      slow starts cwnd up to ssthresh to speed up the recovery.
2455
 */
2456
static void tcp_init_cwnd_reduction(struct sock *sk)
2457 2458 2459 2460
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2461
	tp->tlp_high_seq = 0;
2462 2463 2464 2465
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2466
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2467
	tcp_ecn_queue_cwr(tp);
2468 2469
}

2470
static void tcp_cwnd_reduction(struct sock *sk, const int prior_unsacked,
2471
			       int fast_rexmit, int flag)
2472 2473 2474 2475
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);
2476 2477
	int newly_acked_sacked = prior_unsacked -
				 (tp->packets_out - tp->sacked_out);
2478

2479 2480 2481
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2482
	tp->prr_delivered += newly_acked_sacked;
2483
	if (delta < 0) {
2484 2485 2486
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2487 2488
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2489 2490 2491
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2492 2493
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2494 2495 2496 2497 2498
	}
	sndcnt = max(sndcnt, (fast_rexmit ? 1 : 0));
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2499
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2500
{
2501
	struct tcp_sock *tp = tcp_sk(sk);
2502

2503 2504 2505 2506 2507
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
	if (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR ||
	    (tp->undo_marker && tp->snd_ssthresh < TCP_INFINITE_SSTHRESH)) {
		tp->snd_cwnd = tp->snd_ssthresh;
		tp->snd_cwnd_stamp = tcp_time_stamp;
2508
	}
2509
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2510 2511
}

2512
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2513
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2514 2515 2516 2517
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2518
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2519
		tp->undo_marker = 0;
2520
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2521 2522 2523
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2524
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2525

2526 2527 2528 2529 2530
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2531
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2532 2533 2534 2535 2536 2537 2538 2539
		state = TCP_CA_Disorder;

	if (inet_csk(sk)->icsk_ca_state != state) {
		tcp_set_ca_state(sk, state);
		tp->high_seq = tp->snd_nxt;
	}
}

2540
static void tcp_try_to_open(struct sock *sk, int flag, const int prior_unsacked)
L
Linus Torvalds 已提交
2541
{
2542 2543
	struct tcp_sock *tp = tcp_sk(sk);

2544 2545
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2546
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2547 2548
		tp->retrans_stamp = 0;

2549
	if (flag & FLAG_ECE)
2550
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2551

2552
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2553
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2554
	} else {
2555
		tcp_cwnd_reduction(sk, prior_unsacked, 0, flag);
L
Linus Torvalds 已提交
2556 2557 2558
	}
}

J
John Heffner 已提交
2559 2560 2561 2562 2563 2564
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;
2565
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2566 2567
}

2568
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
{
	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;
2580
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2581 2582 2583 2584

	icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
	icsk->icsk_mtup.probe_size = 0;
	tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
2585
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMTUPSUCCESS);
J
John Heffner 已提交
2586 2587
}

2588 2589 2590 2591 2592 2593 2594 2595 2596
/* Do a simple retransmit without using the backoff mechanisms in
 * tcp_timer. This is used for path mtu discovery.
 * The socket is already locked here.
 */
void tcp_simple_retransmit(struct sock *sk)
{
	const struct inet_connection_sock *icsk = inet_csk(sk);
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;
I
Ilpo Järvinen 已提交
2597
	unsigned int mss = tcp_current_mss(sk);
2598 2599 2600 2601 2602
	u32 prior_lost = tp->lost_out;

	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2603
		if (tcp_skb_seglen(skb) > mss &&
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
		    !(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) {
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
				TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
				tp->retrans_out -= tcp_skb_pcount(skb);
			}
			tcp_skb_mark_lost_uncond_verify(tp, skb);
		}
	}

	tcp_clear_retrans_hints_partial(tp);

	if (prior_lost == tp->lost_out)
		return;

	if (tcp_is_reno(tp))
		tcp_limit_reno_sacked(tp);

	tcp_verify_left_out(tp);

	/* Don't muck with the congestion window here.
	 * Reason is that we do not increase amount of _data_
	 * in network, but units changed and effective
	 * cwnd/ssthresh really reduced now.
	 */
	if (icsk->icsk_ca_state != TCP_CA_Loss) {
		tp->high_seq = tp->snd_nxt;
		tp->snd_ssthresh = tcp_current_ssthresh(sk);
		tp->prior_ssthresh = 0;
		tp->undo_marker = 0;
		tcp_set_ca_state(sk, TCP_CA_Loss);
	}
	tcp_xmit_retransmit_queue(sk);
}
E
Eric Dumazet 已提交
2637
EXPORT_SYMBOL(tcp_simple_retransmit);
2638

2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651
static void tcp_enter_recovery(struct sock *sk, bool ece_ack)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int mib_idx;

	if (tcp_is_reno(tp))
		mib_idx = LINUX_MIB_TCPRENORECOVERY;
	else
		mib_idx = LINUX_MIB_TCPSACKRECOVERY;

	NET_INC_STATS_BH(sock_net(sk), mib_idx);

	tp->prior_ssthresh = 0;
Y
Yuchung Cheng 已提交
2652
	tcp_init_undo(tp);
2653

2654
	if (!tcp_in_cwnd_reduction(sk)) {
2655 2656
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2657
		tcp_init_cwnd_reduction(sk);
2658 2659 2660 2661
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2662 2663 2664
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
Y
Yuchung Cheng 已提交
2665
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack)
2666 2667
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2668
	bool recovered = !before(tp->snd_una, tp->high_seq);
2669

2670 2671 2672 2673
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

Y
Yuchung Cheng 已提交
2674
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2675 2676 2677
		/* Step 3.b. A timeout is spurious if not all data are
		 * lost, i.e., never-retransmitted data are (s)acked.
		 */
2678 2679
		if ((flag & FLAG_ORIG_SACK_ACKED) &&
		    tcp_try_undo_loss(sk, true))
Y
Yuchung Cheng 已提交
2680
			return;
2681

2682 2683 2684
		if (after(tp->snd_nxt, tp->high_seq)) {
			if (flag & FLAG_DATA_SACKED || is_dupack)
				tp->frto = 0; /* Step 3.a. loss was real */
Y
Yuchung Cheng 已提交
2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
		} else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
			tp->high_seq = tp->snd_nxt;
			__tcp_push_pending_frames(sk, tcp_current_mss(sk),
						  TCP_NAGLE_OFF);
			if (after(tp->snd_nxt, tp->high_seq))
				return; /* Step 2.b */
			tp->frto = 0;
		}
	}

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2697 2698 2699
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2700 2701 2702 2703 2704 2705 2706 2707 2708
	if (tcp_is_reno(tp)) {
		/* A Reno DUPACK means new data in F-RTO step 2.b above are
		 * delivered. Lower inflight to clock out (re)tranmissions.
		 */
		if (after(tp->snd_nxt, tp->high_seq) && is_dupack)
			tcp_add_reno_sack(sk);
		else if (flag & FLAG_SND_UNA_ADVANCED)
			tcp_reset_reno_sack(tp);
	}
2709 2710 2711
	tcp_xmit_retransmit_queue(sk);
}

Y
Yuchung Cheng 已提交
2712
/* Undo during fast recovery after partial ACK. */
2713
static bool tcp_try_undo_partial(struct sock *sk, const int acked,
2714
				 const int prior_unsacked, int flag)
Y
Yuchung Cheng 已提交
2715 2716 2717
{
	struct tcp_sock *tp = tcp_sk(sk);

2718
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2719 2720 2721
		/* Plain luck! Hole if filled with delayed
		 * packet, rather than with a retransmit.
		 */
2722 2723 2724 2725 2726 2727 2728 2729
		tcp_update_reordering(sk, tcp_fackets_out(tp) + acked, 1);

		/* We are getting evidence that the reordering degree is higher
		 * than we realized. If there are no retransmits out then we
		 * can undo. Otherwise we clock out new packets but do not
		 * mark more packets lost or retransmit more.
		 */
		if (tp->retrans_out) {
2730
			tcp_cwnd_reduction(sk, prior_unsacked, 0, flag);
2731 2732 2733
			return true;
		}

Y
Yuchung Cheng 已提交
2734 2735 2736
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2737 2738
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
Y
Yuchung Cheng 已提交
2739
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2740 2741
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2742
	}
2743
	return false;
Y
Yuchung Cheng 已提交
2744 2745
}

L
Linus Torvalds 已提交
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
/* 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().
 */
2757 2758
static void tcp_fastretrans_alert(struct sock *sk, const int acked,
				  const int prior_unsacked,
2759
				  bool is_dupack, int flag)
L
Linus Torvalds 已提交
2760
{
2761
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2762
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2763
	bool do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2764
				    (tcp_fackets_out(tp) > tp->reordering));
2765
	int fast_rexmit = 0;
L
Linus Torvalds 已提交
2766

2767
	if (WARN_ON(!tp->packets_out && tp->sacked_out))
L
Linus Torvalds 已提交
2768
		tp->sacked_out = 0;
I
Ilpo Järvinen 已提交
2769
	if (WARN_ON(!tp->sacked_out && tp->fackets_out))
L
Linus Torvalds 已提交
2770 2771
		tp->fackets_out = 0;

2772
	/* Now state machine starts.
L
Linus Torvalds 已提交
2773
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2774
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2775 2776 2777
		tp->prior_ssthresh = 0;

	/* B. In all the states check for reneging SACKs. */
2778
	if (tcp_check_sack_reneging(sk, flag))
L
Linus Torvalds 已提交
2779 2780
		return;

2781
	/* C. Check consistency of the current state. */
2782
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2783

2784
	/* D. Check state exit conditions. State can be terminated
L
Linus Torvalds 已提交
2785
	 *    when high_seq is ACKed. */
2786
	if (icsk->icsk_ca_state == TCP_CA_Open) {
2787
		WARN_ON(tp->retrans_out != 0);
L
Linus Torvalds 已提交
2788 2789
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
2790
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2791 2792 2793 2794
		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) {
2795
				tcp_end_cwnd_reduction(sk);
2796
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2797 2798 2799 2800
			}
			break;

		case TCP_CA_Recovery:
2801
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2802
				tcp_reset_reno_sack(tp);
2803
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2804
				return;
2805
			tcp_end_cwnd_reduction(sk);
L
Linus Torvalds 已提交
2806 2807 2808 2809
			break;
		}
	}

Y
Yuchung Cheng 已提交
2810 2811 2812 2813 2814
	/* Use RACK to detect loss */
	if (sysctl_tcp_recovery & TCP_RACK_LOST_RETRANS &&
	    tcp_rack_mark_lost(sk))
		flag |= FLAG_LOST_RETRANS;

2815
	/* E. Process state. */
2816
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2817
	case TCP_CA_Recovery:
2818
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
2819
			if (tcp_is_reno(tp) && is_dupack)
2820
				tcp_add_reno_sack(sk);
2821
		} else {
2822
			if (tcp_try_undo_partial(sk, acked, prior_unsacked, flag))
2823 2824 2825 2826 2827
				return;
			/* Partial ACK arrived. Force fast retransmit. */
			do_lost = tcp_is_reno(tp) ||
				  tcp_fackets_out(tp) > tp->reordering;
		}
2828 2829 2830 2831
		if (tcp_try_undo_dsack(sk)) {
			tcp_try_keep_open(sk);
			return;
		}
L
Linus Torvalds 已提交
2832 2833
		break;
	case TCP_CA_Loss:
Y
Yuchung Cheng 已提交
2834
		tcp_process_loss(sk, flag, is_dupack);
2835 2836
		if (icsk->icsk_ca_state != TCP_CA_Open &&
		    !(flag & FLAG_LOST_RETRANS))
L
Linus Torvalds 已提交
2837
			return;
2838
		/* Change state if cwnd is undone or retransmits are lost */
L
Linus Torvalds 已提交
2839
	default:
2840
		if (tcp_is_reno(tp)) {
2841
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
2842 2843
				tcp_reset_reno_sack(tp);
			if (is_dupack)
2844
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
2845 2846
		}

2847
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2848
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2849

2850
		if (!tcp_time_to_recover(sk, flag)) {
2851
			tcp_try_to_open(sk, flag, prior_unsacked);
L
Linus Torvalds 已提交
2852 2853 2854
			return;
		}

J
John Heffner 已提交
2855 2856 2857
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
2858
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
2859 2860 2861 2862 2863 2864 2865
			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 已提交
2866
		/* Otherwise enter Recovery state */
2867
		tcp_enter_recovery(sk, (flag & FLAG_ECE));
2868
		fast_rexmit = 1;
L
Linus Torvalds 已提交
2869 2870
	}

2871
	if (do_lost)
2872
		tcp_update_scoreboard(sk, fast_rexmit);
2873
	tcp_cwnd_reduction(sk, prior_unsacked, fast_rexmit, flag);
L
Linus Torvalds 已提交
2874 2875 2876
	tcp_xmit_retransmit_queue(sk);
}

2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
/* Kathleen Nichols' algorithm for tracking the minimum value of
 * a data stream over some fixed time interval. (E.g., the minimum
 * RTT over the past five minutes.) It uses constant space and constant
 * time per update yet almost always delivers the same minimum as an
 * implementation that has to keep all the data in the window.
 *
 * The algorithm keeps track of the best, 2nd best & 3rd best min
 * values, maintaining an invariant that the measurement time of the
 * n'th best >= n-1'th best. It also makes sure that the three values
 * are widely separated in the time window since that bounds the worse
 * case error when that data is monotonically increasing over the window.
 *
 * Upon getting a new min, we can forget everything earlier because it
 * has no value - the new min is <= everything else in the window by
 * definition and it's the most recent. So we restart fresh on every new min
 * and overwrites 2nd & 3rd choices. The same property holds for 2nd & 3rd
 * best.
 */
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us)
{
	const u32 now = tcp_time_stamp, wlen = sysctl_tcp_min_rtt_wlen * HZ;
	struct rtt_meas *m = tcp_sk(sk)->rtt_min;
	struct rtt_meas rttm = { .rtt = (rtt_us ? : 1), .ts = now };
	u32 elapsed;

	/* Check if the new measurement updates the 1st, 2nd, or 3rd choices */
	if (unlikely(rttm.rtt <= m[0].rtt))
		m[0] = m[1] = m[2] = rttm;
	else if (rttm.rtt <= m[1].rtt)
		m[1] = m[2] = rttm;
	else if (rttm.rtt <= m[2].rtt)
		m[2] = rttm;

	elapsed = now - m[0].ts;
	if (unlikely(elapsed > wlen)) {
		/* Passed entire window without a new min so make 2nd choice
		 * the new min & 3rd choice the new 2nd. So forth and so on.
		 */
		m[0] = m[1];
		m[1] = m[2];
		m[2] = rttm;
		if (now - m[0].ts > wlen) {
			m[0] = m[1];
			m[1] = rttm;
			if (now - m[0].ts > wlen)
				m[0] = rttm;
		}
	} else if (m[1].ts == m[0].ts && elapsed > wlen / 4) {
		/* Passed a quarter of the window without a new min so
		 * take 2nd choice from the 2nd quarter of the window.
		 */
		m[2] = m[1] = rttm;
	} else if (m[2].ts == m[1].ts && elapsed > wlen / 2) {
		/* Passed half the window without a new min so take the 3rd
		 * choice from the last half of the window.
		 */
		m[2] = rttm;
	}
}

Y
Yuchung Cheng 已提交
2937
static inline bool tcp_ack_update_rtt(struct sock *sk, const int flag,
2938 2939
				      long seq_rtt_us, long sack_rtt_us,
				      long ca_rtt_us)
2940
{
2941 2942 2943 2944 2945 2946 2947
	const struct tcp_sock *tp = tcp_sk(sk);

	/* Prefer RTT measured from ACK's timing to TS-ECR. This is because
	 * broken middle-boxes or peers may corrupt TS-ECR fields. But
	 * Karn's algorithm forbids taking RTT if some retransmitted data
	 * is acked (RFC6298).
	 */
2948 2949
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2950

L
Linus Torvalds 已提交
2951 2952 2953 2954 2955 2956
	/* 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.
	 */
2957
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2958
	    flag & FLAG_ACKED)
2959 2960
		seq_rtt_us = ca_rtt_us = jiffies_to_usecs(tcp_time_stamp -
							  tp->rx_opt.rcv_tsecr);
2961
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2962
		return false;
L
Linus Torvalds 已提交
2963

2964 2965 2966 2967 2968
	/* ca_rtt_us >= 0 is counting on the invariant that ca_rtt_us is
	 * always taken together with ACK, SACK, or TS-opts. Any negative
	 * values will be skipped with the seq_rtt_us < 0 check above.
	 */
	tcp_update_rtt_min(sk, ca_rtt_us);
2969
	tcp_rtt_estimator(sk, seq_rtt_us);
2970
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2971

2972 2973
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2974
	return true;
L
Linus Torvalds 已提交
2975 2976
}

2977
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2978
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2979
{
Y
Yuchung Cheng 已提交
2980
	long rtt_us = -1L;
2981

Y
Yuchung Cheng 已提交
2982 2983
	if (req && !req->num_retrans && tcp_rsk(req)->snt_synack.v64) {
		struct skb_mstamp now;
2984

Y
Yuchung Cheng 已提交
2985 2986 2987 2988
		skb_mstamp_get(&now);
		rtt_us = skb_mstamp_us_delta(&now, &tcp_rsk(req)->snt_synack);
	}

2989
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us);
2990 2991
}

Y
Yuchung Cheng 已提交
2992

2993
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2994
{
2995
	const struct inet_connection_sock *icsk = inet_csk(sk);
2996 2997

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2998
	tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
L
Linus Torvalds 已提交
2999 3000 3001 3002 3003
}

/* Restart timer after forward progress on connection.
 * RFC2988 recommends to restart timer to now+rto.
 */
3004
void tcp_rearm_rto(struct sock *sk)
L
Linus Torvalds 已提交
3005
{
N
Nandita Dukkipati 已提交
3006
	const struct inet_connection_sock *icsk = inet_csk(sk);
3007
	struct tcp_sock *tp = tcp_sk(sk);
3008

3009 3010 3011 3012 3013 3014
	/* If the retrans timer is currently being used by Fast Open
	 * for SYN-ACK retrans purpose, stay put.
	 */
	if (tp->fastopen_rsk)
		return;

L
Linus Torvalds 已提交
3015
	if (!tp->packets_out) {
3016
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
3017
	} else {
3018 3019
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
N
Nandita Dukkipati 已提交
3020 3021
		if (icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
3022
			struct sk_buff *skb = tcp_write_queue_head(sk);
E
Eric Dumazet 已提交
3023 3024
			const u32 rto_time_stamp =
				tcp_skb_timestamp(skb) + rto;
3025 3026
			s32 delta = (s32)(rto_time_stamp - tcp_time_stamp);
			/* delta may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
3027
			 * when the retrans timer fires and is rescheduled.
3028 3029 3030 3031 3032 3033
			 */
			if (delta > 0)
				rto = delta;
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
3034
	}
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052
}

/* This function is called when the delayed ER timer fires. TCP enters
 * fast recovery and performs fast-retransmit.
 */
void tcp_resume_early_retransmit(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

	tcp_rearm_rto(sk);

	/* Stop if ER is disabled after the delayed ER timer is scheduled */
	if (!tp->do_early_retrans)
		return;

	tcp_enter_recovery(sk, false);
	tcp_update_scoreboard(sk, 1);
	tcp_xmit_retransmit_queue(sk);
L
Linus Torvalds 已提交
3053 3054
}

3055
/* If we get here, the whole TSO packet has not been acked. */
3056
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
3057 3058
{
	struct tcp_sock *tp = tcp_sk(sk);
3059
	u32 packets_acked;
L
Linus Torvalds 已提交
3060

3061
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3062 3063

	packets_acked = tcp_skb_pcount(skb);
3064
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3065 3066 3067 3068 3069
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3073
	return packets_acked;
L
Linus Torvalds 已提交
3074 3075
}

3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090
static void tcp_ack_tstamp(struct sock *sk, struct sk_buff *skb,
			   u32 prior_snd_una)
{
	const struct skb_shared_info *shinfo;

	/* Avoid cache line misses to get skb_shinfo() and shinfo->tx_flags */
	if (likely(!(sk->sk_tsflags & SOF_TIMESTAMPING_TX_ACK)))
		return;

	shinfo = skb_shinfo(skb);
	if ((shinfo->tx_flags & SKBTX_ACK_TSTAMP) &&
	    between(shinfo->tskey, prior_snd_una, tcp_sk(sk)->snd_una - 1))
		__skb_tstamp_tx(skb, NULL, sk, SCM_TSTAMP_ACK);
}

3091 3092 3093 3094
/* 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.
 */
I
Ilpo Järvinen 已提交
3095
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
3096 3097
			       u32 prior_snd_una,
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3098
{
3099
	const struct inet_connection_sock *icsk = inet_csk(sk);
3100 3101 3102 3103
	struct skb_mstamp first_ackt, last_ackt, now;
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
	u32 reord = tp->packets_out;
3104
	bool fully_acked = true;
3105
	long sack_rtt_us = -1L;
3106
	long seq_rtt_us = -1L;
3107
	long ca_rtt_us = -1L;
3108
	struct sk_buff *skb;
3109
	u32 pkts_acked = 0;
3110
	bool rtt_update;
3111 3112 3113
	int flag = 0;

	first_ackt.v64 = 0;
L
Linus Torvalds 已提交
3114

3115
	while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
3116
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3117
		u8 sacked = scb->sacked;
3118
		u32 acked_pcount;
L
Linus Torvalds 已提交
3119

3120
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3121

3122
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3123
		if (after(scb->end_seq, tp->snd_una)) {
3124 3125 3126 3127
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3128 3129
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3130 3131
				break;

E
Eric Dumazet 已提交
3132
			fully_acked = false;
3133
		} else {
3134 3135
			/* Speedup tcp_unlink_write_queue() and next loop */
			prefetchw(skb->next);
3136
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3137 3138
		}

3139
		if (unlikely(sacked & TCPCB_RETRANS)) {
3140
			if (sacked & TCPCB_SACKED_RETRANS)
3141
				tp->retrans_out -= acked_pcount;
3142
			flag |= FLAG_RETRANS_DATA_ACKED;
3143
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3144
			last_ackt = skb->skb_mstamp;
E
Eric Dumazet 已提交
3145
			WARN_ON_ONCE(last_ackt.v64 == 0);
3146 3147 3148
			if (!first_ackt.v64)
				first_ackt = last_ackt;

3149 3150 3151
			reord = min(pkts_acked, reord);
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3152
		}
3153 3154

		if (sacked & TCPCB_SACKED_ACKED)
3155
			tp->sacked_out -= acked_pcount;
3156 3157
		else if (tcp_is_sack(tp) && !tcp_skb_spurious_retrans(tp, skb))
			tcp_rack_advance(tp, &skb->skb_mstamp, sacked);
3158
		if (sacked & TCPCB_LOST)
3159
			tp->lost_out -= acked_pcount;
3160

3161 3162
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3163

3164 3165 3166 3167 3168 3169 3170
		/* 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.
		 */
3171
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3172 3173 3174 3175 3176 3177
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3178 3179 3180
		if (!fully_acked)
			break;

3181
		tcp_unlink_write_queue(skb, sk);
3182
		sk_wmem_free_skb(sk, skb);
3183
		if (unlikely(skb == tp->retransmit_skb_hint))
3184
			tp->retransmit_skb_hint = NULL;
3185
		if (unlikely(skb == tp->lost_skb_hint))
3186
			tp->lost_skb_hint = NULL;
L
Linus Torvalds 已提交
3187 3188
	}

I
Ilpo Järvinen 已提交
3189 3190 3191
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3192 3193 3194
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3195
	skb_mstamp_get(&now);
3196
	if (likely(first_ackt.v64) && !(flag & FLAG_RETRANS_DATA_ACKED)) {
3197
		seq_rtt_us = skb_mstamp_us_delta(&now, &first_ackt);
3198 3199 3200 3201 3202
		ca_rtt_us = skb_mstamp_us_delta(&now, &last_ackt);
	}
	if (sack->first_sackt.v64) {
		sack_rtt_us = skb_mstamp_us_delta(&now, &sack->first_sackt);
		ca_rtt_us = skb_mstamp_us_delta(&now, &sack->last_sackt);
3203 3204
	}

3205 3206
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
					ca_rtt_us);
Y
Yuchung Cheng 已提交
3207

3208
	if (flag & FLAG_ACKED) {
3209
		tcp_rearm_rto(sk);
3210 3211 3212 3213 3214
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3215 3216 3217
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3218 3219
			int delta;

3220 3221 3222
			/* Non-retransmitted hole got filled? That's reordering */
			if (reord < prior_fackets)
				tcp_update_reordering(sk, tp->fackets_out - reord, 0);
3223

3224 3225 3226
			delta = tcp_is_fack(tp) ? pkts_acked :
						  prior_sacked - tp->sacked_out;
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3227 3228
		}

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

3231 3232
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
		   sack_rtt_us > skb_mstamp_us_delta(&now, &skb->skb_mstamp)) {
3233 3234 3235 3236 3237
		/* Do not re-arm RTO if the sack RTT is measured from data sent
		 * after when the head was last (re)transmitted. Otherwise the
		 * timeout may continue to extend in loss recovery.
		 */
		tcp_rearm_rto(sk);
L
Linus Torvalds 已提交
3238 3239
	}

3240 3241 3242
	if (icsk->icsk_ca_ops->pkts_acked)
		icsk->icsk_ca_ops->pkts_acked(sk, pkts_acked, ca_rtt_us);

L
Linus Torvalds 已提交
3243
#if FASTRETRANS_DEBUG > 0
3244 3245 3246
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
3247
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
3248
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3249
		if (tp->lost_out) {
3250 3251
			pr_debug("Leak l=%u %d\n",
				 tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3252 3253 3254
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
3255 3256
			pr_debug("Leak s=%u %d\n",
				 tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3257 3258 3259
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
3260 3261
			pr_debug("Leak r=%u %d\n",
				 tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3262 3263 3264 3265
			tp->retrans_out = 0;
		}
	}
#endif
3266
	return flag;
L
Linus Torvalds 已提交
3267 3268 3269 3270
}

static void tcp_ack_probe(struct sock *sk)
{
3271 3272
	const struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3273 3274 3275

	/* Was it a usable window open? */

3276
	if (!after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
3277 3278
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3279 3280 3281 3282
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3283
		unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3284

3285
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3286
					  when, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3287 3288 3289
	}
}

3290
static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3291
{
E
Eric Dumazet 已提交
3292 3293
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3294 3295
}

3296
/* Decide wheather to run the increase function of congestion control. */
3297
static inline bool tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3298
{
3299 3300 3301 3302 3303
	if (tcp_in_cwnd_reduction(sk))
		return false;

	/* If reordering is high then always grow cwnd whenever data is
	 * delivered regardless of its ordering. Otherwise stay conservative
3304
	 * and only grow cwnd on in-order delivery (RFC5681). A stretched ACK w/
3305 3306 3307 3308 3309 3310
	 * new SACK or ECE mark may first advance cwnd here and later reduce
	 * cwnd in tcp_fastretrans_alert() based on more states.
	 */
	if (tcp_sk(sk)->reordering > sysctl_tcp_reordering)
		return flag & FLAG_FORWARD_PROGRESS;

3311
	return flag & FLAG_DATA_ACKED;
L
Linus Torvalds 已提交
3312 3313 3314 3315 3316
}

/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
3317
static inline bool tcp_may_update_window(const struct tcp_sock *tp,
3318 3319
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
3320
{
E
Eric Dumazet 已提交
3321
	return	after(ack, tp->snd_una) ||
L
Linus Torvalds 已提交
3322
		after(ack_seq, tp->snd_wl1) ||
E
Eric Dumazet 已提交
3323
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
L
Linus Torvalds 已提交
3324 3325
}

3326 3327 3328 3329 3330
/* If we update tp->snd_una, also update tp->bytes_acked */
static void tcp_snd_una_update(struct tcp_sock *tp, u32 ack)
{
	u32 delta = ack - tp->snd_una;

3331
	u64_stats_update_begin(&tp->syncp);
3332
	tp->bytes_acked += delta;
3333
	u64_stats_update_end(&tp->syncp);
3334 3335 3336
	tp->snd_una = ack;
}

3337 3338 3339 3340 3341
/* If we update tp->rcv_nxt, also update tp->bytes_received */
static void tcp_rcv_nxt_update(struct tcp_sock *tp, u32 seq)
{
	u32 delta = seq - tp->rcv_nxt;

3342
	u64_stats_update_begin(&tp->syncp);
3343
	tp->bytes_received += delta;
3344
	u64_stats_update_end(&tp->syncp);
3345 3346 3347
	tp->rcv_nxt = seq;
}

L
Linus Torvalds 已提交
3348 3349 3350 3351 3352
/* 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.
 */
3353
static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,
3354
				 u32 ack_seq)
L
Linus Torvalds 已提交
3355
{
3356
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3357
	int flag = 0;
3358
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
3359

3360
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
3361 3362 3363 3364
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
3365
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3366 3367 3368 3369 3370 3371 3372

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

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

3376 3377 3378
			if (tcp_send_head(sk))
				tcp_slow_start_after_idle_check(sk);

L
Linus Torvalds 已提交
3379 3380
			if (nwin > tp->max_window) {
				tp->max_window = nwin;
3381
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
3382 3383 3384 3385
			}
		}
	}

3386
	tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3387 3388 3389 3390

	return flag;
}

3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
/* Return true if we're currently rate-limiting out-of-window ACKs and
 * thus shouldn't send a dupack right now. We rate-limit dupacks in
 * response to out-of-window SYNs or ACKs to mitigate ACK loops or DoS
 * attacks that send repeated SYNs or ACKs for the same connection. To
 * do this, we do not send a duplicate SYNACK or ACK if the remote
 * endpoint is sending out-of-window SYNs or pure ACKs at a high rate.
 */
bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
			  int mib_idx, u32 *last_oow_ack_time)
{
	/* Data packets without SYNs are not likely part of an ACK loop. */
	if ((TCP_SKB_CB(skb)->seq != TCP_SKB_CB(skb)->end_seq) &&
	    !tcp_hdr(skb)->syn)
		goto not_rate_limited;

	if (*last_oow_ack_time) {
		s32 elapsed = (s32)(tcp_time_stamp - *last_oow_ack_time);

		if (0 <= elapsed && elapsed < sysctl_tcp_invalid_ratelimit) {
			NET_INC_STATS_BH(net, mib_idx);
			return true;	/* rate-limited: don't send yet! */
		}
	}

	*last_oow_ack_time = tcp_time_stamp;

not_rate_limited:
	return false;	/* not rate-limited: go ahead, send dupack now! */
}

3421
/* RFC 5961 7 [ACK Throttling] */
3422
static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
3423 3424 3425 3426
{
	/* unprotected vars, we dont care of overwrites */
	static u32 challenge_timestamp;
	static unsigned int challenge_count;
3427 3428 3429 3430 3431 3432 3433 3434
	struct tcp_sock *tp = tcp_sk(sk);
	u32 now;

	/* First check our per-socket dupack rate limit. */
	if (tcp_oow_rate_limited(sock_net(sk), skb,
				 LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
				 &tp->last_oow_ack_time))
		return;
3435

3436 3437
	/* Then check the check host-wide RFC 5961 rate limit. */
	now = jiffies / HZ;
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447
	if (now != challenge_timestamp) {
		challenge_timestamp = now;
		challenge_count = 0;
	}
	if (++challenge_count <= sysctl_tcp_challenge_ack_limit) {
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK);
		tcp_send_ack(sk);
	}
}

3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
static void tcp_store_ts_recent(struct tcp_sock *tp)
{
	tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
	tp->rx_opt.ts_recent_stamp = get_seconds();
}

static 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.
		 */

		if (tcp_paws_check(&tp->rx_opt, 0))
			tcp_store_ts_recent(tp);
	}
}

N
Nandita Dukkipati 已提交
3469
/* This routine deals with acks during a TLP episode.
3470 3471
 * We mark the end of a TLP episode on receiving TLP dupack or when
 * ack is after tlp_high_seq.
N
Nandita Dukkipati 已提交
3472 3473 3474 3475 3476 3477
 * Ref: loss detection algorithm in draft-dukkipati-tcpm-tcp-loss-probe.
 */
static void tcp_process_tlp_ack(struct sock *sk, u32 ack, int flag)
{
	struct tcp_sock *tp = tcp_sk(sk);

3478
	if (before(ack, tp->tlp_high_seq))
N
Nandita Dukkipati 已提交
3479 3480
		return;

3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496
	if (flag & FLAG_DSACKING_ACK) {
		/* This DSACK means original and TLP probe arrived; no loss */
		tp->tlp_high_seq = 0;
	} else if (after(ack, tp->tlp_high_seq)) {
		/* ACK advances: there was a loss, so reduce cwnd. Reset
		 * tlp_high_seq in tcp_init_cwnd_reduction()
		 */
		tcp_init_cwnd_reduction(sk);
		tcp_set_ca_state(sk, TCP_CA_CWR);
		tcp_end_cwnd_reduction(sk);
		tcp_try_keep_open(sk);
		NET_INC_STATS_BH(sock_net(sk),
				 LINUX_MIB_TCPLOSSPROBERECOVERY);
	} else if (!(flag & (FLAG_SND_UNA_ADVANCED |
			     FLAG_NOT_DUP | FLAG_DATA_SACKED))) {
		/* Pure dupack: original and TLP probe arrived; no loss */
N
Nandita Dukkipati 已提交
3497 3498 3499 3500
		tp->tlp_high_seq = 0;
	}
}

3501 3502 3503 3504 3505 3506 3507 3508
static inline void tcp_in_ack_event(struct sock *sk, u32 flags)
{
	const struct inet_connection_sock *icsk = inet_csk(sk);

	if (icsk->icsk_ca_ops->in_ack_event)
		icsk->icsk_ca_ops->in_ack_event(sk, flags);
}

L
Linus Torvalds 已提交
3509
/* This routine deals with incoming acks, but not outgoing ones. */
3510
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
L
Linus Torvalds 已提交
3511
{
3512
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3513
	struct tcp_sock *tp = tcp_sk(sk);
3514
	struct tcp_sacktag_state sack_state;
L
Linus Torvalds 已提交
3515 3516 3517
	u32 prior_snd_una = tp->snd_una;
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
3518
	bool is_dupack = false;
3519
	u32 prior_fackets;
3520
	int prior_packets = tp->packets_out;
3521 3522
	const int prior_unsacked = tp->packets_out - tp->sacked_out;
	int acked = 0; /* Number of packets newly acked */
3523

3524
	sack_state.first_sackt.v64 = 0;
L
Linus Torvalds 已提交
3525

3526 3527 3528
	/* We very likely will need to access write queue head. */
	prefetchw(sk->sk_write_queue.next);

3529
	/* If the ack is older than previous acks
L
Linus Torvalds 已提交
3530 3531
	 * then we can probably ignore it.
	 */
3532 3533 3534
	if (before(ack, prior_snd_una)) {
		/* RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation] */
		if (before(ack, prior_snd_una - tp->max_window)) {
3535
			tcp_send_challenge_ack(sk, skb);
3536 3537
			return -1;
		}
L
Linus Torvalds 已提交
3538
		goto old_ack;
3539
	}
L
Linus Torvalds 已提交
3540

3541 3542 3543 3544 3545 3546
	/* If the ack includes data we haven't sent yet, discard
	 * this segment (RFC793 Section 3.9).
	 */
	if (after(ack, tp->snd_nxt))
		goto invalid_ack;

N
Nandita Dukkipati 已提交
3547 3548
	if (icsk->icsk_pending == ICSK_TIME_EARLY_RETRANS ||
	    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
3549 3550
		tcp_rearm_rto(sk);

3551
	if (after(ack, prior_snd_una)) {
3552
		flag |= FLAG_SND_UNA_ADVANCED;
3553 3554
		icsk->icsk_retransmits = 0;
	}
3555

3556 3557
	prior_fackets = tp->fackets_out;

3558 3559 3560 3561 3562 3563
	/* ts_recent update must be made after we are sure that the packet
	 * is in window.
	 */
	if (flag & FLAG_UPDATE_TS_RECENT)
		tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);

3564
	if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
L
Linus Torvalds 已提交
3565 3566 3567 3568
		/* Window is constant, pure forward advance.
		 * No more checks are required.
		 * Note, we use the fact that SND.UNA>=SND.WL2.
		 */
3569
		tcp_update_wl(tp, ack_seq);
3570
		tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3571 3572
		flag |= FLAG_WIN_UPDATE;

3573
		tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);
3574

3575
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPACKS);
L
Linus Torvalds 已提交
3576
	} else {
3577 3578
		u32 ack_ev_flags = CA_ACK_SLOWPATH;

L
Linus Torvalds 已提交
3579 3580 3581
		if (ack_seq != TCP_SKB_CB(skb)->end_seq)
			flag |= FLAG_DATA;
		else
3582
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPUREACKS);
L
Linus Torvalds 已提交
3583

3584
		flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
L
Linus Torvalds 已提交
3585 3586

		if (TCP_SKB_CB(skb)->sacked)
Y
Yuchung Cheng 已提交
3587
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3588
							&sack_state);
L
Linus Torvalds 已提交
3589

3590
		if (tcp_ecn_rcv_ecn_echo(tp, tcp_hdr(skb))) {
L
Linus Torvalds 已提交
3591
			flag |= FLAG_ECE;
3592 3593 3594 3595 3596
			ack_ev_flags |= CA_ACK_ECE;
		}

		if (flag & FLAG_WIN_UPDATE)
			ack_ev_flags |= CA_ACK_WIN_UPDATE;
L
Linus Torvalds 已提交
3597

3598
		tcp_in_ack_event(sk, ack_ev_flags);
L
Linus Torvalds 已提交
3599 3600 3601 3602 3603 3604
	}

	/* We passed data and got it acked, remove any soft error
	 * log. Something worked...
	 */
	sk->sk_err_soft = 0;
3605
	icsk->icsk_probes_out = 0;
L
Linus Torvalds 已提交
3606 3607 3608 3609 3610
	tp->rcv_tstamp = tcp_time_stamp;
	if (!prior_packets)
		goto no_queue;

	/* See if we can take anything off of the retransmit queue. */
3611
	acked = tp->packets_out;
3612
	flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una,
3613
				    &sack_state);
3614
	acked -= tp->packets_out;
3615

3616
	if (tcp_ack_is_dubious(sk, flag)) {
3617
		is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
3618 3619
		tcp_fastretrans_alert(sk, acked, prior_unsacked,
				      is_dupack, flag);
L
Linus Torvalds 已提交
3620
	}
N
Nandita Dukkipati 已提交
3621 3622 3623
	if (tp->tlp_high_seq)
		tcp_process_tlp_ack(sk, ack, flag);

3624 3625 3626 3627
	/* Advance cwnd if state allows */
	if (tcp_may_raise_cwnd(sk, flag))
		tcp_cong_avoid(sk, ack, acked);

3628 3629 3630 3631 3632
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP)) {
		struct dst_entry *dst = __sk_dst_get(sk);
		if (dst)
			dst_confirm(dst);
	}
N
Nandita Dukkipati 已提交
3633 3634 3635

	if (icsk->icsk_pending == ICSK_TIME_RETRANS)
		tcp_schedule_loss_probe(sk);
3636
	tcp_update_pacing_rate(sk);
L
Linus Torvalds 已提交
3637 3638 3639
	return 1;

no_queue:
3640 3641
	/* If data was DSACKed, see if we can undo a cwnd reduction. */
	if (flag & FLAG_DSACKING_ACK)
3642 3643
		tcp_fastretrans_alert(sk, acked, prior_unsacked,
				      is_dupack, flag);
L
Linus Torvalds 已提交
3644 3645 3646 3647
	/* 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.
	 */
3648
	if (tcp_send_head(sk))
L
Linus Torvalds 已提交
3649
		tcp_ack_probe(sk);
N
Nandita Dukkipati 已提交
3650 3651 3652

	if (tp->tlp_high_seq)
		tcp_process_tlp_ack(sk, ack, flag);
L
Linus Torvalds 已提交
3653 3654
	return 1;

3655 3656 3657 3658
invalid_ack:
	SOCK_DEBUG(sk, "Ack %u after %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return -1;

L
Linus Torvalds 已提交
3659
old_ack:
3660 3661 3662
	/* If data was SACKed, tag it and see if we should send more data.
	 * If data was DSACKed, see if we can undo a cwnd reduction.
	 */
3663
	if (TCP_SKB_CB(skb)->sacked) {
Y
Yuchung Cheng 已提交
3664
		flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3665
						&sack_state);
3666 3667
		tcp_fastretrans_alert(sk, acked, prior_unsacked,
				      is_dupack, flag);
3668
	}
L
Linus Torvalds 已提交
3669

3670
	SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
L
Linus Torvalds 已提交
3671 3672 3673
	return 0;
}

3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690
static void tcp_parse_fastopen_option(int len, const unsigned char *cookie,
				      bool syn, struct tcp_fastopen_cookie *foc,
				      bool exp_opt)
{
	/* Valid only in SYN or SYN-ACK with an even length.  */
	if (!foc || !syn || len < 0 || (len & 1))
		return;

	if (len >= TCP_FASTOPEN_COOKIE_MIN &&
	    len <= TCP_FASTOPEN_COOKIE_MAX)
		memcpy(foc->val, cookie, len);
	else if (len != 0)
		len = -1;
	foc->len = len;
	foc->exp = exp_opt;
}

L
Linus Torvalds 已提交
3691 3692 3693 3694
/* 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.
 */
C
Christoph Paasch 已提交
3695 3696
void tcp_parse_options(const struct sk_buff *skb,
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3697
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3698
{
3699 3700
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3701
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3702

3703
	ptr = (const unsigned char *)(th + 1);
L
Linus Torvalds 已提交
3704 3705
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3706
	while (length > 0) {
3707
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3708 3709 3710
		int opsize;

		switch (opcode) {
3711 3712 3713 3714 3715 3716 3717 3718
		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 已提交
3719
				return;
3720 3721 3722 3723 3724
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
3725
					u16 in_mss = get_unaligned_be16(ptr);
3726 3727 3728 3729 3730
					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 已提交
3731
					}
3732 3733 3734 3735
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
3736
				    !estab && sysctl_tcp_window_scaling) {
3737 3738 3739
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
					if (snd_wscale > 14) {
3740 3741 3742
						net_info_ratelimited("%s: Illegal window scaling value %d >14 received\n",
								     __func__,
								     snd_wscale);
3743
						snd_wscale = 14;
L
Linus Torvalds 已提交
3744
					}
3745 3746 3747 3748 3749 3750
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
3751
				     (!estab && sysctl_tcp_timestamps))) {
3752
					opt_rx->saw_tstamp = 1;
3753 3754
					opt_rx->rcv_tsval = get_unaligned_be32(ptr);
					opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
3755 3756 3757 3758
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
3759
				    !estab && sysctl_tcp_sack) {
3760
					opt_rx->sack_ok = TCP_SACK_SEEN;
3761 3762 3763
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3764

3765 3766 3767 3768 3769 3770 3771
			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;
3772
#ifdef CONFIG_TCP_MD5SIG
3773 3774 3775 3776 3777 3778
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3779
#endif
3780 3781 3782 3783 3784 3785
			case TCPOPT_FASTOPEN:
				tcp_parse_fastopen_option(
					opsize - TCPOLEN_FASTOPEN_BASE,
					ptr, th->syn, foc, false);
				break;

Y
Yuchung Cheng 已提交
3786 3787
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3788
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3789
				 */
3790 3791 3792 3793 3794 3795
				if (opsize >= TCPOLEN_EXP_FASTOPEN_BASE &&
				    get_unaligned_be16(ptr) ==
				    TCPOPT_FASTOPEN_MAGIC)
					tcp_parse_fastopen_option(opsize -
						TCPOLEN_EXP_FASTOPEN_BASE,
						ptr + 2, th->syn, foc, true);
Y
Yuchung Cheng 已提交
3796 3797 3798
				break;

			}
3799 3800
			ptr += opsize-2;
			length -= opsize;
3801
		}
L
Linus Torvalds 已提交
3802 3803
	}
}
E
Eric Dumazet 已提交
3804
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3805

E
Eric Dumazet 已提交
3806
static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
3807
{
3808
	const __be32 *ptr = (const __be32 *)(th + 1);
3809 3810 3811 3812 3813 3814 3815

	if (*ptr == htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
			  | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP)) {
		tp->rx_opt.saw_tstamp = 1;
		++ptr;
		tp->rx_opt.rcv_tsval = ntohl(*ptr);
		++ptr;
3816 3817 3818 3819
		if (*ptr)
			tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
		else
			tp->rx_opt.rcv_tsecr = 0;
E
Eric Dumazet 已提交
3820
		return true;
3821
	}
E
Eric Dumazet 已提交
3822
	return false;
3823 3824
}

L
Linus Torvalds 已提交
3825 3826 3827
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
E
Eric Dumazet 已提交
3828
static bool tcp_fast_parse_options(const struct sk_buff *skb,
C
Christoph Paasch 已提交
3829
				   const struct tcphdr *th, struct tcp_sock *tp)
L
Linus Torvalds 已提交
3830
{
3831 3832 3833 3834
	/* In the spirit of fast parsing, compare doff directly to constant
	 * values.  Because equality is used, short doff can be ignored here.
	 */
	if (th->doff == (sizeof(*th) / 4)) {
L
Linus Torvalds 已提交
3835
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
3836
		return false;
L
Linus Torvalds 已提交
3837
	} else if (tp->rx_opt.tstamp_ok &&
3838
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3839
		if (tcp_parse_aligned_timestamp(tp, th))
E
Eric Dumazet 已提交
3840
			return true;
L
Linus Torvalds 已提交
3841
	}
3842

C
Christoph Paasch 已提交
3843
	tcp_parse_options(skb, &tp->rx_opt, 1, NULL);
3844
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3845 3846
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3847
	return true;
L
Linus Torvalds 已提交
3848 3849
}

3850 3851 3852 3853
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
3854
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th)
3855
{
3856 3857
	int length = (th->doff << 2) - sizeof(*th);
	const u8 *ptr = (const u8 *)(th + 1);
3858 3859 3860 3861 3862 3863 3864 3865 3866

	/* If the TCP option is too short, we can short cut */
	if (length < TCPOLEN_MD5SIG)
		return NULL;

	while (length > 0) {
		int opcode = *ptr++;
		int opsize;

W
Weilong Chen 已提交
3867
		switch (opcode) {
3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3878
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3879 3880 3881 3882 3883 3884
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3885
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3886 3887
#endif

L
Linus Torvalds 已提交
3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910
/* 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) ]
 */

3911
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3912
{
3913 3914
	const struct tcp_sock *tp = tcp_sk(sk);
	const struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927
	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. */
3928
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
3929 3930
}

3931
static inline bool tcp_paws_discard(const struct sock *sk,
3932
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
3933
{
3934
	const struct tcp_sock *tp = tcp_sk(sk);
I
Ilpo Järvinen 已提交
3935 3936 3937

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
}

/* 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)
 */

3953
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
3954 3955 3956 3957 3958 3959
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
3960
void tcp_reset(struct sock *sk)
L
Linus Torvalds 已提交
3961 3962 3963
{
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
3964 3965 3966 3967 3968 3969 3970 3971 3972 3973
	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 已提交
3974
	}
T
Tom Marshall 已提交
3975 3976
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997

	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.
 */
3998
void tcp_fin(struct sock *sk)
L
Linus Torvalds 已提交
3999 4000 4001
{
	struct tcp_sock *tp = tcp_sk(sk);

4002
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4003 4004 4005 4006 4007

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

	switch (sk->sk_state) {
4008 4009 4010 4011
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
4012
		inet_csk(sk)->icsk_ack.pingpong = 1;
4013
		break;
L
Linus Torvalds 已提交
4014

4015 4016 4017 4018 4019 4020 4021 4022 4023
	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 已提交
4024

4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041
	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.
		 */
J
Joe Perches 已提交
4042
		pr_err("%s: Impossible, sk->sk_state=%d\n",
4043
		       __func__, sk->sk_state);
4044
		break;
4045
	}
L
Linus Torvalds 已提交
4046 4047 4048 4049 4050

	/* 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);
4051
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4052
		tcp_sack_reset(&tp->rx_opt);
4053
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4054 4055 4056 4057 4058 4059 4060

	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)
4061
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
4062
		else
4063
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
4064 4065 4066
	}
}

E
Eric Dumazet 已提交
4067
static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4068
				  u32 end_seq)
L
Linus Torvalds 已提交
4069 4070 4071 4072 4073 4074
{
	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;
E
Eric Dumazet 已提交
4075
		return true;
L
Linus Torvalds 已提交
4076
	}
E
Eric Dumazet 已提交
4077
	return false;
L
Linus Torvalds 已提交
4078 4079
}

4080
static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4081
{
4082 4083
	struct tcp_sock *tp = tcp_sk(sk);

4084
	if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
4085 4086
		int mib_idx;

L
Linus Torvalds 已提交
4087
		if (before(seq, tp->rcv_nxt))
4088
			mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
L
Linus Torvalds 已提交
4089
		else
4090 4091
			mib_idx = LINUX_MIB_TCPDSACKOFOSENT;

4092
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4093 4094 4095 4096 4097 4098 4099

		tp->rx_opt.dsack = 1;
		tp->duplicate_sack[0].start_seq = seq;
		tp->duplicate_sack[0].end_seq = end_seq;
	}
}

4100
static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4101
{
4102 4103
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
4104
	if (!tp->rx_opt.dsack)
4105
		tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4106 4107 4108 4109
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

4110
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
4111 4112 4113 4114 4115
{
	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)) {
4116
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4117
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4118

4119
		if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
4120 4121 4122 4123
			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;
4124
			tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
L
Linus Torvalds 已提交
4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137
		}
	}

	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];
4138
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
4139 4140 4141 4142

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
4143
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
4144 4145 4146 4147 4148 4149 4150
		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--;
4151 4152
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168
			continue;
		}
		this_sack++, swalk++;
	}
}

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;

4169
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
4170 4171
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
4172
			for (; this_sack > 0; this_sack--, sp--)
4173
				swap(*sp, *(sp - 1));
L
Linus Torvalds 已提交
4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185
			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.
	 */
4186
	if (this_sack >= TCP_NUM_SACKS) {
L
Linus Torvalds 已提交
4187 4188 4189 4190
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
4191
	for (; this_sack > 0; this_sack--, sp--)
4192
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209

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++;
}

/* 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. */
4210
	if (skb_queue_empty(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4211 4212 4213 4214
		tp->rx_opt.num_sacks = 0;
		return;
	}

4215
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
4216 4217 4218 4219 4220
		/* 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! */
4221
			WARN_ON(before(tp->rcv_nxt, sp->end_seq));
L
Linus Torvalds 已提交
4222 4223

			/* Zap this SACK, by moving forward any other SACKS. */
W
Weilong Chen 已提交
4224
			for (i = this_sack+1; i < num_sacks; i++)
L
Linus Torvalds 已提交
4225 4226 4227 4228 4229 4230 4231
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4232
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4233 4234
}

4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272
/**
 * tcp_try_coalesce - try to merge skb to prior one
 * @sk: socket
 * @to: prior buffer
 * @from: buffer to add in queue
 * @fragstolen: pointer to boolean
 *
 * Before queueing skb @from after @to, try to merge them
 * to reduce overall memory use and queue lengths, if cost is small.
 * Packets in ofo or receive queues can stay a long time.
 * Better try to coalesce them right now to avoid future collapses.
 * Returns true if caller should free @from instead of queueing it
 */
static bool tcp_try_coalesce(struct sock *sk,
			     struct sk_buff *to,
			     struct sk_buff *from,
			     bool *fragstolen)
{
	int delta;

	*fragstolen = false;

	/* Its possible this segment overlaps with prior segment in queue */
	if (TCP_SKB_CB(from)->seq != TCP_SKB_CB(to)->end_seq)
		return false;

	if (!skb_try_coalesce(to, from, fragstolen, &delta))
		return false;

	atomic_add(delta, &sk->sk_rmem_alloc);
	sk_mem_charge(sk, delta);
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
	TCP_SKB_CB(to)->end_seq = TCP_SKB_CB(from)->end_seq;
	TCP_SKB_CB(to)->ack_seq = TCP_SKB_CB(from)->ack_seq;
	TCP_SKB_CB(to)->tcp_flags |= TCP_SKB_CB(from)->tcp_flags;
	return true;
}

L
Linus Torvalds 已提交
4273 4274 4275 4276 4277 4278 4279
/* 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;
4280 4281
	struct sk_buff *skb, *tail;
	bool fragstolen, eaten;
L
Linus Torvalds 已提交
4282 4283 4284 4285 4286 4287 4288 4289 4290

	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;
4291
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4292 4293
		}

4294
		__skb_unlink(skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4295
		if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
4296
			SOCK_DEBUG(sk, "ofo packet was already received\n");
L
Linus Torvalds 已提交
4297 4298 4299 4300 4301 4302 4303
			__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);

4304 4305
		tail = skb_peek_tail(&sk->sk_receive_queue);
		eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4306
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4307 4308
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4309
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4310
			tcp_fin(sk);
4311 4312
		if (eaten)
			kfree_skb_partial(skb, fragstolen);
L
Linus Torvalds 已提交
4313 4314 4315
	}
}

E
Eric Dumazet 已提交
4316
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4317 4318
static int tcp_prune_queue(struct sock *sk);

4319 4320
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
				 unsigned int size)
4321 4322
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4323
	    !sk_rmem_schedule(sk, skb, size)) {
4324 4325 4326 4327

		if (tcp_prune_queue(sk) < 0)
			return -1;

4328
		if (!sk_rmem_schedule(sk, skb, size)) {
4329 4330 4331
			if (!tcp_prune_ofo_queue(sk))
				return -1;

4332
			if (!sk_rmem_schedule(sk, skb, size))
4333 4334 4335 4336 4337 4338
				return -1;
		}
	}
	return 0;
}

E
Eric Dumazet 已提交
4339 4340 4341 4342 4343 4344
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb1;
	u32 seq, end_seq;

4345
	tcp_ecn_check_ce(tp, skb);
E
Eric Dumazet 已提交
4346

4347
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
E
Eric Dumazet 已提交
4348
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPOFODROP);
E
Eric Dumazet 已提交
4349 4350 4351 4352 4353 4354 4355 4356
		__kfree_skb(skb);
		return;
	}

	/* Disable header prediction. */
	tp->pred_flags = 0;
	inet_csk_schedule_ack(sk);

E
Eric Dumazet 已提交
4357
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
E
Eric Dumazet 已提交
4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377
	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);

	skb1 = skb_peek_tail(&tp->out_of_order_queue);
	if (!skb1) {
		/* Initial out of order segment, build 1 SACK. */
		if (tcp_is_sack(tp)) {
			tp->rx_opt.num_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;
		}
		__skb_queue_head(&tp->out_of_order_queue, skb);
		goto end;
	}

	seq = TCP_SKB_CB(skb)->seq;
	end_seq = TCP_SKB_CB(skb)->end_seq;

	if (seq == TCP_SKB_CB(skb1)->end_seq) {
4378 4379 4380
		bool fragstolen;

		if (!tcp_try_coalesce(sk, skb1, skb, &fragstolen)) {
E
Eric Dumazet 已提交
4381 4382
			__skb_queue_after(&tp->out_of_order_queue, skb1, skb);
		} else {
4383
			tcp_grow_window(sk, skb);
4384
			kfree_skb_partial(skb, fragstolen);
4385 4386
			skb = NULL;
		}
E
Eric Dumazet 已提交
4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411

		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;
		goto end;
	}

	/* Find place to insert this segment. */
	while (1) {
		if (!after(TCP_SKB_CB(skb1)->seq, seq))
			break;
		if (skb_queue_is_first(&tp->out_of_order_queue, skb1)) {
			skb1 = NULL;
			break;
		}
		skb1 = skb_queue_prev(&tp->out_of_order_queue, skb1);
	}

	/* Do skb overlap to previous one? */
	if (skb1 && before(seq, TCP_SKB_CB(skb1)->end_seq)) {
		if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
			/* All the bits are present. Drop. */
E
Eric Dumazet 已提交
4412
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
E
Eric Dumazet 已提交
4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450
			__kfree_skb(skb);
			skb = NULL;
			tcp_dsack_set(sk, seq, end_seq);
			goto add_sack;
		}
		if (after(seq, TCP_SKB_CB(skb1)->seq)) {
			/* Partial overlap. */
			tcp_dsack_set(sk, seq,
				      TCP_SKB_CB(skb1)->end_seq);
		} else {
			if (skb_queue_is_first(&tp->out_of_order_queue,
					       skb1))
				skb1 = NULL;
			else
				skb1 = skb_queue_prev(
					&tp->out_of_order_queue,
					skb1);
		}
	}
	if (!skb1)
		__skb_queue_head(&tp->out_of_order_queue, skb);
	else
		__skb_queue_after(&tp->out_of_order_queue, skb1, skb);

	/* And clean segments covered by new one as whole. */
	while (!skb_queue_is_last(&tp->out_of_order_queue, skb)) {
		skb1 = skb_queue_next(&tp->out_of_order_queue, skb);

		if (!after(end_seq, TCP_SKB_CB(skb1)->seq))
			break;
		if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
			tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
					 end_seq);
			break;
		}
		__skb_unlink(skb1, &tp->out_of_order_queue);
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
E
Eric Dumazet 已提交
4451
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
E
Eric Dumazet 已提交
4452 4453 4454 4455 4456 4457 4458
		__kfree_skb(skb1);
	}

add_sack:
	if (tcp_is_sack(tp))
		tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
4459 4460
	if (skb) {
		tcp_grow_window(sk, skb);
E
Eric Dumazet 已提交
4461
		skb_set_owner_r(skb, sk);
4462
	}
E
Eric Dumazet 已提交
4463 4464
}

4465
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
4466 4467 4468 4469 4470 4471 4472 4473
		  bool *fragstolen)
{
	int eaten;
	struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);

	__skb_pull(skb, hdrlen);
	eaten = (tail &&
		 tcp_try_coalesce(sk, tail, skb, fragstolen)) ? 1 : 0;
4474
	tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
4475 4476 4477 4478 4479 4480
	if (!eaten) {
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		skb_set_owner_r(skb, sk);
	}
	return eaten;
}
E
Eric Dumazet 已提交
4481

4482 4483
int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
{
4484
	struct sk_buff *skb;
4485 4486
	int err = -ENOMEM;
	int data_len = 0;
4487 4488
	bool fragstolen;

4489 4490 4491
	if (size == 0)
		return 0;

4492 4493 4494 4495 4496 4497 4498 4499 4500
	if (size > PAGE_SIZE) {
		int npages = min_t(size_t, size >> PAGE_SHIFT, MAX_SKB_FRAGS);

		data_len = npages << PAGE_SHIFT;
		size = data_len + (size & ~PAGE_MASK);
	}
	skb = alloc_skb_with_frags(size - data_len, data_len,
				   PAGE_ALLOC_COSTLY_ORDER,
				   &err, sk->sk_allocation);
4501 4502 4503
	if (!skb)
		goto err;

4504 4505 4506 4507
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4508
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
4509 4510
		goto err_free;

4511 4512
	err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
	if (err)
4513 4514 4515 4516 4517 4518
		goto err_free;

	TCP_SKB_CB(skb)->seq = tcp_sk(sk)->rcv_nxt;
	TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(skb)->seq + size;
	TCP_SKB_CB(skb)->ack_seq = tcp_sk(sk)->snd_una - 1;

4519
	if (tcp_queue_rcv(sk, skb, 0, &fragstolen)) {
4520 4521 4522 4523 4524 4525 4526 4527
		WARN_ON_ONCE(fragstolen); /* should not happen */
		__kfree_skb(skb);
	}
	return size;

err_free:
	kfree_skb(skb);
err:
4528 4529
	return err;

4530 4531
}

L
Linus Torvalds 已提交
4532 4533 4534 4535
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int eaten = -1;
4536
	bool fragstolen = false;
L
Linus Torvalds 已提交
4537 4538 4539 4540

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

E
Eric Dumazet 已提交
4541
	skb_dst_drop(skb);
4542
	__skb_pull(skb, tcp_hdr(skb)->doff * 4);
L
Linus Torvalds 已提交
4543

4544
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4545

4546
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560

	/*  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,
4561
					  tp->ucopy.len);
L
Linus Torvalds 已提交
4562 4563 4564 4565

			__set_current_state(TASK_RUNNING);

			local_bh_enable();
4566
			if (!skb_copy_datagram_msg(skb, 0, tp->ucopy.msg, chunk)) {
L
Linus Torvalds 已提交
4567 4568
				tp->ucopy.len -= chunk;
				tp->copied_seq += chunk;
4569
				eaten = (chunk == skb->len);
L
Linus Torvalds 已提交
4570 4571 4572 4573 4574 4575 4576
				tcp_rcv_space_adjust(sk);
			}
			local_bh_disable();
		}

		if (eaten <= 0) {
queue_and_out:
4577 4578 4579 4580 4581 4582
			if (eaten < 0) {
				if (skb_queue_len(&sk->sk_receive_queue) == 0)
					sk_forced_mem_schedule(sk, skb->truesize);
				else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
					goto drop;
			}
4583
			eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
L
Linus Torvalds 已提交
4584
		}
4585
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
S
Stephen Hemminger 已提交
4586
		if (skb->len)
4587
			tcp_event_data_recv(sk, skb);
4588
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4589
			tcp_fin(sk);
L
Linus Torvalds 已提交
4590

4591
		if (!skb_queue_empty(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4592 4593 4594 4595 4596
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4597
			if (skb_queue_empty(&tp->out_of_order_queue))
4598
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4599 4600 4601 4602 4603
		}

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

4604
		tcp_fast_path_check(sk);
L
Linus Torvalds 已提交
4605

4606 4607
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4608
		if (!sock_flag(sk, SOCK_DEAD))
4609
			sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
4610 4611 4612 4613 4614
		return;
	}

	if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
		/* A retransmit, 2nd most common case.  Force an immediate ack. */
4615
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4616
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
L
Linus Torvalds 已提交
4617 4618

out_of_window:
4619 4620
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4621 4622 4623 4624 4625 4626 4627 4628 4629
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;

4630
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4631 4632 4633 4634 4635 4636 4637

	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);

4638
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4639

L
Linus Torvalds 已提交
4640 4641 4642 4643 4644 4645 4646 4647
		/* 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;
	}

E
Eric Dumazet 已提交
4648
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4649 4650
}

4651 4652 4653
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
					struct sk_buff_head *list)
{
4654 4655 4656 4657
	struct sk_buff *next = NULL;

	if (!skb_queue_is_last(list, skb))
		next = skb_queue_next(list, skb);
4658 4659 4660 4661 4662 4663 4664 4665

	__skb_unlink(skb, list);
	__kfree_skb(skb);
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);

	return next;
}

L
Linus Torvalds 已提交
4666 4667
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4668 4669 4670
 *
 * If tail is NULL, this means until the end of the list.
 *
L
Linus Torvalds 已提交
4671 4672 4673 4674
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
D
David S. Miller 已提交
4675 4676 4677
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 已提交
4678
{
4679 4680
	struct sk_buff *skb, *n;
	bool end_of_skbs;
L
Linus Torvalds 已提交
4681

S
Stephen Hemminger 已提交
4682
	/* First, check that queue is collapsible and find
L
Linus Torvalds 已提交
4683
	 * the point where collapsing can be useful. */
4684 4685 4686 4687 4688 4689
	skb = head;
restart:
	end_of_skbs = true;
	skb_queue_walk_from_safe(list, skb, n) {
		if (skb == tail)
			break;
L
Linus Torvalds 已提交
4690 4691
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4692
			skb = tcp_collapse_one(sk, skb, list);
4693 4694 4695
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4696 4697 4698 4699 4700 4701 4702
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4703
		if (!(TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)) &&
L
Linus Torvalds 已提交
4704
		    (tcp_win_from_space(skb->truesize) > skb->len ||
4705 4706
		     before(TCP_SKB_CB(skb)->seq, start))) {
			end_of_skbs = false;
L
Linus Torvalds 已提交
4707
			break;
4708 4709 4710 4711 4712 4713 4714 4715 4716 4717
		}

		if (!skb_queue_is_last(list, skb)) {
			struct sk_buff *next = skb_queue_next(list, skb);
			if (next != tail &&
			    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(next)->seq) {
				end_of_skbs = false;
				break;
			}
		}
L
Linus Torvalds 已提交
4718 4719 4720 4721

		/* Decided to skip this, advance start seq. */
		start = TCP_SKB_CB(skb)->end_seq;
	}
4722 4723
	if (end_of_skbs ||
	    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
L
Linus Torvalds 已提交
4724 4725 4726
		return;

	while (before(start, end)) {
4727
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4728 4729
		struct sk_buff *nskb;

4730
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4731 4732
		if (!nskb)
			return;
4733

L
Linus Torvalds 已提交
4734 4735
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4736
		__skb_queue_before(list, skb, nskb);
4737
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4738 4739 4740 4741 4742 4743

		/* 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;

4744
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4745 4746 4747 4748 4749 4750 4751 4752 4753
			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)) {
4754
				skb = tcp_collapse_one(sk, skb, list);
4755 4756
				if (!skb ||
				    skb == tail ||
4757
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
L
Linus Torvalds 已提交
4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773
					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;

4774
	if (!skb)
L
Linus Torvalds 已提交
4775 4776 4777 4778 4779 4780 4781
		return;

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

	for (;;) {
4782 4783 4784 4785 4786
		struct sk_buff *next = NULL;

		if (!skb_queue_is_last(&tp->out_of_order_queue, skb))
			next = skb_queue_next(&tp->out_of_order_queue, skb);
		skb = next;
L
Linus Torvalds 已提交
4787 4788 4789

		/* Segment is terminated when we see gap or when
		 * we are at the end of all the queue. */
4790
		if (!skb ||
L
Linus Torvalds 已提交
4791 4792
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
D
David S. Miller 已提交
4793 4794
			tcp_collapse(sk, &tp->out_of_order_queue,
				     head, skb, start, end);
L
Linus Torvalds 已提交
4795
			head = skb;
4796
			if (!skb)
L
Linus Torvalds 已提交
4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809
				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;
		}
	}
}

4810 4811
/*
 * Purge the out-of-order queue.
4812
 * Return true if queue was pruned.
4813
 */
E
Eric Dumazet 已提交
4814
static bool tcp_prune_ofo_queue(struct sock *sk)
4815 4816
{
	struct tcp_sock *tp = tcp_sk(sk);
E
Eric Dumazet 已提交
4817
	bool res = false;
4818 4819

	if (!skb_queue_empty(&tp->out_of_order_queue)) {
4820
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_OFOPRUNED);
4821 4822 4823 4824 4825 4826 4827 4828 4829 4830
		__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.
		 */
		if (tp->rx_opt.sack_ok)
			tcp_sack_reset(&tp->rx_opt);
		sk_mem_reclaim(sk);
E
Eric Dumazet 已提交
4831
		res = true;
4832
	}
4833
	return res;
4834 4835
}

L
Linus Torvalds 已提交
4836 4837 4838 4839 4840 4841 4842 4843 4844
/* 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)
{
4845
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4846 4847 4848

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

4849
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4850 4851

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4852
		tcp_clamp_window(sk);
4853
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
4854 4855 4856
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4857 4858 4859 4860 4861
	if (!skb_queue_empty(&sk->sk_receive_queue))
		tcp_collapse(sk, &sk->sk_receive_queue,
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4862
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4863 4864 4865 4866 4867 4868 4869

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

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

4870
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4871 4872 4873 4874 4875 4876 4877 4878

	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.
	 */
4879
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_RCVPRUNED);
L
Linus Torvalds 已提交
4880 4881 4882 4883 4884 4885

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

E
Eric Dumazet 已提交
4886
static bool tcp_should_expand_sndbuf(const struct sock *sk)
4887
{
4888
	const struct tcp_sock *tp = tcp_sk(sk);
4889

4890 4891 4892 4893
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
4894
		return false;
4895 4896

	/* If we are under global TCP memory pressure, do not expand.  */
4897
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
4898
		return false;
4899 4900

	/* If we are under soft global TCP memory pressure, do not expand.  */
4901
	if (sk_memory_allocated(sk) >= sk_prot_mem_limits(sk, 0))
E
Eric Dumazet 已提交
4902
		return false;
4903 4904

	/* If we filled the congestion window, do not expand.  */
4905
	if (tcp_packets_in_flight(tp) >= tp->snd_cwnd)
E
Eric Dumazet 已提交
4906
		return false;
4907

E
Eric Dumazet 已提交
4908
	return true;
4909
}
L
Linus Torvalds 已提交
4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920

/* 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);

4921
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
4922
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
4923 4924 4925 4926 4927 4928
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
4929
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
4930 4931 4932
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
4933 4934
		/* pairs with tcp_poll() */
		smp_mb__after_atomic();
L
Linus Torvalds 已提交
4935 4936 4937 4938 4939 4940
		if (sk->sk_socket &&
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
			tcp_new_space(sk);
	}
}

4941
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4942
{
4943
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954
	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... */
4955
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
4956 4957 4958
	     /* ... and right edge of window advances far enough.
	      * (tcp_recvmsg() will send ACK otherwise). Or...
	      */
4959
	     __tcp_select_window(sk) >= tp->rcv_wnd) ||
L
Linus Torvalds 已提交
4960
	    /* We ACK each frame or... */
4961
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
4962
	    /* We have out of order data. */
4963
	    (ofo_possible && skb_peek(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
4964 4965 4966 4967 4968 4969 4970 4971
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
4972
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4973
{
4974
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
4975 4976 4977 4978 4979 4980 4981 4982
		/* 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 已提交
4983
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
4984 4985 4986 4987 4988 4989
 *	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).
 */
4990

4991
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 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
{
	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 已提交
5028
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039
	 *
	 * 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 &&
5040
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5041 5042 5043
		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 已提交
5044
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5045 5046 5047 5048
			__kfree_skb(skb);
		}
	}

5049 5050
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
L
Linus Torvalds 已提交
5051 5052 5053 5054 5055 5056

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

/* This is the 'fast' part of urgent handling. */
5057
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5058 5059 5060 5061 5062
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5063
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5064 5065 5066 5067 5068 5069

	/* 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;

5070
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5071 5072 5073 5074 5075 5076
		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))
5077
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088
		}
	}
}

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();
5089
	if (skb_csum_unnecessary(skb))
5090
		err = skb_copy_datagram_msg(skb, hlen, tp->ucopy.msg, chunk);
L
Linus Torvalds 已提交
5091
	else
5092
		err = skb_copy_and_csum_datagram_msg(skb, hlen, tp->ucopy.msg);
L
Linus Torvalds 已提交
5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103

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

	local_bh_disable();
	return err;
}

5104 5105
static __sum16 __tcp_checksum_complete_user(struct sock *sk,
					    struct sk_buff *skb)
L
Linus Torvalds 已提交
5106
{
5107
	__sum16 result;
L
Linus Torvalds 已提交
5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118

	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;
}

5119
static inline bool tcp_checksum_complete_user(struct sock *sk,
5120
					     struct sk_buff *skb)
L
Linus Torvalds 已提交
5121
{
5122
	return !skb_csum_unnecessary(skb) &&
5123
	       __tcp_checksum_complete_user(sk, skb);
L
Linus Torvalds 已提交
5124 5125
}

5126 5127 5128
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
E
Eric Dumazet 已提交
5129 5130
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
				  const struct tcphdr *th, int syn_inerr)
5131 5132 5133 5134
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* RFC1323: H1. Apply PAWS check first. */
C
Christoph Paasch 已提交
5135
	if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
5136 5137 5138
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5139 5140 5141 5142
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDPAWS,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155
			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)) {
		/* 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)".
		 */
5156 5157 5158
		if (!th->rst) {
			if (th->syn)
				goto syn_challenge;
5159 5160 5161 5162
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDSEQ,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5163
		}
5164 5165 5166 5167 5168
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
E
Eric Dumazet 已提交
5169 5170 5171 5172 5173 5174 5175 5176 5177
		/* RFC 5961 3.2 :
		 * If sequence number exactly matches RCV.NXT, then
		 *     RESET the connection
		 * else
		 *     Send a challenge ACK
		 */
		if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt)
			tcp_reset(sk);
		else
5178
			tcp_send_challenge_ack(sk, skb);
5179 5180 5181 5182 5183
		goto discard;
	}

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

E
Eric Dumazet 已提交
5184
	/* step 4: Check for a SYN
5185
	 * RFC 5961 4.2 : Send a challenge ack
E
Eric Dumazet 已提交
5186 5187
	 */
	if (th->syn) {
5188
syn_challenge:
5189 5190
		if (syn_inerr)
			TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
E
Eric Dumazet 已提交
5191
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
5192
		tcp_send_challenge_ack(sk, skb);
E
Eric Dumazet 已提交
5193
		goto discard;
5194 5195
	}

E
Eric Dumazet 已提交
5196
	return true;
5197 5198 5199

discard:
	__kfree_skb(skb);
E
Eric Dumazet 已提交
5200
	return false;
5201 5202
}

L
Linus Torvalds 已提交
5203
/*
5204
 *	TCP receive function for the ESTABLISHED state.
L
Linus Torvalds 已提交
5205
 *
5206
 *	It is split into a fast path and a slow path. The fast path is
L
Linus Torvalds 已提交
5207 5208
 * 	disabled when:
 *	- A zero window was announced from us - zero window probing
5209
 *        is only handled properly in the slow path.
L
Linus Torvalds 已提交
5210 5211 5212 5213
 *	- Out of order segments arrived.
 *	- Urgent data is expected.
 *	- There is no buffer space left
 *	- Unexpected TCP flags/window values/header lengths are received
5214
 *	  (detected by checking the TCP header against pred_flags)
L
Linus Torvalds 已提交
5215 5216 5217 5218 5219
 *	- 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.
 *
5220
 *	When these conditions are not satisfied it drops into a standard
L
Linus Torvalds 已提交
5221 5222
 *	receive procedure patterned after RFC793 to handle all cases.
 *	The first three cases are guaranteed by proper pred_flags setting,
5223
 *	the rest is checked inline. Fast processing is turned on in
L
Linus Torvalds 已提交
5224 5225
 *	tcp_data_queue when everything is OK.
 */
5226 5227
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
			 const struct tcphdr *th, unsigned int len)
L
Linus Torvalds 已提交
5228 5229 5230
{
	struct tcp_sock *tp = tcp_sk(sk);

5231
	if (unlikely(!sk->sk_rx_dst))
E
Eric Dumazet 已提交
5232
		inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
L
Linus Torvalds 已提交
5233 5234
	/*
	 *	Header prediction.
5235
	 *	The code loosely follows the one in the famous
L
Linus Torvalds 已提交
5236
	 *	"30 instruction TCP receive" Van Jacobson mail.
5237 5238
	 *
	 *	Van's trick is to deposit buffers into socket queue
L
Linus Torvalds 已提交
5239 5240 5241 5242
	 *	on a device interrupt, to call tcp_recv function
	 *	on the receive process context and checksum and copy
	 *	the buffer to user space. smart...
	 *
5243
	 *	Our current scheme is not silly either but we take the
L
Linus Torvalds 已提交
5244 5245 5246 5247 5248 5249 5250
	 *	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 已提交
5251
	 *	if header_prediction is to be made
L
Linus Torvalds 已提交
5252 5253
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
5254
	 *  turn it off	(when there are holes in the receive
L
Linus Torvalds 已提交
5255 5256 5257 5258 5259
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
5260 5261
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
	    !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
L
Linus Torvalds 已提交
5262 5263 5264 5265 5266 5267 5268 5269 5270 5271
		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) {
			/* No? Slow path! */
5272
			if (!tcp_parse_aligned_timestamp(tp, th))
L
Linus Torvalds 已提交
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 5300 5301
				goto slow_path;

			/* 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);
5302
				__kfree_skb(skb);
5303
				tcp_data_snd_check(sk);
5304
				return;
L
Linus Torvalds 已提交
5305
			} else { /* Header too small */
5306
				TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5307 5308 5309 5310
				goto discard;
			}
		} else {
			int eaten = 0;
5311
			bool fragstolen = false;
L
Linus Torvalds 已提交
5312

D
Dan Williams 已提交
5313 5314 5315 5316 5317
			if (tp->ucopy.task == current &&
			    tp->copied_seq == tp->rcv_nxt &&
			    len - tcp_header_len <= tp->ucopy.len &&
			    sock_owned_by_user(sk)) {
				__set_current_state(TASK_RUNNING);
L
Linus Torvalds 已提交
5318

D
Dan Williams 已提交
5319
				if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) {
L
Linus Torvalds 已提交
5320 5321 5322 5323 5324 5325 5326 5327 5328 5329
					/* 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);

5330
					tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5331 5332

					__skb_pull(skb, tcp_header_len);
5333
					tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
5334
					NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITSTOUSER);
D
Dan Williams 已提交
5335
					eaten = 1;
L
Linus Torvalds 已提交
5336 5337 5338 5339 5340 5341
				}
			}
			if (!eaten) {
				if (tcp_checksum_complete_user(sk, skb))
					goto csum_error;

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

L
Linus Torvalds 已提交
5345 5346 5347 5348 5349 5350 5351 5352 5353
				/* 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);

5354
				tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5355

5356
				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITS);
L
Linus Torvalds 已提交
5357 5358

				/* Bulk data transfer: receiver */
5359 5360
				eaten = tcp_queue_rcv(sk, skb, tcp_header_len,
						      &fragstolen);
L
Linus Torvalds 已提交
5361 5362
			}

5363
			tcp_event_data_recv(sk, skb);
L
Linus Torvalds 已提交
5364 5365 5366 5367

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

D
Dan Williams 已提交
5373
			__tcp_ack_snd_check(sk, 0);
L
Linus Torvalds 已提交
5374 5375
no_ack:
			if (eaten)
5376
				kfree_skb_partial(skb, fragstolen);
5377
			sk->sk_data_ready(sk);
5378
			return;
L
Linus Torvalds 已提交
5379 5380 5381 5382
		}
	}

slow_path:
5383
	if (len < (th->doff << 2) || tcp_checksum_complete_user(sk, skb))
L
Linus Torvalds 已提交
5384 5385
		goto csum_error;

5386
	if (!th->ack && !th->rst && !th->syn)
5387 5388
		goto discard;

L
Linus Torvalds 已提交
5389 5390 5391 5392
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5393
	if (!tcp_validate_incoming(sk, skb, th, 1))
5394
		return;
L
Linus Torvalds 已提交
5395 5396

step5:
5397
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5398
		goto discard;
L
Linus Torvalds 已提交
5399

5400
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5401 5402 5403 5404 5405 5406 5407

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

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

5408
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5409
	tcp_ack_snd_check(sk);
5410
	return;
L
Linus Torvalds 已提交
5411 5412

csum_error:
5413
	TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
5414
	TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5415 5416 5417 5418

discard:
	__kfree_skb(skb);
}
E
Eric Dumazet 已提交
5419
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5420

P
Pavel Emelyanov 已提交
5421 5422 5423 5424 5425 5426 5427
void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);

	tcp_set_state(sk, TCP_ESTABLISHED);

5428
	if (skb) {
E
Eric Dumazet 已提交
5429
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5430
		security_inet_conn_established(sk, skb);
D
David S. Miller 已提交
5431
	}
P
Pavel Emelyanov 已提交
5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460

	/* Make sure socket is routed, for correct metrics.  */
	icsk->icsk_af_ops->rebuild_header(sk);

	tcp_init_metrics(sk);

	tcp_init_congestion_control(sk);

	/* 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))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));

	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);
		sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
	}
}

5461 5462 5463 5464
static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,
				    struct tcp_fastopen_cookie *cookie)
{
	struct tcp_sock *tp = tcp_sk(sk);
5465
	struct sk_buff *data = tp->syn_data ? tcp_write_queue_head(sk) : NULL;
5466 5467
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5468 5469 5470 5471 5472 5473 5474

	if (mss == tp->rx_opt.user_mss) {
		struct tcp_options_received opt;

		/* Get original SYNACK MSS value if user MSS sets mss_clamp */
		tcp_clear_options(&opt);
		opt.user_mss = opt.mss_clamp = 0;
C
Christoph Paasch 已提交
5475
		tcp_parse_options(synack, &opt, 0, NULL);
5476 5477 5478
		mss = opt.mss_clamp;
	}

5479 5480
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5481
		cookie->len = -1;
5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495
	} else if (tp->total_retrans) {
		/* SYN timed out and the SYN-ACK neither has a cookie nor
		 * acknowledges data. Presumably the remote received only
		 * the retransmitted (regular) SYNs: either the original
		 * SYN-data or the corresponding SYN-ACK was dropped.
		 */
		syn_drop = (cookie->len < 0 && data);
	} else if (cookie->len < 0 && !tp->syn_data) {
		/* We requested a cookie but didn't get it. If we did not use
		 * the (old) exp opt format then try so next time (try_exp=1).
		 * Otherwise we go back to use the RFC7413 opt (try_exp=2).
		 */
		try_exp = tp->syn_fastopen_exp ? 2 : 1;
	}
5496

5497
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5498 5499

	if (data) { /* Retransmit unacked data in SYN */
5500 5501 5502 5503 5504
		tcp_for_write_queue_from(data, sk) {
			if (data == tcp_send_head(sk) ||
			    __tcp_retransmit_skb(sk, data))
				break;
		}
5505
		tcp_rearm_rto(sk);
5506
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5507 5508
		return true;
	}
Y
Yuchung Cheng 已提交
5509
	tp->syn_data_acked = tp->syn_data;
5510 5511
	if (tp->syn_data_acked)
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVE);
5512 5513 5514

	tcp_fastopen_add_skb(sk, synack);

5515 5516 5517
	return false;
}

L
Linus Torvalds 已提交
5518
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5519
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5520
{
5521
	struct inet_connection_sock *icsk = inet_csk(sk);
5522
	struct tcp_sock *tp = tcp_sk(sk);
5523
	struct tcp_fastopen_cookie foc = { .len = -1 };
5524
	int saved_clamp = tp->rx_opt.mss_clamp;
L
Linus Torvalds 已提交
5525

C
Christoph Paasch 已提交
5526
	tcp_parse_options(skb, &tp->rx_opt, 0, &foc);
5527
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5528
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5529 5530 5531 5532 5533 5534 5535 5536 5537 5538

	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)"
		 */
5539 5540
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5541 5542 5543 5544 5545
			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)) {
5546
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579
			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..."
		 */

5580
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5581

5582
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
L
Linus Torvalds 已提交
5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610
		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);

		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);
		}

5611 5612
		if (tcp_is_sack(tp) && sysctl_tcp_fack)
			tcp_enable_fack(tp);
L
Linus Torvalds 已提交
5613

J
John Heffner 已提交
5614
		tcp_mtup_init(sk);
5615
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5616 5617 5618 5619 5620 5621
		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;
5622

R
Ralf Baechle 已提交
5623
		smp_mb();
L
Linus Torvalds 已提交
5624

P
Pavel Emelyanov 已提交
5625
		tcp_finish_connect(sk, skb);
L
Linus Torvalds 已提交
5626

5627 5628
		if ((tp->syn_fastopen || tp->syn_data) &&
		    tcp_rcv_fastopen_synack(sk, skb, &foc))
5629 5630
			return -1;

5631 5632 5633
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5634 5635 5636 5637 5638 5639 5640
			/* 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
			 */
5641
			inet_csk_schedule_ack(sk);
5642
			icsk->icsk_ack.lrcvtime = tcp_time_stamp;
5643
			tcp_enter_quickack_mode(sk);
5644 5645
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668

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. */
5669
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5670
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689
		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;
5690
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5691 5692 5693 5694 5695 5696 5697 5698 5699
		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;

5700
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5701

J
John Heffner 已提交
5702
		tcp_mtup_init(sk);
5703
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5704 5705 5706 5707 5708
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5709 5710 5711
		 * There are no obstacles to make this (except that we must
		 * either change tcp_recvmsg() to prevent it from returning data
		 * before 3WHS completes per RFC793, or employ TCP Fast Open).
L
Linus Torvalds 已提交
5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740
		 *
		 * 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
5741
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5742 5743 5744
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5745

5746
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5747 5748
{
	struct tcp_sock *tp = tcp_sk(sk);
5749
	struct inet_connection_sock *icsk = inet_csk(sk);
5750
	const struct tcphdr *th = tcp_hdr(skb);
5751
	struct request_sock *req;
L
Linus Torvalds 已提交
5752
	int queued = 0;
5753
	bool acceptable;
L
Linus Torvalds 已提交
5754 5755 5756 5757 5758 5759 5760 5761

	tp->rx_opt.saw_tstamp = 0;

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5762
		if (th->ack)
L
Linus Torvalds 已提交
5763 5764
			return 1;

S
Stephen Hemminger 已提交
5765
		if (th->rst)
L
Linus Torvalds 已提交
5766 5767
			goto discard;

S
Stephen Hemminger 已提交
5768
		if (th->syn) {
E
Eric Dumazet 已提交
5769 5770
			if (th->fin)
				goto discard;
5771
			if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
L
Linus Torvalds 已提交
5772 5773
				return 1;

5774 5775
			/* Now we have several options: In theory there is
			 * nothing else in the frame. KA9Q has an option to
L
Linus Torvalds 已提交
5776
			 * send data with the syn, BSD accepts data with the
5777 5778 5779
			 * 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 已提交
5780 5781 5782
			 * and avoids incompatibilities. It would be nice in
			 * future to drop through and process the data.
			 *
5783
			 * Now that TTCP is starting to be used we ought to
L
Linus Torvalds 已提交
5784 5785
			 * queue this data.
			 * But, this leaves one open to an easy denial of
5786
			 * service attack, and SYN cookies can't defend
L
Linus Torvalds 已提交
5787
			 * against this problem. So, we drop the data
5788 5789
			 * in the interest of security over speed unless
			 * it's still in use.
L
Linus Torvalds 已提交
5790
			 */
5791 5792
			kfree_skb(skb);
			return 0;
L
Linus Torvalds 已提交
5793 5794 5795 5796
		}
		goto discard;

	case TCP_SYN_SENT:
5797
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
5798 5799 5800 5801 5802 5803
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5804
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5805 5806 5807
		return 0;
	}

5808
	req = tp->fastopen_rsk;
5809
	if (req) {
5810
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
5811 5812
		    sk->sk_state != TCP_FIN_WAIT1);

5813
		if (!tcp_check_req(sk, skb, req, true))
5814
			goto discard;
5815
	}
5816

5817
	if (!th->ack && !th->rst && !th->syn)
5818 5819
		goto discard;

5820
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
5821
		return 0;
L
Linus Torvalds 已提交
5822 5823

	/* step 5: check the ACK field */
5824 5825
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT) > 0;
5826

5827 5828
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
5829 5830
		if (!acceptable)
			return 1;
L
Linus Torvalds 已提交
5831

Y
Yuchung Cheng 已提交
5832 5833 5834
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
			tp->total_retrans = req->num_retrans;
			reqsk_fastopen_remove(sk, req, false);
		} else {
			/* Make sure socket is routed, for correct metrics. */
			icsk->icsk_af_ops->rebuild_header(sk);
			tcp_init_congestion_control(sk);

			tcp_mtup_init(sk);
			tp->copied_seq = tp->rcv_nxt;
E
Eric Dumazet 已提交
5848
			tcp_init_buffer_space(sk);
5849 5850 5851 5852
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
5853

5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875
		/* 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.
		 */
		if (sk->sk_socket)
			sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);

		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)->seq);

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

		if (req) {
			/* Re-arm the timer because data may have been sent out.
			 * This is similar to the regular data transmission case
			 * when new data has just been ack'ed.
			 *
			 * (TFO) - we could try to be more aggressive and
			 * retransmitting any data sooner based on when they
			 * are sent out.
5876
			 */
5877 5878 5879
			tcp_rearm_rto(sk);
		} else
			tcp_init_metrics(sk);
L
Linus Torvalds 已提交
5880

5881 5882
		tcp_update_pacing_rate(sk);

5883 5884 5885 5886 5887
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
		tp->lsndtime = tcp_time_stamp;

		tcp_initialize_rcv_mss(sk);
		tcp_fast_path_on(tp);
5888 5889
		break;

5890 5891 5892 5893
	case TCP_FIN_WAIT1: {
		struct dst_entry *dst;
		int tmo;

5894 5895 5896 5897 5898
		/* If we enter the TCP_FIN_WAIT1 state and we are a
		 * Fast Open socket and this is the first acceptable
		 * ACK we have received, this would have acknowledged
		 * our SYNACK so stop the SYNACK timer.
		 */
5899
		if (req) {
5900 5901 5902 5903 5904
			/* Return RST if ack_seq is invalid.
			 * Note that RFC793 only says to generate a
			 * DUPACK for it but for TCP Fast Open it seems
			 * better to treat this case like TCP_SYN_RECV
			 * above.
5905
			 */
5906 5907 5908 5909 5910 5911
			if (!acceptable)
				return 1;
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
5912 5913
		if (tp->snd_una != tp->write_seq)
			break;
5914

5915 5916
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
5917

5918 5919 5920
		dst = __sk_dst_get(sk);
		if (dst)
			dst_confirm(dst);
5921

5922 5923 5924 5925 5926
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
5927

5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949
		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(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
			return 1;
		}

		tmo = tcp_fin_time(sk);
		if (tmo > TCP_TIMEWAIT_LEN) {
			inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
		} 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.
			 */
			inet_csk_reset_keepalive_timer(sk, tmo);
		} else {
			tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
			goto discard;
5950 5951
		}
		break;
5952
	}
L
Linus Torvalds 已提交
5953

5954 5955 5956 5957 5958 5959
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
5960

5961 5962 5963 5964 5965
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
5966
		}
5967
		break;
5968
	}
L
Linus Torvalds 已提交
5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982

	/* 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,
5983
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
5984 5985 5986 5987 5988
		 * 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)) {
5989
				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
5990 5991 5992 5993 5994
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
5995
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
5996 5997 5998 5999 6000 6001 6002
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6003
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6004 6005 6006
		tcp_ack_snd_check(sk);
	}

6007
	if (!queued) {
L
Linus Torvalds 已提交
6008 6009 6010 6011 6012 6013
discard:
		__kfree_skb(skb);
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6014 6015 6016 6017 6018 6019

static inline void pr_drop_req(struct request_sock *req, __u16 port, int family)
{
	struct inet_request_sock *ireq = inet_rsk(req);

	if (family == AF_INET)
6020 6021
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6022 6023
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6024 6025
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6026
#endif
O
Octavian Purdila 已提交
6027 6028
}

6029 6030 6031 6032 6033
/* RFC3168 : 6.1.1 SYN packets must not have ECT/ECN bits set
 *
 * If we receive a SYN packet with these bits set, it means a
 * network is playing bad games with TOS bits. In order to
 * avoid possible false congestion notifications, we disable
S
stephen hemminger 已提交
6034
 * TCP ECN negotiation.
6035 6036
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6037 6038 6039
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6040 6041 6042
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6043 6044
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6045 6046 6047 6048
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6049
	bool ect, ecn_ok;
6050
	u32 ecn_ok_dst;
6051 6052 6053 6054 6055

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6056 6057
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6058

6059 6060
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
	    (ecn_ok_dst & DST_FEATURE_ECN_CA))
6061 6062 6063
		inet_rsk(req)->ecn_ok = 1;
}

6064 6065 6066 6067 6068 6069
static void tcp_openreq_init(struct request_sock *req,
			     const struct tcp_options_received *rx_opt,
			     struct sk_buff *skb, const struct sock *sk)
{
	struct inet_request_sock *ireq = inet_rsk(req);

6070
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6071 6072 6073
	req->cookie_ts = 0;
	tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
	tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
Y
Yuchung Cheng 已提交
6074
	skb_mstamp_get(&tcp_rsk(req)->snt_synack);
6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088
	tcp_rsk(req)->last_oow_ack_time = 0;
	req->mss = rx_opt->mss_clamp;
	req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
	ireq->tstamp_ok = rx_opt->tstamp_ok;
	ireq->sack_ok = rx_opt->sack_ok;
	ireq->snd_wscale = rx_opt->snd_wscale;
	ireq->wscale_ok = rx_opt->wscale_ok;
	ireq->acked = 0;
	ireq->ecn_ok = 0;
	ireq->ir_rmt_port = tcp_hdr(skb)->source;
	ireq->ir_num = ntohs(tcp_hdr(skb)->dest);
	ireq->ir_mark = inet_request_mark(sk, skb);
}

E
Eric Dumazet 已提交
6089
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6090 6091
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6092
{
6093 6094
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6095 6096 6097 6098 6099 6100 6101 6102 6103

	if (req) {
		struct inet_request_sock *ireq = inet_rsk(req);

		kmemcheck_annotate_bitfield(ireq, flags);
		ireq->opt = NULL;
		atomic64_set(&ireq->ir_cookie, 0);
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6104
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6105 6106 6107 6108 6109 6110
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6111 6112 6113
/*
 * Return true if a syncookie should be sent
 */
6114
static bool tcp_syn_flood_action(const struct sock *sk,
6115 6116 6117
				 const struct sk_buff *skb,
				 const char *proto)
{
6118
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130
	const char *msg = "Dropping request";
	bool want_cookie = false;

#ifdef CONFIG_SYN_COOKIES
	if (sysctl_tcp_syncookies) {
		msg = "Sending cookies";
		want_cookie = true;
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
	} else
#endif
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);

6131
	if (!queue->synflood_warned &&
6132
	    sysctl_tcp_syncookies != 2 &&
6133
	    xchg(&queue->synflood_warned, 1) == 0)
6134 6135
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6136

6137 6138 6139
	return want_cookie;
}

6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156
static void tcp_reqsk_record_syn(const struct sock *sk,
				 struct request_sock *req,
				 const struct sk_buff *skb)
{
	if (tcp_sk(sk)->save_syn) {
		u32 len = skb_network_header_len(skb) + tcp_hdrlen(skb);
		u32 *copy;

		copy = kmalloc(len + sizeof(u32), GFP_ATOMIC);
		if (copy) {
			copy[0] = len;
			memcpy(&copy[1], skb_network_header(skb), len);
			req->saved_syn = copy;
		}
	}
}

O
Octavian Purdila 已提交
6157 6158 6159 6160
int tcp_conn_request(struct request_sock_ops *rsk_ops,
		     const struct tcp_request_sock_ops *af_ops,
		     struct sock *sk, struct sk_buff *skb)
{
6161 6162
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6163 6164
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6165
	struct sock *fastopen_sk = NULL;
O
Octavian Purdila 已提交
6166
	struct dst_entry *dst = NULL;
6167 6168
	struct request_sock *req;
	bool want_cookie = false;
O
Octavian Purdila 已提交
6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
	if ((sysctl_tcp_syncookies == 2 ||
	     inet_csk_reqsk_queue_is_full(sk)) && !isn) {
		want_cookie = tcp_syn_flood_action(sk, skb, rsk_ops->slab_name);
		if (!want_cookie)
			goto drop;
	}


	/* Accept backlog is full. If we have already queued enough
	 * of warm entries in syn queue, drop request. It is better than
	 * clogging syn queue with openreqs with exponentially increasing
	 * timeout.
	 */
	if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
		goto drop;
	}

6193
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;

	tcp_clear_options(&tmp_opt);
	tmp_opt.mss_clamp = af_ops->mss_clamp;
	tmp_opt.user_mss  = tp->rx_opt.user_mss;
	tcp_parse_options(skb, &tmp_opt, 0, want_cookie ? NULL : &foc);

	if (want_cookie && !tmp_opt.saw_tstamp)
		tcp_clear_options(&tmp_opt);

	tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
	tcp_openreq_init(req, &tmp_opt, skb, sk);

6210
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6211
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6212

O
Octavian Purdila 已提交
6213 6214 6215 6216 6217
	af_ops->init_req(req, sk, skb);

	if (security_inet_conn_request(sk, skb, req))
		goto drop_and_free;

6218
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6219 6220 6221 6222 6223 6224 6225 6226 6227
		/* VJ's idea. We save last timestamp seen
		 * from the destination in peer table, when entering
		 * state TIME-WAIT, and check against it before
		 * accepting new connection request.
		 *
		 * If "isn" is not zero, this request hit alive
		 * timewait bucket, so that all the necessary checks
		 * are made in the function processing timewait state.
		 */
6228
		if (tcp_death_row.sysctl_tw_recycle) {
O
Octavian Purdila 已提交
6229 6230 6231
			bool strict;

			dst = af_ops->route_req(sk, &fl, req, &strict);
6232

O
Octavian Purdila 已提交
6233
			if (dst && strict &&
6234 6235
			    !tcp_peer_is_proven(req, dst, true,
						tmp_opt.saw_tstamp)) {
O
Octavian Purdila 已提交
6236 6237 6238 6239 6240 6241 6242 6243
				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
				goto drop_and_release;
			}
		}
		/* Kill the following clause, if you dislike this way. */
		else if (!sysctl_tcp_syncookies &&
			 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
			  (sysctl_max_syn_backlog >> 2)) &&
6244 6245
			 !tcp_peer_is_proven(req, dst, false,
					     tmp_opt.saw_tstamp)) {
O
Octavian Purdila 已提交
6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265
			/* Without syncookies last quarter of
			 * backlog is filled with destinations,
			 * proven to be alive.
			 * It means that we continue to communicate
			 * to destinations, already remembered
			 * to the moment of synflood.
			 */
			pr_drop_req(req, ntohs(tcp_hdr(skb)->source),
				    rsk_ops->family);
			goto drop_and_release;
		}

		isn = af_ops->init_seq(skb);
	}
	if (!dst) {
		dst = af_ops->route_req(sk, &fl, req, NULL);
		if (!dst)
			goto drop_and_free;
	}

6266 6267 6268 6269 6270 6271 6272 6273 6274
	tcp_ecn_create_request(req, skb, sk, dst);

	if (want_cookie) {
		isn = cookie_init_sequence(af_ops, sk, skb, &req->mss);
		req->cookie_ts = tmp_opt.tstamp_ok;
		if (!tmp_opt.tstamp_ok)
			inet_rsk(req)->ecn_ok = 0;
	}

O
Octavian Purdila 已提交
6275
	tcp_rsk(req)->snt_isn = isn;
6276
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6277
	tcp_openreq_init_rwin(req, sk, dst);
6278 6279
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6280
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
6281
	}
6282
	if (fastopen_sk) {
6283
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6284
				    &foc, false);
6285 6286 6287 6288
		/* Add the child socket directly into the accept queue */
		inet_csk_reqsk_queue_add(sk, req, fastopen_sk);
		sk->sk_data_ready(sk);
		bh_unlock_sock(fastopen_sk);
6289 6290
		sock_put(fastopen_sk);
	} else {
6291
		tcp_rsk(req)->tfo_listener = false;
6292 6293 6294
		if (!want_cookie)
			inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
		af_ops->send_synack(sk, dst, &fl, req,
6295
				    &foc, !want_cookie);
6296 6297
		if (want_cookie)
			goto drop_and_free;
O
Octavian Purdila 已提交
6298
	}
6299
	reqsk_put(req);
O
Octavian Purdila 已提交
6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);