tcp_input.c 182.3 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

Y
Yuchung Cheng 已提交
79
int sysctl_tcp_fack __read_mostly;
80
int sysctl_tcp_max_reordering __read_mostly = 300;
81 82
int sysctl_tcp_dsack __read_mostly = 1;
int sysctl_tcp_app_win __read_mostly = 31;
83
int sysctl_tcp_adv_win_scale __read_mostly = 1;
E
Eric Dumazet 已提交
84
EXPORT_SYMBOL(sysctl_tcp_adv_win_scale);
L
Linus Torvalds 已提交
85

E
Eric Dumazet 已提交
86
/* rfc5961 challenge ack rate limiting */
87
int sysctl_tcp_challenge_ack_limit = 1000;
E
Eric Dumazet 已提交
88

89 90 91
int sysctl_tcp_stdurg __read_mostly;
int sysctl_tcp_rfc1337 __read_mostly;
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
92
int sysctl_tcp_frto __read_mostly = 2;
93
int sysctl_tcp_min_rtt_wlen __read_mostly = 300;
94
int sysctl_tcp_moderate_rcvbuf __read_mostly = 1;
N
Nandita Dukkipati 已提交
95
int sysctl_tcp_early_retrans __read_mostly = 3;
96
int sysctl_tcp_invalid_ratelimit __read_mostly = HZ/2;
L
Linus Torvalds 已提交
97 98 99 100 101 102 103 104

#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				*/
105
#define FLAG_LOST_RETRANS	0x80 /* This ACK marks some retransmission lost */
106
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
Y
Yuchung Cheng 已提交
107
#define FLAG_ORIG_SACK_ACKED	0x200 /* Never retransmitted data are (s)acked	*/
108
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
109
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
110
#define FLAG_SET_XMIT_TIMER	0x1000 /* Set TLP or RTO timer */
111
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
112
#define FLAG_UPDATE_TS_RECENT	0x4000 /* tcp_replace_ts_recent() */
113
#define FLAG_NO_CHALLENGE_ACK	0x8000 /* do not call tcp_send_challenge_ack()	*/
L
Linus Torvalds 已提交
114 115 116 117 118 119 120

#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)
121
#define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
L
Linus Torvalds 已提交
122

123 124 125 126
#define REXMIT_NONE	0 /* no loss recovery to do */
#define REXMIT_LOST	1 /* retransmit packets marked lost */
#define REXMIT_NEW	2 /* FRTO-style transmit of unsent/new packets */

127 128
static void tcp_gro_dev_warn(struct sock *sk, const struct sk_buff *skb,
			     unsigned int len)
129 130 131 132 133 134 135 136 137 138
{
	static bool __once __read_mostly;

	if (!__once) {
		struct net_device *dev;

		__once = true;

		rcu_read_lock();
		dev = dev_get_by_index_rcu(sock_net(sk), skb->skb_iif);
139 140 141
		if (!dev || len >= dev->mtu)
			pr_warn("%s: Driver has suspect GRO implementation, TCP performance may be compromised.\n",
				dev ? dev->name : "Unknown driver");
142 143 144 145
		rcu_read_unlock();
	}
}

146
/* Adapt the MSS value used to make delayed ack decision to the
L
Linus Torvalds 已提交
147
 * real world.
148
 */
149
static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
150
{
151
	struct inet_connection_sock *icsk = inet_csk(sk);
152
	const unsigned int lss = icsk->icsk_ack.last_seg_size;
153
	unsigned int len;
L
Linus Torvalds 已提交
154

155
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
156 157 158 159

	/* skb->len may jitter because of SACKs, even if peer
	 * sends good full-sized frames.
	 */
160
	len = skb_shinfo(skb)->gso_size ? : skb->len;
161
	if (len >= icsk->icsk_ack.rcv_mss) {
162 163
		icsk->icsk_ack.rcv_mss = min_t(unsigned int, len,
					       tcp_sk(sk)->advmss);
164 165 166 167
		/* Account for possibly-removed options */
		if (unlikely(len > icsk->icsk_ack.rcv_mss +
				   MAX_TCP_OPTION_SPACE))
			tcp_gro_dev_warn(sk, skb, len);
L
Linus Torvalds 已提交
168 169 170 171 172 173
	} else {
		/* Otherwise, we make more careful check taking into account,
		 * that SACKs block is variable.
		 *
		 * "len" is invariant segment length, including TCP header.
		 */
174
		len += skb->data - skb_transport_header(skb);
175
		if (len >= TCP_MSS_DEFAULT + sizeof(struct tcphdr) ||
L
Linus Torvalds 已提交
176 177 178 179 180 181
		    /* 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) &&
182
		     !(tcp_flag_word(tcp_hdr(skb)) & TCP_REMNANT))) {
L
Linus Torvalds 已提交
183 184 185 186
			/* Subtract also invariant (if peer is RFC compliant),
			 * tcp header plus fixed timestamp option length.
			 * Resulting "len" is MSS free of SACK jitter.
			 */
187 188
			len -= tcp_sk(sk)->tcp_header_len;
			icsk->icsk_ack.last_seg_size = len;
L
Linus Torvalds 已提交
189
			if (len == lss) {
190
				icsk->icsk_ack.rcv_mss = len;
L
Linus Torvalds 已提交
191 192 193
				return;
			}
		}
194 195
		if (icsk->icsk_ack.pending & ICSK_ACK_PUSHED)
			icsk->icsk_ack.pending |= ICSK_ACK_PUSHED2;
196
		icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
L
Linus Torvalds 已提交
197 198 199
	}
}

200
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
201
{
202
	struct inet_connection_sock *icsk = inet_csk(sk);
203
	unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
204

205 206
	if (quickacks == 0)
		quickacks = 2;
207 208
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
209 210
}

211
static void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
212
{
213 214 215 216
	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 已提交
217 218 219 220 221 222
}

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

223
static bool tcp_in_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
224
{
225
	const struct inet_connection_sock *icsk = inet_csk(sk);
226
	const struct dst_entry *dst = __sk_dst_get(sk);
E
Eric Dumazet 已提交
227

228 229
	return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong);
L
Linus Torvalds 已提交
230 231
}

232
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
233
{
234
	if (tp->ecn_flags & TCP_ECN_OK)
235 236 237
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

238
static void tcp_ecn_accept_cwr(struct tcp_sock *tp, const struct sk_buff *skb)
239 240 241 242 243
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

244
static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
245 246 247 248
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

249
static void __tcp_ecn_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
250
{
251
	switch (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK) {
252
	case INET_ECN_NOT_ECT:
253
		/* Funny extension: if ECT is not set on a segment,
254 255 256 257
		 * and we already seen ECT on a previous segment,
		 * it is probably a retransmit.
		 */
		if (tp->ecn_flags & TCP_ECN_SEEN)
258
			tcp_enter_quickack_mode((struct sock *)tp);
259 260
		break;
	case INET_ECN_CE:
261 262 263
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_IS_CE);

264 265 266 267 268
		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;
		}
269 270
		tp->ecn_flags |= TCP_ECN_SEEN;
		break;
271
	default:
272 273
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_NO_CE);
274
		tp->ecn_flags |= TCP_ECN_SEEN;
275
		break;
276 277 278
	}
}

279 280 281 282 283 284 285
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)
286
{
287
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
288 289 290
		tp->ecn_flags &= ~TCP_ECN_OK;
}

291
static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
292
{
293
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
294 295 296
		tp->ecn_flags &= ~TCP_ECN_OK;
}

297
static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
298
{
299
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
E
Eric Dumazet 已提交
300 301
		return true;
	return false;
302 303
}

L
Linus Torvalds 已提交
304 305 306 307 308
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

E
Eric Dumazet 已提交
309
static void tcp_sndbuf_expand(struct sock *sk)
L
Linus Torvalds 已提交
310
{
E
Eric Dumazet 已提交
311
	const struct tcp_sock *tp = tcp_sk(sk);
312
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
E
Eric Dumazet 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
	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)
	 */
333 334
	sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
	sndmem *= nr_segs * per_mss;
L
Linus Torvalds 已提交
335

336 337
	if (sk->sk_sndbuf < sndmem)
		sk->sk_sndbuf = min(sndmem, sysctl_tcp_wmem[2]);
L
Linus Torvalds 已提交
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
}

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

/* Slow part of check#2. */
366
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
367
{
368
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
369
	/* Optimize this! */
370 371
	int truesize = tcp_win_from_space(skb->truesize) >> 1;
	int window = tcp_win_from_space(sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
372 373 374

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
375
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
376 377 378 379 380 381 382

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

383
static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
384
{
385 386
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
387 388 389
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
390
	    !tcp_under_memory_pressure(sk)) {
L
Linus Torvalds 已提交
391 392 393 394 395 396
		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)
397
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
398
		else
399
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
400 401

		if (incr) {
402
			incr = max_t(int, incr, 2 * skb->len);
403 404
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
405
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
406 407 408 409 410 411 412
		}
	}
}

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

416 417
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
418

E
Eric Dumazet 已提交
419 420 421 422 423 424
	/* 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;

425 426
	if (sk->sk_rcvbuf < rcvmem)
		sk->sk_rcvbuf = min(rcvmem, sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
427 428
}

S
Stephen Hemminger 已提交
429
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
430 431
 *    established state.
 */
432
void tcp_init_buffer_space(struct sock *sk)
L
Linus Torvalds 已提交
433 434 435 436 437 438 439
{
	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 已提交
440
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
441 442

	tp->rcvq_space.space = tp->rcv_wnd;
443
	tcp_mstamp_refresh(tp);
444
	tp->rcvq_space.time = tp->tcp_mstamp;
E
Eric Dumazet 已提交
445
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464

	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);
465
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
466 467 468
}

/* 5. Recalculate window clamp after socket hit its memory bounds. */
469
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
470
{
471
	struct tcp_sock *tp = tcp_sk(sk);
472
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
473

474
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
475

476 477
	if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
478
	    !tcp_under_memory_pressure(sk) &&
479
	    sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
480 481
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
				    sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
482
	}
483
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
484
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
485 486
}

S
Stephen Hemminger 已提交
487 488 489 490 491 492 493 494 495
/* 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)
{
496
	const struct tcp_sock *tp = tcp_sk(sk);
S
Stephen Hemminger 已提交
497 498
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

499
	hint = min(hint, tp->rcv_wnd / 2);
500
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
501 502 503 504
	hint = max(hint, TCP_MIN_MSS);

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

L
Linus Torvalds 已提交
507 508 509 510
/* 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.
511
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
L
Linus Torvalds 已提交
512 513
 *
 * More detail on this code can be found at
514
 * <http://staff.psc.edu/jheffner/>,
L
Linus Torvalds 已提交
515 516 517 518 519
 * 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)
{
520
	u32 new_sample = tp->rcv_rtt_est.rtt_us;
L
Linus Torvalds 已提交
521 522 523 524 525 526 527 528 529 530 531 532
	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 已提交
533
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
534
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
535 536 537 538 539
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
540 541 542 543 544
		} else {
			m <<= 3;
			if (m < new_sample)
				new_sample = m;
		}
L
Linus Torvalds 已提交
545
	} else {
S
Stephen Hemminger 已提交
546
		/* No previous measure. */
L
Linus Torvalds 已提交
547 548 549
		new_sample = m << 3;
	}

550
	tp->rcv_rtt_est.rtt_us = new_sample;
L
Linus Torvalds 已提交
551 552 553 554
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
555 556
	u32 delta_us;

557
	if (tp->rcv_rtt_est.time == 0)
L
Linus Torvalds 已提交
558 559 560
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
561
	delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time);
562
	tcp_rcv_rtt_update(tp, delta_us, 1);
L
Linus Torvalds 已提交
563 564 565

new_measure:
	tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
566
	tp->rcv_rtt_est.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
567 568
}

569 570
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
571
{
572
	struct tcp_sock *tp = tcp_sk(sk);
573

L
Linus Torvalds 已提交
574 575
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
576 577 578 579 580 581
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss)) {
		u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr;
		u32 delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);

		tcp_rcv_rtt_update(tp, delta_us, 0);
	}
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591
}

/*
 * 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 已提交
592
	int copied;
593

594
	time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
595
	if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
L
Linus Torvalds 已提交
596
		return;
597

E
Eric Dumazet 已提交
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
	/* 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 已提交
615

E
Eric Dumazet 已提交
616 617 618 619
		/* 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 已提交
620

E
Eric Dumazet 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633
		/* 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 已提交
634

E
Eric Dumazet 已提交
635 636 637
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
		while (tcp_win_from_space(rcvmem) < tp->advmss)
			rcvmem += 128;
L
Linus Torvalds 已提交
638

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

E
Eric Dumazet 已提交
643 644
			/* Make the window clamp follow along.  */
			tp->window_clamp = rcvwin;
L
Linus Torvalds 已提交
645 646
		}
	}
E
Eric Dumazet 已提交
647
	tp->rcvq_space.space = copied;
648

L
Linus Torvalds 已提交
649 650
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
651
	tp->rcvq_space.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
652 653 654 655 656 657 658 659 660 661 662 663
}

/* 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
 */
664
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
665
{
666
	struct tcp_sock *tp = tcp_sk(sk);
667
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
668 669
	u32 now;

670
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
671

672
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
673 674

	tcp_rcv_rtt_measure(tp);
675

676
	now = tcp_jiffies32;
L
Linus Torvalds 已提交
677

678
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
679 680 681
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
682 683
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
684
	} else {
685
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
686

687
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
688
			/* The fastest case is the first. */
689 690 691 692 693 694
			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 已提交
695
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
696 697
			 * restart window, so that we send ACKs quickly.
			 */
698
			tcp_incr_quickack(sk);
699
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
700 701
		}
	}
702
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
703

704
	tcp_ecn_check_ce(tp, skb);
L
Linus Torvalds 已提交
705 706

	if (skb->len >= 128)
707
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
708 709 710 711 712 713 714 715 716 717 718
}

/* 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
 */
719
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
720
{
721
	struct tcp_sock *tp = tcp_sk(sk);
722 723
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
724 725 726 727

	/*	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.
728
	 *	This is designed to be as fast as possible
L
Linus Torvalds 已提交
729 730 731 732 733 734 735
	 *	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 已提交
736
	 * too slowly, when it should be increased quickly, decrease too quickly
L
Linus Torvalds 已提交
737 738 739 740
	 * 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)
	 */
741 742 743
	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 已提交
744 745
		if (m < 0) {
			m = -m;		/* m is now abs(error) */
746
			m -= (tp->mdev_us >> 2);   /* similar update on mdev */
L
Linus Torvalds 已提交
747 748 749 750 751 752 753 754 755 756 757
			/* 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 {
758
			m -= (tp->mdev_us >> 2);   /* similar update on mdev */
L
Linus Torvalds 已提交
759
		}
760 761 762 763 764
		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 已提交
765 766
		}
		if (after(tp->snd_una, tp->rtt_seq)) {
767 768
			if (tp->mdev_max_us < tp->rttvar_us)
				tp->rttvar_us -= (tp->rttvar_us - tp->mdev_max_us) >> 2;
L
Linus Torvalds 已提交
769
			tp->rtt_seq = tp->snd_nxt;
770
			tp->mdev_max_us = tcp_rto_min_us(sk);
L
Linus Torvalds 已提交
771 772 773
		}
	} else {
		/* no previous measure. */
774
		srtt = m << 3;		/* take the measured time to be rtt */
775 776 777
		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 已提交
778 779
		tp->rtt_seq = tp->snd_nxt;
	}
780
	tp->srtt_us = max(1U, srtt);
L
Linus Torvalds 已提交
781 782
}

E
Eric Dumazet 已提交
783 784 785 786 787 788
/* 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)
 */
789 790 791
int sysctl_tcp_pacing_ss_ratio __read_mostly = 200;
int sysctl_tcp_pacing_ca_ratio __read_mostly = 120;

E
Eric Dumazet 已提交
792 793 794 795 796 797
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) */
798 799 800 801 802 803 804 805 806 807 808 809 810 811
	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 已提交
812 813 814

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

815 816
	if (likely(tp->srtt_us))
		do_div(rate, tp->srtt_us);
E
Eric Dumazet 已提交
817

818 819 820 821 822 823
	/* 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 已提交
824 825
}

L
Linus Torvalds 已提交
826 827 828
/* Calculate rto without backoff.  This is the second half of Van Jacobson's
 * routine referred to above.
 */
829
static void tcp_set_rto(struct sock *sk)
L
Linus Torvalds 已提交
830
{
831
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
832 833 834 835 836 837 838 839
	/* 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 已提交
840
	 *    ACKs in some circumstances.
L
Linus Torvalds 已提交
841
	 */
842
	inet_csk(sk)->icsk_rto = __tcp_set_rto(tp);
L
Linus Torvalds 已提交
843 844 845 846

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

850 851 852
	/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
	 * guarantees that rto is higher.
	 */
853
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
854 855
}

856
__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
L
Linus Torvalds 已提交
857 858 859
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

860
	if (!cwnd)
861
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
862 863 864
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

865 866 867 868
/*
 * Packet counting of FACK is based on in-order assumptions, therefore TCP
 * disables it when reordering is detected
 */
869
void tcp_disable_fack(struct tcp_sock *tp)
870
{
871 872 873
	/* RFC3517 uses different metric in lost marker => reset on change */
	if (tcp_is_fack(tp))
		tp->lost_skb_hint = NULL;
874
	tp->rx_opt.sack_ok &= ~TCP_FACK_ENABLED;
875 876
}

877
/* Take a notice that peer is sending D-SACKs */
878 879
static void tcp_dsack_seen(struct tcp_sock *tp)
{
880
	tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
881 882
}

883 884
static void tcp_update_reordering(struct sock *sk, const int metric,
				  const int ts)
L
Linus Torvalds 已提交
885
{
886
	struct tcp_sock *tp = tcp_sk(sk);
887
	int mib_idx;
888

889 890 891
	if (WARN_ON_ONCE(metric < 0))
		return;

892
	if (metric > tp->reordering) {
893
		tp->reordering = min(sysctl_tcp_max_reordering, metric);
L
Linus Torvalds 已提交
894 895

#if FASTRETRANS_DEBUG > 1
896 897 898 899 900 901
		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 已提交
902
#endif
903
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
904
	}
Y
Yuchung Cheng 已提交
905

Y
Yuchung Cheng 已提交
906
	tp->rack.reord = 1;
907 908 909 910 911 912 913 914 915 916 917 918

	/* This exciting event is worth to be remembered. 8) */
	if (ts)
		mib_idx = LINUX_MIB_TCPTSREORDER;
	else if (tcp_is_reno(tp))
		mib_idx = LINUX_MIB_TCPRENOREORDER;
	else if (tcp_is_fack(tp))
		mib_idx = LINUX_MIB_TCPFACKREORDER;
	else
		mib_idx = LINUX_MIB_TCPSACKREORDER;

	NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
919 920
}

921
/* This must be called before lost_out is incremented */
922 923
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
924
	if (!tp->retransmit_skb_hint ||
925 926
	    before(TCP_SKB_CB(skb)->seq,
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
927
		tp->retransmit_skb_hint = skb;
928 929
}

930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
/* Sum the number of packets on the wire we have marked as lost.
 * There are two cases we care about here:
 * a) Packet hasn't been marked lost (nor retransmitted),
 *    and this is the first loss.
 * b) Packet has been marked both lost and retransmitted,
 *    and this means we think it was lost again.
 */
static void tcp_sum_lost(struct tcp_sock *tp, struct sk_buff *skb)
{
	__u8 sacked = TCP_SKB_CB(skb)->sacked;

	if (!(sacked & TCPCB_LOST) ||
	    ((sacked & TCPCB_LOST) && (sacked & TCPCB_SACKED_RETRANS)))
		tp->lost += tcp_skb_pcount(skb);
}

946 947 948 949 950 951
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);
952
		tcp_sum_lost(tp, skb);
953 954 955 956
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

Y
Yuchung Cheng 已提交
957
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
958 959 960
{
	tcp_verify_retransmit_hint(tp, skb);

961
	tcp_sum_lost(tp, skb);
962 963 964 965 966 967
	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 已提交
968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
/* 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())
989
 * 3. Loss detection event of two flavors:
L
Linus Torvalds 已提交
990 991
 *	A. Scoreboard estimator decided the packet is lost.
 *	   A'. Reno "three dupacks" marks head of queue lost.
992 993
 *	   A''. Its FACK modification, head until snd.fack is lost.
 *	B. SACK arrives sacking SND.NXT at the moment, when the
L
Linus Torvalds 已提交
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
 *	   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 已提交
1013 1014 1015 1016 1017 1018 1019
 *
 * 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
1020 1021 1022 1023 1024 1025 1026 1027 1028
 * 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 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
 *
 * 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
1051
 * again, D-SACK block must not to go across snd_una (for the same reason as
I
Ilpo Järvinen 已提交
1052 1053 1054 1055 1056 1057 1058 1059 1060
 * 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 已提交
1061
 */
E
Eric Dumazet 已提交
1062 1063
static bool tcp_is_sackblock_valid(struct tcp_sock *tp, bool is_dsack,
				   u32 start_seq, u32 end_seq)
I
Ilpo Järvinen 已提交
1064 1065 1066
{
	/* Too far in future, or reversed (interpretation is ambiguous) */
	if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
E
Eric Dumazet 已提交
1067
		return false;
I
Ilpo Järvinen 已提交
1068 1069 1070

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

1073
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1074 1075 1076
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
E
Eric Dumazet 已提交
1077
		return true;
I
Ilpo Järvinen 已提交
1078 1079

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

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

	if (!before(start_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1087
		return true;
I
Ilpo Järvinen 已提交
1088 1089 1090

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1091
		return false;
I
Ilpo Järvinen 已提交
1092 1093 1094 1095 1096 1097 1098

	/* 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 已提交
1099 1100 1101
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)
1102
{
1103
	struct tcp_sock *tp = tcp_sk(sk);
1104 1105
	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 已提交
1106
	bool dup_sack = false;
1107 1108

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
E
Eric Dumazet 已提交
1109
		dup_sack = true;
1110
		tcp_dsack_seen(tp);
1111
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1112
	} else if (num_sacks > 1) {
1113 1114
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1115 1116 1117

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
E
Eric Dumazet 已提交
1118
			dup_sack = true;
1119
			tcp_dsack_seen(tp);
1120
			NET_INC_STATS(sock_net(sk),
1121
					LINUX_MIB_TCPDSACKOFORECV);
1122 1123 1124 1125
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1126
	if (dup_sack && tp->undo_marker && tp->undo_retrans > 0 &&
1127 1128 1129 1130 1131 1132 1133
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1134
struct tcp_sacktag_state {
1135 1136
	int	reord;
	int	fack_count;
1137 1138 1139 1140
	/* 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.
	 */
1141 1142
	u64	first_sackt;
	u64	last_sackt;
1143
	struct rate_sample *rate;
1144
	int	flag;
1145 1146
};

1147 1148 1149 1150 1151
/* 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).
1152 1153
 *
 * FIXME: this could be merged to shift decision code
1154
 */
1155
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
E
Eric Dumazet 已提交
1156
				  u32 start_seq, u32 end_seq)
1157
{
E
Eric Dumazet 已提交
1158 1159
	int err;
	bool in_sack;
1160
	unsigned int pkt_len;
1161
	unsigned int mss;
1162 1163 1164 1165 1166 1167

	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)) {
1168
		mss = tcp_skb_mss(skb);
1169 1170
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1171
		if (!in_sack) {
1172
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1173 1174 1175
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1176
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1177 1178 1179 1180 1181 1182 1183 1184 1185
			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;
1186
			if (!in_sack && new_len < pkt_len)
1187 1188 1189
				new_len += mss;
			pkt_len = new_len;
		}
1190 1191 1192 1193

		if (pkt_len >= skb->len && !in_sack)
			return 0;

1194
		err = tcp_fragment(sk, skb, pkt_len, mss, GFP_ATOMIC);
1195 1196 1197 1198 1199 1200 1201
		if (err < 0)
			return err;
	}

	return in_sack;
}

1202 1203 1204 1205
/* 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,
1206
			  int dup_sack, int pcount,
1207
			  u64 xmit_time)
1208
{
1209
	struct tcp_sock *tp = tcp_sk(sk);
1210
	int fack_count = state->fack_count;
1211 1212 1213

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1214
		if (tp->undo_marker && tp->undo_retrans > 0 &&
1215
		    after(end_seq, tp->undo_marker))
1216
			tp->undo_retrans--;
1217
		if (sacked & TCPCB_SACKED_ACKED)
1218
			state->reord = min(fack_count, state->reord);
1219 1220 1221
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
1222
	if (!after(end_seq, tp->snd_una))
1223
		return sacked;
1224 1225

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1226
		tcp_rack_advance(tp, sacked, end_seq, xmit_time);
1227

1228 1229 1230 1231 1232 1233
		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) {
1234
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1235 1236
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1237 1238 1239 1240 1241 1242
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
1243
				if (before(start_seq,
1244
					   tcp_highest_sack_seq(tp)))
1245 1246
					state->reord = min(fack_count,
							   state->reord);
Y
Yuchung Cheng 已提交
1247 1248
				if (!after(end_seq, tp->high_seq))
					state->flag |= FLAG_ORIG_SACK_ACKED;
1249 1250 1251
				if (state->first_sackt == 0)
					state->first_sackt = xmit_time;
				state->last_sackt = xmit_time;
1252 1253 1254
			}

			if (sacked & TCPCB_LOST) {
1255
				sacked &= ~TCPCB_LOST;
1256
				tp->lost_out -= pcount;
1257 1258 1259
			}
		}

1260 1261
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1262
		tp->sacked_out += pcount;
Y
Yuchung Cheng 已提交
1263
		tp->delivered += pcount;  /* Out-of-order packets delivered */
1264

1265
		fack_count += pcount;
1266 1267

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
1268
		if (!tcp_is_fack(tp) && tp->lost_skb_hint &&
1269
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1270
			tp->lost_cnt_hint += pcount;
1271 1272 1273 1274 1275 1276 1277 1278 1279

		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.
	 */
1280 1281
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1282
		tp->retrans_out -= pcount;
1283 1284
	}

1285
	return sacked;
1286 1287
}

1288 1289 1290
/* 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 已提交
1291 1292 1293 1294
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)
1295 1296
{
	struct tcp_sock *tp = tcp_sk(sk);
1297
	struct sk_buff *prev = tcp_write_queue_prev(sk, skb);
1298 1299
	u32 start_seq = TCP_SKB_CB(skb)->seq;	/* start of newly-SACKed */
	u32 end_seq = start_seq + shifted;	/* end of newly-SACKed */
1300 1301 1302

	BUG_ON(!pcount);

1303 1304 1305 1306 1307 1308 1309
	/* 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 已提交
1310
			start_seq, end_seq, dup_sack, pcount,
1311
			skb->skb_mstamp);
1312
	tcp_rate_skb_delivered(sk, skb, state->rate);
1313 1314

	if (skb == tp->lost_skb_hint)
1315 1316
		tp->lost_cnt_hint += pcount;

1317 1318 1319
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

1320 1321 1322
	tcp_skb_pcount_add(prev, pcount);
	BUG_ON(tcp_skb_pcount(skb) < pcount);
	tcp_skb_pcount_add(skb, -pcount);
1323 1324 1325 1326 1327 1328

	/* 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.
	 */
1329 1330
	if (!TCP_SKB_CB(prev)->tcp_gso_size)
		TCP_SKB_CB(prev)->tcp_gso_size = mss;
1331 1332

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
1333
	if (tcp_skb_pcount(skb) <= 1)
1334
		TCP_SKB_CB(skb)->tcp_gso_size = 0;
1335 1336 1337 1338 1339 1340

	/* 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));
1341
		NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
E
Eric Dumazet 已提交
1342
		return false;
1343 1344 1345 1346
	}

	/* Whole SKB was eaten :-) */

1347 1348 1349 1350 1351 1352 1353
	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);
	}

1354
	TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1355
	TCP_SKB_CB(prev)->eor = TCP_SKB_CB(skb)->eor;
1356 1357 1358
	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
		TCP_SKB_CB(prev)->end_seq++;

1359 1360 1361
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

1362
	tcp_skb_collapse_tstamp(prev, skb);
1363 1364
	if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp))
		TCP_SKB_CB(prev)->tx.delivered_mstamp = 0;
1365

1366 1367 1368
	tcp_unlink_write_queue(skb, sk);
	sk_wmem_free_skb(sk, skb);

1369
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1370

E
Eric Dumazet 已提交
1371
	return true;
1372 1373 1374 1375 1376
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1377
static int tcp_skb_seglen(const struct sk_buff *skb)
1378
{
1379
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1380 1381 1382
}

/* Shifting pages past head area doesn't work */
1383
static int skb_can_shift(const struct sk_buff *skb)
1384 1385 1386 1387 1388 1389 1390 1391
{
	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,
1392
					  struct tcp_sacktag_state *state,
1393
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1394
					  bool dup_sack)
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
{
	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 &&
1408
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
		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;

1424 1425 1426
	if (!tcp_skb_can_collapse_to(prev))
		goto fallback;

1427 1428 1429 1430 1431 1432
	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);
1433
		mss = tcp_skb_seglen(skb);
1434 1435 1436 1437

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1438
		if (mss != tcp_skb_seglen(prev))
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478
			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
		 */
1479
		if (mss != tcp_skb_seglen(prev))
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
			goto fallback;

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

1492 1493 1494 1495
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1496 1497
	if (!skb_shift(prev, skb, len))
		goto fallback;
I
Ilpo Järvinen 已提交
1498
	if (!tcp_shifted_skb(sk, skb, state, pcount, len, mss, dup_sack))
1499 1500 1501 1502 1503 1504 1505 1506 1507
		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);

1508 1509 1510
	if (!skb_can_shift(skb) ||
	    (skb == tcp_send_head(sk)) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1511
	    (mss != tcp_skb_seglen(skb)))
1512 1513 1514 1515 1516
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
I
Ilpo Järvinen 已提交
1517
		tcp_shifted_skb(sk, skb, state, tcp_skb_pcount(skb), len, mss, 0);
1518 1519 1520
	}

out:
1521
	state->fack_count += pcount;
1522 1523 1524 1525 1526 1527
	return prev;

noop:
	return skb;

fallback:
1528
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1529 1530 1531
	return NULL;
}

1532 1533
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1534
					struct tcp_sacktag_state *state,
1535
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1536
					bool dup_sack_in)
1537
{
1538 1539 1540
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1541 1542
	tcp_for_write_queue_from(skb, sk) {
		int in_sack = 0;
E
Eric Dumazet 已提交
1543
		bool dup_sack = dup_sack_in;
1544 1545 1546 1547 1548 1549 1550 1551

		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;

1552
		if (next_dup  &&
1553 1554 1555 1556 1557
		    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 已提交
1558
				dup_sack = true;
1559 1560
		}

1561 1562 1563 1564 1565
		/* 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) {
1566 1567
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1568
			if (tmp) {
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1582 1583 1584
		if (unlikely(in_sack < 0))
			break;

1585
		if (in_sack) {
1586 1587 1588 1589 1590 1591 1592
			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 已提交
1593
						tcp_skb_pcount(skb),
1594
						skb->skb_mstamp);
1595
			tcp_rate_skb_delivered(sk, skb, state->rate);
1596

1597 1598 1599 1600 1601
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}

1602
		state->fack_count += tcp_skb_pcount(skb);
1603 1604 1605 1606 1607 1608 1609 1610
	}
	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,
1611 1612
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1613 1614 1615 1616 1617
{
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;

I
Ilpo Järvinen 已提交
1618
		if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq))
1619
			break;
1620

1621
		state->fack_count += tcp_skb_pcount(skb);
1622 1623 1624 1625 1626 1627 1628
	}
	return skb;
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1629 1630
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1631
{
1632
	if (!next_dup)
1633 1634 1635
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1636 1637 1638 1639
		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);
1640 1641 1642 1643 1644
	}

	return skb;
}

1645
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1646 1647 1648 1649
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1650
static int
1651
tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
1652
			u32 prior_snd_una, struct tcp_sacktag_state *state)
L
Linus Torvalds 已提交
1653 1654
{
	struct tcp_sock *tp = tcp_sk(sk);
1655 1656
	const unsigned char *ptr = (skb_transport_header(ack_skb) +
				    TCP_SKB_CB(ack_skb)->sacked);
1657
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1658
	struct tcp_sack_block sp[TCP_NUM_SACKS];
1659 1660
	struct tcp_sack_block *cache;
	struct sk_buff *skb;
1661
	int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1662
	int used_sacks;
E
Eric Dumazet 已提交
1663
	bool found_dup_sack = false;
1664
	int i, j;
1665
	int first_sack_index;
L
Linus Torvalds 已提交
1666

1667 1668
	state->flag = 0;
	state->reord = tp->packets_out;
1669

1670
	if (!tp->sacked_out) {
1671 1672
		if (WARN_ON(tp->fackets_out))
			tp->fackets_out = 0;
1673
		tcp_highest_sack_reset(sk);
1674
	}
L
Linus Torvalds 已提交
1675

1676
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1677
					 num_sacks, prior_snd_una);
1678
	if (found_dup_sack) {
1679
		state->flag |= FLAG_DSACKING_ACK;
1680 1681
		tp->delivered++; /* A spurious retransmission is delivered */
	}
1682 1683 1684 1685 1686 1687 1688 1689

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

1690 1691 1692
	if (!tp->packets_out)
		goto out;

1693 1694 1695
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
E
Eric Dumazet 已提交
1696
		bool dup_sack = !i && found_dup_sack;
1697

1698 1699
		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);
1700 1701 1702 1703

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

1706 1707
			if (dup_sack) {
				if (!tp->undo_marker)
1708
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1709
				else
1710
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1711 1712 1713 1714 1715
			} 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;
1716
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1717
			}
1718

1719
			NET_INC_STATS(sock_net(sk), mib_idx);
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
			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++;
	}

1732 1733
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1734 1735
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1736
				swap(sp[j], sp[j + 1]);
1737

1738 1739
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1740
					first_sack_index = j + 1;
1741 1742 1743 1744
			}
		}
	}

1745
	skb = tcp_write_queue_head(sk);
1746
	state->fack_count = 0;
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
	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++;
1758 1759
	}

1760
	while (i < used_sacks) {
1761 1762
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
E
Eric Dumazet 已提交
1763
		bool dup_sack = (found_dup_sack && (i == first_sack_index));
1764
		struct tcp_sack_block *next_dup = NULL;
1765

1766 1767
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1768

1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
		/* 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)) {
1780
				skb = tcp_sacktag_skip(skb, sk, state,
1781
						       start_seq);
1782
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1783
						       state,
1784 1785
						       start_seq,
						       cache->start_seq,
1786
						       dup_sack);
1787
			}
1788

1789
			/* Rest of the block already fully processed? */
1790
			if (!after(end_seq, cache->end_seq))
1791
				goto advance_sp;
1792

1793
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1794
						       state,
1795
						       cache->end_seq);
1796

1797
			/* ...tail remains todo... */
1798
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1799
				/* ...but better entrypoint exists! */
1800
				skb = tcp_highest_sack(sk);
1801
				if (!skb)
1802
					break;
1803
				state->fack_count = tp->fackets_out;
1804 1805
				cache++;
				goto walk;
1806 1807
			}

1808
			skb = tcp_sacktag_skip(skb, sk, state, cache->end_seq);
1809 1810 1811 1812
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1813

1814 1815
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
1816
			if (!skb)
1817
				break;
1818
			state->fack_count = tp->fackets_out;
L
Linus Torvalds 已提交
1819
		}
1820
		skb = tcp_sacktag_skip(skb, sk, state, start_seq);
1821 1822

walk:
1823
		skb = tcp_sacktag_walk(skb, sk, next_dup, state,
1824
				       start_seq, end_seq, dup_sack);
1825

1826 1827
advance_sp:
		i++;
L
Linus Torvalds 已提交
1828 1829
	}

1830 1831 1832 1833 1834 1835 1836 1837
	/* 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];

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

1842
	tcp_verify_left_out(tp);
1843 1844
out:

L
Linus Torvalds 已提交
1845
#if FASTRETRANS_DEBUG > 0
1846 1847 1848 1849
	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 已提交
1850
#endif
1851
	return state->flag;
L
Linus Torvalds 已提交
1852 1853
}

1854
/* Limits sacked_out so that sum with lost_out isn't ever larger than
E
Eric Dumazet 已提交
1855
 * packets_out. Returns false if sacked_out adjustement wasn't necessary.
1856
 */
E
Eric Dumazet 已提交
1857
static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
1858 1859 1860 1861 1862 1863 1864 1865
{
	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 已提交
1866
		return true;
1867
	}
E
Eric Dumazet 已提交
1868
	return false;
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
}

/* 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);
1880 1881 1882 1883 1884 1885 1886
}

/* 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);
Y
Yuchung Cheng 已提交
1887 1888
	u32 prior_sacked = tp->sacked_out;

1889 1890
	tp->sacked_out++;
	tcp_check_reno_reordering(sk, 0);
Y
Yuchung Cheng 已提交
1891 1892
	if (tp->sacked_out > prior_sacked)
		tp->delivered++; /* Some out-of-order packet is delivered */
1893
	tcp_verify_left_out(tp);
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
}

/* 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. */
Y
Yuchung Cheng 已提交
1904
		tp->delivered += max_t(int, acked - tp->sacked_out, 1);
1905
		if (acked - 1 >= tp->sacked_out)
1906 1907
			tp->sacked_out = 0;
		else
1908
			tp->sacked_out -= acked - 1;
1909 1910
	}
	tcp_check_reno_reordering(sk, acked);
1911
	tcp_verify_left_out(tp);
1912 1913 1914 1915 1916 1917 1918
}

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

Y
Yuchung Cheng 已提交
1919
void tcp_clear_retrans(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1920 1921 1922 1923
{
	tp->retrans_out = 0;
	tp->lost_out = 0;
	tp->undo_marker = 0;
Y
Yuchung Cheng 已提交
1924
	tp->undo_retrans = -1;
Y
Yuchung Cheng 已提交
1925 1926
	tp->fackets_out = 0;
	tp->sacked_out = 0;
L
Linus Torvalds 已提交
1927 1928
}

Y
Yuchung Cheng 已提交
1929
static inline void tcp_init_undo(struct tcp_sock *tp)
1930
{
Y
Yuchung Cheng 已提交
1931 1932 1933
	tp->undo_marker = tp->snd_una;
	/* Retransmission still in flight may cause DSACKs later. */
	tp->undo_retrans = tp->retrans_out ? : -1;
1934 1935
}

1936
/* Enter Loss state. If we detect SACK reneging, forget all SACK information
L
Linus Torvalds 已提交
1937 1938 1939
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
1940
void tcp_enter_loss(struct sock *sk)
L
Linus Torvalds 已提交
1941
{
1942
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1943
	struct tcp_sock *tp = tcp_sk(sk);
1944
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
1945
	struct sk_buff *skb;
1946
	bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
1947
	bool is_reneg;			/* is receiver reneging on SACKs? */
1948
	bool mark_lost;
L
Linus Torvalds 已提交
1949 1950

	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1951 1952
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1953 1954
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
1955
		tp->prior_cwnd = tp->snd_cwnd;
1956 1957
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
Y
Yuchung Cheng 已提交
1958
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1959 1960 1961
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
1962
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
1963

Y
Yuchung Cheng 已提交
1964 1965
	tp->retrans_out = 0;
	tp->lost_out = 0;
1966 1967 1968

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

1970 1971 1972
	skb = tcp_write_queue_head(sk);
	is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
	if (is_reneg) {
1973
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
1974 1975
		tp->sacked_out = 0;
		tp->fackets_out = 0;
1976
	}
1977
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
1978

1979 1980 1981
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1982

1983 1984 1985 1986
		mark_lost = (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
			     is_reneg);
		if (mark_lost)
			tcp_sum_lost(tp, skb);
L
Linus Torvalds 已提交
1987
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
1988
		if (mark_lost) {
L
Linus Torvalds 已提交
1989 1990 1991 1992 1993
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
		}
	}
1994
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1995

1996 1997 1998 1999
	/* 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 &&
2000
	    tp->sacked_out >= net->ipv4.sysctl_tcp_reordering)
2001
		tp->reordering = min_t(unsigned int, tp->reordering,
2002
				       net->ipv4.sysctl_tcp_reordering);
2003
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
2004
	tp->high_seq = tp->snd_nxt;
2005
	tcp_ecn_queue_cwr(tp);
Y
Yuchung Cheng 已提交
2006

2007 2008 2009 2010 2011 2012 2013 2014
	/* 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
	 *
	 * In theory F-RTO can be used repeatedly during loss recovery.
	 * In practice this interacts badly with broken middle-boxes that
	 * falsely raise the receive window, which results in repeated
	 * timeouts and stop-and-go behavior.
Y
Yuchung Cheng 已提交
2015
	 */
2016 2017 2018
	tp->frto = sysctl_tcp_frto &&
		   (new_recovery || icsk->icsk_retransmits) &&
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
2019 2020
}

2021 2022 2023 2024
/* 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).
 *
2025 2026 2027 2028 2029
 * 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.
2030
 */
E
Eric Dumazet 已提交
2031
static bool tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2032
{
2033
	if (flag & FLAG_SACK_RENEGING) {
2034 2035 2036
		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 已提交
2037

2038
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2039
					  delay, TCP_RTO_MAX);
E
Eric Dumazet 已提交
2040
		return true;
L
Linus Torvalds 已提交
2041
	}
E
Eric Dumazet 已提交
2042
	return false;
L
Linus Torvalds 已提交
2043 2044
}

2045
static inline int tcp_fackets_out(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2046
{
2047
	return tcp_is_reno(tp) ? tp->sacked_out + 1 : tp->fackets_out;
L
Linus Torvalds 已提交
2048 2049
}

2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
/* 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.
 */
2065
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2066 2067 2068 2069
{
	return tcp_is_fack(tp) ? tp->fackets_out : tp->sacked_out + 1;
}

L
Linus Torvalds 已提交
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 2108 2109 2110 2111 2112 2113 2114 2115 2116
/* 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.
 *
2117
 *		Essentially, we have now a few algorithms detecting
L
Linus Torvalds 已提交
2118 2119
 *		lost packets.
 *
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
 *		If the receiver supports SACK:
 *
 *		RFC6675/3517: It is the conventional algorithm. A packet is
 *		considered lost if the number of higher sequence packets
 *		SACKed is greater than or equal the DUPACK thoreshold
 *		(reordering). This is implemented in tcp_mark_head_lost and
 *		tcp_update_scoreboard.
 *
 *		RACK (draft-ietf-tcpm-rack-01): it is a newer algorithm
 *		(2017-) that checks timing instead of counting DUPACKs.
 *		Essentially a packet is considered lost if it's not S/ACKed
 *		after RTT + reordering_window, where both metrics are
 *		dynamically measured and adjusted. This is implemented in
 *		tcp_rack_mark_lost.
 *
Y
Yuchung Cheng 已提交
2135 2136
 *		FACK (Disabled by default. Subsumbed by RACK):
 *		It is the simplest heuristics. As soon as we decided
L
Linus Torvalds 已提交
2137 2138 2139 2140 2141 2142 2143 2144
 *		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.
 *
2145 2146 2147
 *		If the receiver does not support SACK:
 *
 *		NewReno (RFC6582): in Recovery we assume that one segment
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
 *		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.
 *
 * 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 已提交
2177
static bool tcp_time_to_recover(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2178
{
2179
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2180 2181 2182

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

	/* Not-A-Trick#2 : Classic rule... */
2186
	if (tcp_dupack_heuristics(tp) > tp->reordering)
E
Eric Dumazet 已提交
2187
		return true;
L
Linus Torvalds 已提交
2188

E
Eric Dumazet 已提交
2189
	return false;
L
Linus Torvalds 已提交
2190 2191
}

2192 2193 2194 2195 2196
/* 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.
2197
 */
I
Ilpo Järvinen 已提交
2198
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2199
{
2200
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2201
	struct sk_buff *skb;
2202
	int cnt, oldcnt, lost;
2203
	unsigned int mss;
2204 2205
	/* 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 已提交
2206

2207
	WARN_ON(packets > tp->packets_out);
2208 2209 2210
	if (tp->lost_skb_hint) {
		skb = tp->lost_skb_hint;
		cnt = tp->lost_cnt_hint;
I
Ilpo Järvinen 已提交
2211 2212 2213
		/* Head already handled? */
		if (mark_head && skb != tcp_write_queue_head(sk))
			return;
2214
	} else {
2215
		skb = tcp_write_queue_head(sk);
2216 2217
		cnt = 0;
	}
L
Linus Torvalds 已提交
2218

2219 2220 2221
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2222 2223 2224 2225
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2226

2227
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2228 2229 2230
			break;

		oldcnt = cnt;
2231
		if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
2232 2233 2234
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2235
		if (cnt > packets) {
2236
			if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) ||
2237
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2238
			    (oldcnt >= packets))
2239 2240
				break;

2241
			mss = tcp_skb_mss(skb);
2242 2243 2244 2245
			/* 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)
2246 2247 2248 2249
				break;
			cnt = packets;
		}

2250
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2251 2252 2253

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2254
	}
2255
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2256 2257 2258 2259
}

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

2260
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2261
{
2262 2263
	struct tcp_sock *tp = tcp_sk(sk);

2264
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2265
		tcp_mark_head_lost(sk, 1, 1);
2266
	} else if (tcp_is_fack(tp)) {
L
Linus Torvalds 已提交
2267 2268 2269
		int lost = tp->fackets_out - tp->reordering;
		if (lost <= 0)
			lost = 1;
I
Ilpo Järvinen 已提交
2270
		tcp_mark_head_lost(sk, lost, 0);
L
Linus Torvalds 已提交
2271
	} else {
2272
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2273 2274 2275 2276
		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 已提交
2277 2278 2279
	}
}

2280 2281 2282 2283 2284 2285
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);
}

2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
/* 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 已提交
2296 2297 2298
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2299
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2300 2301
{
	return !tp->retrans_stamp ||
2302
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2303 2304 2305 2306
}

/* Undo procedures. */

2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
/* 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 已提交
2336
#if FASTRETRANS_DEBUG > 1
2337
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2338
{
2339
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2340
	struct inet_sock *inet = inet_sk(sk);
2341

2342
	if (sk->sk_family == AF_INET) {
2343 2344 2345 2346 2347 2348
		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);
2349
	}
E
Eric Dumazet 已提交
2350
#if IS_ENABLED(CONFIG_IPV6)
2351
	else if (sk->sk_family == AF_INET6) {
2352 2353
		pr_debug("Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
			 msg,
2354
			 &sk->sk_v6_daddr, ntohs(inet->inet_dport),
2355 2356 2357
			 tp->snd_cwnd, tcp_left_out(tp),
			 tp->snd_ssthresh, tp->prior_ssthresh,
			 tp->packets_out);
2358 2359
	}
#endif
L
Linus Torvalds 已提交
2360 2361 2362 2363 2364
}
#else
#define DBGUNDO(x...) do { } while (0)
#endif

2365
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2366
{
2367 2368
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
	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 已提交
2381
	if (tp->prior_ssthresh) {
2382 2383
		const struct inet_connection_sock *icsk = inet_csk(sk);

2384
		tp->snd_cwnd = icsk->icsk_ca_ops->undo_cwnd(sk);
L
Linus Torvalds 已提交
2385

2386
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2387
			tp->snd_ssthresh = tp->prior_ssthresh;
2388
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2389 2390
		}
	}
2391
	tp->snd_cwnd_stamp = tcp_jiffies32;
2392
	tp->undo_marker = 0;
L
Linus Torvalds 已提交
2393 2394
}

2395
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2396
{
2397
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2398 2399 2400
}

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

L
Linus Torvalds 已提交
2405
	if (tcp_may_undo(tp)) {
2406 2407
		int mib_idx;

L
Linus Torvalds 已提交
2408 2409 2410
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2411
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2412
		tcp_undo_cwnd_reduction(sk, false);
2413
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2414
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2415
		else
2416 2417
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2418
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
2419
	}
2420
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2421 2422 2423
		/* 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. */
2424 2425
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2426
		return true;
L
Linus Torvalds 已提交
2427
	}
2428
	tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2429
	return false;
L
Linus Torvalds 已提交
2430 2431 2432
}

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

L
Linus Torvalds 已提交
2437
	if (tp->undo_marker && !tp->undo_retrans) {
2438
		DBGUNDO(sk, "D-SACK");
2439
		tcp_undo_cwnd_reduction(sk, false);
2440
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2441
		return true;
L
Linus Torvalds 已提交
2442
	}
2443
	return false;
L
Linus Torvalds 已提交
2444 2445
}

Y
Yuchung Cheng 已提交
2446 2447
/* 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 已提交
2448
{
2449 2450
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2451
	if (frto_undo || tcp_may_undo(tp)) {
2452
		tcp_undo_cwnd_reduction(sk, true);
2453

2454
		DBGUNDO(sk, "partial loss");
2455
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2456
		if (frto_undo)
2457
			NET_INC_STATS(sock_net(sk),
2458
					LINUX_MIB_TCPSPURIOUSRTOS);
2459
		inet_csk(sk)->icsk_retransmits = 0;
Y
Yuchung Cheng 已提交
2460
		if (frto_undo || tcp_is_sack(tp))
2461
			tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2462
		return true;
L
Linus Torvalds 已提交
2463
	}
E
Eric Dumazet 已提交
2464
	return false;
L
Linus Torvalds 已提交
2465 2466
}

2467
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2468 2469 2470 2471
 * 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.
2472 2473 2474
 *   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.
2475
 */
2476
static void tcp_init_cwnd_reduction(struct sock *sk)
2477 2478 2479 2480
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2481
	tp->tlp_high_seq = 0;
2482 2483 2484 2485
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2486
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2487
	tcp_ecn_queue_cwr(tp);
2488 2489
}

2490
void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
2491 2492 2493 2494 2495
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);

2496 2497 2498
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2499
	tp->prr_delivered += newly_acked_sacked;
2500
	if (delta < 0) {
2501 2502 2503
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2504 2505
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2506 2507 2508
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2509 2510
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2511
	}
2512 2513
	/* Force a fast retransmit upon entering fast recovery */
	sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2514 2515 2516
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2517
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2518
{
2519
	struct tcp_sock *tp = tcp_sk(sk);
2520

2521 2522 2523
	if (inet_csk(sk)->icsk_ca_ops->cong_control)
		return;

2524
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
2525 2526
	if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
	    (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
2527
		tp->snd_cwnd = tp->snd_ssthresh;
2528
		tp->snd_cwnd_stamp = tcp_jiffies32;
2529
	}
2530
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2531 2532
}

2533
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2534
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2535 2536 2537 2538
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2539
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2540
		tp->undo_marker = 0;
2541
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2542 2543 2544
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2545
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2546

2547 2548 2549 2550 2551
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2552
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2553 2554 2555 2556 2557 2558 2559 2560
		state = TCP_CA_Disorder;

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

2561
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2562
{
2563 2564
	struct tcp_sock *tp = tcp_sk(sk);

2565 2566
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2567
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2568 2569
		tp->retrans_stamp = 0;

2570
	if (flag & FLAG_ECE)
2571
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2572

2573
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2574
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2575 2576 2577
	}
}

J
John Heffner 已提交
2578 2579 2580 2581 2582 2583
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;
2584
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2585 2586
}

2587
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
{
	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;
2598
	tp->snd_cwnd_stamp = tcp_jiffies32;
2599
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2600 2601 2602 2603

	icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
	icsk->icsk_mtup.probe_size = 0;
	tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
2604
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPSUCCESS);
J
John Heffner 已提交
2605 2606
}

2607 2608 2609 2610 2611 2612 2613 2614 2615
/* 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 已提交
2616
	unsigned int mss = tcp_current_mss(sk);
2617 2618 2619 2620 2621
	u32 prior_lost = tp->lost_out;

	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2622
		if (tcp_skb_seglen(skb) > mss &&
2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655
		    !(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 已提交
2656
EXPORT_SYMBOL(tcp_simple_retransmit);
2657

2658
void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2659 2660 2661 2662 2663 2664 2665 2666 2667
{
	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;

2668
	NET_INC_STATS(sock_net(sk), mib_idx);
2669 2670

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

2673
	if (!tcp_in_cwnd_reduction(sk)) {
2674 2675
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2676
		tcp_init_cwnd_reduction(sk);
2677 2678 2679 2680
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2681 2682 2683
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
2684 2685
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
2686 2687
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2688
	bool recovered = !before(tp->snd_una, tp->high_seq);
2689

2690 2691 2692 2693
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
	/* The ACK (s)acks some never-retransmitted data meaning not all
	 * the data packets before the timeout were lost. Therefore we
	 * undo the congestion window and state. This is essentially
	 * the operation in F-RTO (RFC5682 section 3.1 step 3.b). Since
	 * a retransmitted skb is permantly marked, we can apply such an
	 * operation even if F-RTO was not used.
	 */
	if ((flag & FLAG_ORIG_SACK_ACKED) &&
	    tcp_try_undo_loss(sk, tp->undo_marker))
		return;
2704

2705
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2706 2707 2708
		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 已提交
2709 2710
		} else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
			tp->high_seq = tp->snd_nxt;
2711 2712 2713 2714 2715 2716 2717 2718 2719
			/* Step 2.b. Try send new data (but deferred until cwnd
			 * is updated in tcp_ack()). Otherwise fall back to
			 * the conventional recovery.
			 */
			if (tcp_send_head(sk) &&
			    after(tcp_wnd_end(tp), tp->snd_nxt)) {
				*rexmit = REXMIT_NEW;
				return;
			}
Y
Yuchung Cheng 已提交
2720 2721 2722 2723 2724 2725
			tp->frto = 0;
		}
	}

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2726 2727 2728
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2729 2730 2731 2732 2733 2734 2735 2736 2737
	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);
	}
2738
	*rexmit = REXMIT_LOST;
2739 2740
}

Y
Yuchung Cheng 已提交
2741
/* Undo during fast recovery after partial ACK. */
2742
static bool tcp_try_undo_partial(struct sock *sk, const int acked)
Y
Yuchung Cheng 已提交
2743 2744 2745
{
	struct tcp_sock *tp = tcp_sk(sk);

2746
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2747 2748 2749
		/* Plain luck! Hole if filled with delayed
		 * packet, rather than with a retransmit.
		 */
2750 2751 2752 2753 2754 2755 2756
		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.
		 */
2757
		if (tp->retrans_out)
2758 2759
			return true;

Y
Yuchung Cheng 已提交
2760 2761 2762
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2763 2764
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
2765
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2766 2767
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2768
	}
2769
	return false;
Y
Yuchung Cheng 已提交
2770 2771
}

2772
static void tcp_rack_identify_loss(struct sock *sk, int *ack_flag)
2773 2774 2775 2776
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Use RACK to detect loss */
2777
	if (sysctl_tcp_recovery & TCP_RACK_LOSS_DETECTION) {
2778 2779
		u32 prior_retrans = tp->retrans_out;

2780
		tcp_rack_mark_lost(sk);
2781 2782 2783 2784 2785
		if (prior_retrans > tp->retrans_out)
			*ack_flag |= FLAG_LOST_RETRANS;
	}
}

L
Linus Torvalds 已提交
2786 2787 2788 2789 2790
/* 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.
 *
2791 2792 2793
 * Besides that it updates the congestion state when packet loss or ECN
 * is detected. But it does not reduce the cwnd, it is done by the
 * congestion control later.
L
Linus Torvalds 已提交
2794 2795 2796 2797
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2798
static void tcp_fastretrans_alert(struct sock *sk, const int acked,
2799
				  bool is_dupack, int *ack_flag, int *rexmit)
L
Linus Torvalds 已提交
2800
{
2801
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2802
	struct tcp_sock *tp = tcp_sk(sk);
2803
	int fast_rexmit = 0, flag = *ack_flag;
Y
Yuchung Cheng 已提交
2804
	bool do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2805
				    (tcp_fackets_out(tp) > tp->reordering));
L
Linus Torvalds 已提交
2806

2807
	if (WARN_ON(!tp->packets_out && tp->sacked_out))
L
Linus Torvalds 已提交
2808
		tp->sacked_out = 0;
I
Ilpo Järvinen 已提交
2809
	if (WARN_ON(!tp->sacked_out && tp->fackets_out))
L
Linus Torvalds 已提交
2810 2811
		tp->fackets_out = 0;

2812
	/* Now state machine starts.
L
Linus Torvalds 已提交
2813
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2814
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2815 2816 2817
		tp->prior_ssthresh = 0;

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

2821
	/* C. Check consistency of the current state. */
2822
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2823

2824
	/* D. Check state exit conditions. State can be terminated
L
Linus Torvalds 已提交
2825
	 *    when high_seq is ACKed. */
2826
	if (icsk->icsk_ca_state == TCP_CA_Open) {
2827
		WARN_ON(tp->retrans_out != 0);
L
Linus Torvalds 已提交
2828 2829
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
2830
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2831 2832 2833 2834
		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) {
2835
				tcp_end_cwnd_reduction(sk);
2836
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2837 2838 2839 2840
			}
			break;

		case TCP_CA_Recovery:
2841
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2842
				tcp_reset_reno_sack(tp);
2843
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2844
				return;
2845
			tcp_end_cwnd_reduction(sk);
L
Linus Torvalds 已提交
2846 2847 2848 2849
			break;
		}
	}

2850
	/* E. Process state. */
2851
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2852
	case TCP_CA_Recovery:
2853
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
2854
			if (tcp_is_reno(tp) && is_dupack)
2855
				tcp_add_reno_sack(sk);
2856
		} else {
2857
			if (tcp_try_undo_partial(sk, acked))
2858 2859 2860 2861 2862
				return;
			/* Partial ACK arrived. Force fast retransmit. */
			do_lost = tcp_is_reno(tp) ||
				  tcp_fackets_out(tp) > tp->reordering;
		}
2863 2864 2865 2866
		if (tcp_try_undo_dsack(sk)) {
			tcp_try_keep_open(sk);
			return;
		}
2867
		tcp_rack_identify_loss(sk, ack_flag);
L
Linus Torvalds 已提交
2868 2869
		break;
	case TCP_CA_Loss:
2870
		tcp_process_loss(sk, flag, is_dupack, rexmit);
2871
		tcp_rack_identify_loss(sk, ack_flag);
2872 2873
		if (!(icsk->icsk_ca_state == TCP_CA_Open ||
		      (*ack_flag & FLAG_LOST_RETRANS)))
L
Linus Torvalds 已提交
2874
			return;
2875
		/* Change state if cwnd is undone or retransmits are lost */
L
Linus Torvalds 已提交
2876
	default:
2877
		if (tcp_is_reno(tp)) {
2878
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
2879 2880
				tcp_reset_reno_sack(tp);
			if (is_dupack)
2881
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
2882 2883
		}

2884
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2885
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2886

2887
		tcp_rack_identify_loss(sk, ack_flag);
2888
		if (!tcp_time_to_recover(sk, flag)) {
2889
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2890 2891 2892
			return;
		}

J
John Heffner 已提交
2893 2894 2895
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
2896
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
2897 2898 2899 2900 2901 2902 2903
			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 已提交
2904
		/* Otherwise enter Recovery state */
2905
		tcp_enter_recovery(sk, (flag & FLAG_ECE));
2906
		fast_rexmit = 1;
L
Linus Torvalds 已提交
2907 2908
	}

2909
	if (do_lost)
2910
		tcp_update_scoreboard(sk, fast_rexmit);
2911
	*rexmit = REXMIT_LOST;
L
Linus Torvalds 已提交
2912 2913
}

2914 2915
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us)
{
2916 2917 2918
	struct tcp_sock *tp = tcp_sk(sk);
	u32 wlen = sysctl_tcp_min_rtt_wlen * HZ;

2919
	minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32,
2920
			   rtt_us ? : jiffies_to_usecs(1));
2921 2922
}

2923 2924 2925
static bool tcp_ack_update_rtt(struct sock *sk, const int flag,
			       long seq_rtt_us, long sack_rtt_us,
			       long ca_rtt_us, struct rate_sample *rs)
2926
{
2927 2928 2929 2930 2931 2932 2933
	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).
	 */
2934 2935
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2936

L
Linus Torvalds 已提交
2937 2938 2939 2940 2941 2942
	/* 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.
	 */
2943
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2944 2945 2946 2947 2948 2949
	    flag & FLAG_ACKED) {
		u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr;
		u32 delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);

		seq_rtt_us = ca_rtt_us = delta_us;
	}
2950
	rs->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet (or -1) */
2951
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2952
		return false;
L
Linus Torvalds 已提交
2953

2954 2955 2956 2957 2958
	/* 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);
2959
	tcp_rtt_estimator(sk, seq_rtt_us);
2960
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2961

2962 2963
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2964
	return true;
L
Linus Torvalds 已提交
2965 2966
}

2967
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2968
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2969
{
2970
	struct rate_sample rs;
Y
Yuchung Cheng 已提交
2971
	long rtt_us = -1L;
2972

2973 2974
	if (req && !req->num_retrans && tcp_rsk(req)->snt_synack)
		rtt_us = tcp_stamp_us_delta(tcp_clock_us(), tcp_rsk(req)->snt_synack);
Y
Yuchung Cheng 已提交
2975

2976
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
2977 2978
}

Y
Yuchung Cheng 已提交
2979

2980
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2981
{
2982
	const struct inet_connection_sock *icsk = inet_csk(sk);
2983 2984

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2985
	tcp_sk(sk)->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
2986 2987 2988 2989 2990
}

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

2996 2997 2998 2999 3000 3001
	/* 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 已提交
3002
	if (!tp->packets_out) {
3003
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
3004
	} else {
3005 3006
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
Y
Yuchung Cheng 已提交
3007
		if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
N
Nandita Dukkipati 已提交
3008
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
3009
			s64 delta_us = tcp_rto_delta_us(sk);
E
Eric Dumazet 已提交
3010
			/* delta_us may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
3011
			 * when the retrans timer fires and is rescheduled.
3012
			 */
3013
			rto = usecs_to_jiffies(max_t(int, delta_us, 1));
3014 3015 3016
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
3017
	}
3018 3019
}

3020 3021 3022 3023 3024 3025 3026
/* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
static void tcp_set_xmit_timer(struct sock *sk)
{
	if (!tcp_schedule_loss_probe(sk))
		tcp_rearm_rto(sk);
}

3027
/* If we get here, the whole TSO packet has not been acked. */
3028
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
3029 3030
{
	struct tcp_sock *tp = tcp_sk(sk);
3031
	u32 packets_acked;
L
Linus Torvalds 已提交
3032

3033
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3034 3035

	packets_acked = tcp_skb_pcount(skb);
3036
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3037 3038 3039 3040 3041
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3045
	return packets_acked;
L
Linus Torvalds 已提交
3046 3047
}

3048 3049 3050 3051 3052 3053
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 */
3054
	if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3055 3056 3057
		return;

	shinfo = skb_shinfo(skb);
3058
	if (!before(shinfo->tskey, prior_snd_una) &&
3059
	    before(shinfo->tskey, tcp_sk(sk)->snd_una))
3060 3061 3062
		__skb_tstamp_tx(skb, NULL, sk, SCM_TSTAMP_ACK);
}

3063 3064 3065 3066
/* 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 已提交
3067
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
3068
			       u32 prior_snd_una, int *acked,
3069
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3070
{
3071
	const struct inet_connection_sock *icsk = inet_csk(sk);
3072
	u64 first_ackt, last_ackt;
3073 3074 3075
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
	u32 reord = tp->packets_out;
3076
	bool fully_acked = true;
3077
	long sack_rtt_us = -1L;
3078
	long seq_rtt_us = -1L;
3079
	long ca_rtt_us = -1L;
3080
	struct sk_buff *skb;
3081
	u32 pkts_acked = 0;
3082
	u32 last_in_flight = 0;
3083
	bool rtt_update;
3084 3085
	int flag = 0;

3086
	first_ackt = 0;
L
Linus Torvalds 已提交
3087

3088
	while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
3089
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3090
		u8 sacked = scb->sacked;
3091
		u32 acked_pcount;
L
Linus Torvalds 已提交
3092

3093
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3094

3095
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3096
		if (after(scb->end_seq, tp->snd_una)) {
3097 3098 3099 3100
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3101 3102
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3103
				break;
E
Eric Dumazet 已提交
3104
			fully_acked = false;
3105
		} else {
3106 3107
			/* Speedup tcp_unlink_write_queue() and next loop */
			prefetchw(skb->next);
3108
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3109 3110
		}

3111
		if (unlikely(sacked & TCPCB_RETRANS)) {
3112
			if (sacked & TCPCB_SACKED_RETRANS)
3113
				tp->retrans_out -= acked_pcount;
3114
			flag |= FLAG_RETRANS_DATA_ACKED;
3115
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3116
			last_ackt = skb->skb_mstamp;
3117 3118
			WARN_ON_ONCE(last_ackt == 0);
			if (!first_ackt)
3119 3120
				first_ackt = last_ackt;

3121
			last_in_flight = TCP_SKB_CB(skb)->tx.in_flight;
3122 3123 3124
			reord = min(pkts_acked, reord);
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3125
		}
3126

Y
Yuchung Cheng 已提交
3127
		if (sacked & TCPCB_SACKED_ACKED) {
3128
			tp->sacked_out -= acked_pcount;
Y
Yuchung Cheng 已提交
3129 3130 3131
		} else if (tcp_is_sack(tp)) {
			tp->delivered += acked_pcount;
			if (!tcp_skb_spurious_retrans(tp, skb))
3132
				tcp_rack_advance(tp, sacked, scb->end_seq,
3133
						 skb->skb_mstamp);
Y
Yuchung Cheng 已提交
3134
		}
3135
		if (sacked & TCPCB_LOST)
3136
			tp->lost_out -= acked_pcount;
3137

3138 3139
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3140
		tcp_rate_skb_delivered(sk, skb, sack->rate);
3141

3142 3143 3144 3145 3146 3147 3148
		/* 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.
		 */
3149
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3150 3151 3152 3153 3154 3155
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3156 3157 3158
		if (!fully_acked)
			break;

3159
		tcp_unlink_write_queue(skb, sk);
3160
		sk_wmem_free_skb(sk, skb);
3161
		if (unlikely(skb == tp->retransmit_skb_hint))
3162
			tp->retransmit_skb_hint = NULL;
3163
		if (unlikely(skb == tp->lost_skb_hint))
3164
			tp->lost_skb_hint = NULL;
L
Linus Torvalds 已提交
3165 3166
	}

3167 3168 3169
	if (!skb)
		tcp_chrono_stop(sk, TCP_CHRONO_BUSY);

I
Ilpo Järvinen 已提交
3170 3171 3172
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3173 3174 3175
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3176 3177 3178
	if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) {
		seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt);
		ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt);
3179
	}
3180 3181 3182
	if (sack->first_sackt) {
		sack_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, sack->first_sackt);
		ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, sack->last_sackt);
3183
	}
3184
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
3185
					ca_rtt_us, sack->rate);
Y
Yuchung Cheng 已提交
3186

3187
	if (flag & FLAG_ACKED) {
3188
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3189 3190 3191 3192 3193
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3194 3195 3196
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3197 3198
			int delta;

3199
			/* Non-retransmitted hole got filled? That's reordering */
3200
			if (reord < prior_fackets && reord <= tp->fackets_out)
3201
				tcp_update_reordering(sk, tp->fackets_out - reord, 0);
3202

3203 3204 3205
			delta = tcp_is_fack(tp) ? pkts_acked :
						  prior_sacked - tp->sacked_out;
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3206 3207
		}

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

3210
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
3211
		   sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp, skb->skb_mstamp)) {
3212 3213 3214 3215
		/* 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.
		 */
3216
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
L
Linus Torvalds 已提交
3217 3218
	}

3219 3220
	if (icsk->icsk_ca_ops->pkts_acked) {
		struct ack_sample sample = { .pkts_acked = pkts_acked,
3221
					     .rtt_us = sack->rate->rtt_us,
3222
					     .in_flight = last_in_flight };
3223 3224 3225

		icsk->icsk_ca_ops->pkts_acked(sk, &sample);
	}
3226

L
Linus Torvalds 已提交
3227
#if FASTRETRANS_DEBUG > 0
3228 3229 3230
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
3231
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
3232
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3233
		if (tp->lost_out) {
3234 3235
			pr_debug("Leak l=%u %d\n",
				 tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3236 3237 3238
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
3239 3240
			pr_debug("Leak s=%u %d\n",
				 tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3241 3242 3243
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
3244 3245
			pr_debug("Leak r=%u %d\n",
				 tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3246 3247 3248 3249
			tp->retrans_out = 0;
		}
	}
#endif
3250
	*acked = pkts_acked;
3251
	return flag;
L
Linus Torvalds 已提交
3252 3253 3254 3255
}

static void tcp_ack_probe(struct sock *sk)
{
3256 3257
	const struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3258 3259 3260

	/* Was it a usable window open? */

3261
	if (!after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
3262 3263
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3264 3265 3266 3267
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3268
		unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3269

3270
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3271
					  when, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3272 3273 3274
	}
}

3275
static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3276
{
E
Eric Dumazet 已提交
3277 3278
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3279 3280
}

3281
/* Decide wheather to run the increase function of congestion control. */
3282
static inline bool tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3283
{
3284 3285
	/* If reordering is high then always grow cwnd whenever data is
	 * delivered regardless of its ordering. Otherwise stay conservative
3286
	 * and only grow cwnd on in-order delivery (RFC5681). A stretched ACK w/
3287 3288 3289
	 * new SACK or ECE mark may first advance cwnd here and later reduce
	 * cwnd in tcp_fastretrans_alert() based on more states.
	 */
3290
	if (tcp_sk(sk)->reordering > sock_net(sk)->ipv4.sysctl_tcp_reordering)
3291 3292
		return flag & FLAG_FORWARD_PROGRESS;

3293
	return flag & FLAG_DATA_ACKED;
L
Linus Torvalds 已提交
3294 3295
}

Y
Yuchung Cheng 已提交
3296 3297 3298 3299 3300 3301
/* The "ultimate" congestion control function that aims to replace the rigid
 * cwnd increase and decrease control (tcp_cong_avoid,tcp_*cwnd_reduction).
 * It's called toward the end of processing an ACK with precise rate
 * information. All transmission or retransmission are delayed afterwards.
 */
static void tcp_cong_control(struct sock *sk, u32 ack, u32 acked_sacked,
3302
			     int flag, const struct rate_sample *rs)
Y
Yuchung Cheng 已提交
3303
{
3304 3305 3306 3307 3308 3309 3310
	const struct inet_connection_sock *icsk = inet_csk(sk);

	if (icsk->icsk_ca_ops->cong_control) {
		icsk->icsk_ca_ops->cong_control(sk, rs);
		return;
	}

Y
Yuchung Cheng 已提交
3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
	if (tcp_in_cwnd_reduction(sk)) {
		/* Reduce cwnd if state mandates */
		tcp_cwnd_reduction(sk, acked_sacked, flag);
	} else if (tcp_may_raise_cwnd(sk, flag)) {
		/* Advance cwnd if state allows */
		tcp_cong_avoid(sk, ack, acked_sacked);
	}
	tcp_update_pacing_rate(sk);
}

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

3333 3334 3335 3336 3337
/* 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;

3338
	sock_owned_by_me((struct sock *)tp);
3339 3340 3341 3342
	tp->bytes_acked += delta;
	tp->snd_una = ack;
}

3343 3344 3345 3346 3347
/* 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;

3348
	sock_owned_by_me((struct sock *)tp);
3349 3350 3351 3352
	tp->bytes_received += delta;
	tp->rcv_nxt = seq;
}

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

3365
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
3366 3367 3368 3369
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
3370
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3371 3372 3373 3374

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

3375 3376 3377 3378 3379 3380
			/* Note, it is the only place, where
			 * fast path is recovered for sending TCP.
			 */
			tp->pred_flags = 0;
			tcp_fast_path_check(sk);

3381 3382 3383
			if (tcp_send_head(sk))
				tcp_slow_start_after_idle_check(sk);

L
Linus Torvalds 已提交
3384 3385
			if (nwin > tp->max_window) {
				tp->max_window = nwin;
3386
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
3387 3388 3389 3390
			}
		}
	}

3391
	tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3392 3393 3394 3395

	return flag;
}

3396 3397 3398 3399
static bool __tcp_oow_rate_limited(struct net *net, int mib_idx,
				   u32 *last_oow_ack_time)
{
	if (*last_oow_ack_time) {
3400
		s32 elapsed = (s32)(tcp_jiffies32 - *last_oow_ack_time);
3401 3402 3403 3404 3405 3406 3407

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

3408
	*last_oow_ack_time = tcp_jiffies32;
3409 3410 3411 3412

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

3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425
/* 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)
3426
		return false;
3427

3428
	return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
3429 3430
}

3431
/* RFC 5961 7 [ACK Throttling] */
3432
static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
3433 3434 3435 3436
{
	/* unprotected vars, we dont care of overwrites */
	static u32 challenge_timestamp;
	static unsigned int challenge_count;
3437
	struct tcp_sock *tp = tcp_sk(sk);
3438
	u32 count, now;
3439 3440

	/* First check our per-socket dupack rate limit. */
3441 3442 3443
	if (__tcp_oow_rate_limited(sock_net(sk),
				   LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
				   &tp->last_oow_ack_time))
3444
		return;
3445

3446
	/* Then check host-wide RFC 5961 rate limit. */
3447
	now = jiffies / HZ;
3448
	if (now != challenge_timestamp) {
3449 3450
		u32 half = (sysctl_tcp_challenge_ack_limit + 1) >> 1;

3451
		challenge_timestamp = now;
3452 3453
		WRITE_ONCE(challenge_count, half +
			   prandom_u32_max(sysctl_tcp_challenge_ack_limit));
3454
	}
3455 3456 3457
	count = READ_ONCE(challenge_count);
	if (count > 0) {
		WRITE_ONCE(challenge_count, count - 1);
3458
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK);
3459 3460 3461 3462
		tcp_send_ack(sk);
	}
}

3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
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 已提交
3484
/* This routine deals with acks during a TLP episode.
3485 3486
 * We mark the end of a TLP episode on receiving TLP dupack or when
 * ack is after tlp_high_seq.
N
Nandita Dukkipati 已提交
3487 3488 3489 3490 3491 3492
 * 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);

3493
	if (before(ack, tp->tlp_high_seq))
N
Nandita Dukkipati 已提交
3494 3495
		return;

3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506
	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);
3507
		NET_INC_STATS(sock_net(sk),
3508
				LINUX_MIB_TCPLOSSPROBERECOVERY);
3509 3510 3511
	} 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 已提交
3512 3513 3514 3515
		tp->tlp_high_seq = 0;
	}
}

3516 3517 3518 3519 3520 3521 3522 3523
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);
}

3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544
/* Congestion control has updated the cwnd already. So if we're in
 * loss recovery then now we do any new sends (for FRTO) or
 * retransmits (for CA_Loss or CA_recovery) that make sense.
 */
static void tcp_xmit_recovery(struct sock *sk, int rexmit)
{
	struct tcp_sock *tp = tcp_sk(sk);

	if (rexmit == REXMIT_NONE)
		return;

	if (unlikely(rexmit == 2)) {
		__tcp_push_pending_frames(sk, tcp_current_mss(sk),
					  TCP_NAGLE_OFF);
		if (after(tp->snd_nxt, tp->high_seq))
			return;
		tp->frto = 0;
	}
	tcp_xmit_retransmit_queue(sk);
}

L
Linus Torvalds 已提交
3545
/* This routine deals with incoming acks, but not outgoing ones. */
3546
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
L
Linus Torvalds 已提交
3547
{
3548
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3549
	struct tcp_sock *tp = tcp_sk(sk);
3550
	struct tcp_sacktag_state sack_state;
3551
	struct rate_sample rs = { .prior_delivered = 0 };
L
Linus Torvalds 已提交
3552 3553 3554
	u32 prior_snd_una = tp->snd_una;
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
3555
	bool is_dupack = false;
3556
	u32 prior_fackets;
3557
	int prior_packets = tp->packets_out;
3558 3559
	u32 delivered = tp->delivered;
	u32 lost = tp->lost;
3560
	int acked = 0; /* Number of packets newly acked */
3561
	int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
3562

3563
	sack_state.first_sackt = 0;
3564
	sack_state.rate = &rs;
L
Linus Torvalds 已提交
3565

3566 3567 3568
	/* We very likely will need to access write queue head. */
	prefetchw(sk->sk_write_queue.next);

3569
	/* If the ack is older than previous acks
L
Linus Torvalds 已提交
3570 3571
	 * then we can probably ignore it.
	 */
3572 3573 3574
	if (before(ack, prior_snd_una)) {
		/* RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation] */
		if (before(ack, prior_snd_una - tp->max_window)) {
3575 3576
			if (!(flag & FLAG_NO_CHALLENGE_ACK))
				tcp_send_challenge_ack(sk, skb);
3577 3578
			return -1;
		}
L
Linus Torvalds 已提交
3579
		goto old_ack;
3580
	}
L
Linus Torvalds 已提交
3581

3582 3583 3584 3585 3586 3587
	/* 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;

3588
	if (after(ack, prior_snd_una)) {
3589
		flag |= FLAG_SND_UNA_ADVANCED;
3590 3591
		icsk->icsk_retransmits = 0;
	}
3592

3593
	prior_fackets = tp->fackets_out;
3594
	rs.prior_in_flight = tcp_packets_in_flight(tp);
3595

3596 3597 3598 3599 3600 3601
	/* 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);

3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614
	if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
		/* Window is constant, pure forward advance.
		 * No more checks are required.
		 * Note, we use the fact that SND.UNA>=SND.WL2.
		 */
		tcp_update_wl(tp, ack_seq);
		tcp_snd_una_update(tp, ack);
		flag |= FLAG_WIN_UPDATE;

		tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);

		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPACKS);
	} else {
3615
		u32 ack_ev_flags = CA_ACK_SLOWPATH;
L
Linus Torvalds 已提交
3616

3617 3618 3619 3620
		if (ack_seq != TCP_SKB_CB(skb)->end_seq)
			flag |= FLAG_DATA;
		else
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPUREACKS);
L
Linus Torvalds 已提交
3621

3622
		flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
L
Linus Torvalds 已提交
3623

3624 3625 3626
		if (TCP_SKB_CB(skb)->sacked)
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
							&sack_state);
3627

3628 3629 3630 3631 3632 3633 3634
		if (tcp_ecn_rcv_ecn_echo(tp, tcp_hdr(skb))) {
			flag |= FLAG_ECE;
			ack_ev_flags |= CA_ACK_ECE;
		}

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

3636 3637
		tcp_in_ack_event(sk, ack_ev_flags);
	}
L
Linus Torvalds 已提交
3638 3639 3640 3641 3642

	/* We passed data and got it acked, remove any soft error
	 * log. Something worked...
	 */
	sk->sk_err_soft = 0;
3643
	icsk->icsk_probes_out = 0;
3644
	tp->rcv_tstamp = tcp_jiffies32;
L
Linus Torvalds 已提交
3645 3646 3647 3648
	if (!prior_packets)
		goto no_queue;

	/* See if we can take anything off of the retransmit queue. */
3649
	flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una, &acked,
3650
				    &sack_state);
3651

3652 3653 3654 3655 3656 3657
	if (tp->tlp_high_seq)
		tcp_process_tlp_ack(sk, ack, flag);
	/* If needed, reset TLP/RTO timer; RACK may later override this. */
	if (flag & FLAG_SET_XMIT_TIMER)
		tcp_set_xmit_timer(sk);

3658
	if (tcp_ack_is_dubious(sk, flag)) {
3659
		is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
3660
		tcp_fastretrans_alert(sk, acked, is_dupack, &flag, &rexmit);
L
Linus Torvalds 已提交
3661
	}
N
Nandita Dukkipati 已提交
3662

3663 3664
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
		sk_dst_confirm(sk);
N
Nandita Dukkipati 已提交
3665

3666 3667
	delivered = tp->delivered - delivered;	/* freshly ACKed or SACKed */
	lost = tp->lost - lost;			/* freshly marked lost */
3668
	tcp_rate_gen(sk, delivered, lost, sack_state.rate);
3669
	tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
3670
	tcp_xmit_recovery(sk, rexmit);
L
Linus Torvalds 已提交
3671 3672 3673
	return 1;

no_queue:
3674 3675
	/* If data was DSACKed, see if we can undo a cwnd reduction. */
	if (flag & FLAG_DSACKING_ACK)
3676
		tcp_fastretrans_alert(sk, acked, is_dupack, &flag, &rexmit);
L
Linus Torvalds 已提交
3677 3678 3679 3680
	/* 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.
	 */
3681
	if (tcp_send_head(sk))
L
Linus Torvalds 已提交
3682
		tcp_ack_probe(sk);
N
Nandita Dukkipati 已提交
3683 3684 3685

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

3688 3689 3690 3691
invalid_ack:
	SOCK_DEBUG(sk, "Ack %u after %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return -1;

L
Linus Torvalds 已提交
3692
old_ack:
3693 3694 3695
	/* 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.
	 */
3696
	if (TCP_SKB_CB(skb)->sacked) {
Y
Yuchung Cheng 已提交
3697
		flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3698
						&sack_state);
3699
		tcp_fastretrans_alert(sk, acked, is_dupack, &flag, &rexmit);
3700
		tcp_xmit_recovery(sk, rexmit);
3701
	}
L
Linus Torvalds 已提交
3702

3703
	SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
L
Linus Torvalds 已提交
3704 3705 3706
	return 0;
}

3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723
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 已提交
3724 3725 3726 3727
/* 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.
 */
3728 3729
void tcp_parse_options(const struct net *net,
		       const struct sk_buff *skb,
C
Christoph Paasch 已提交
3730
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3731
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3732
{
3733 3734
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3735
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3736

3737
	ptr = (const unsigned char *)(th + 1);
L
Linus Torvalds 已提交
3738 3739
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3740
	while (length > 0) {
3741
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3742 3743 3744
		int opsize;

		switch (opcode) {
3745 3746 3747 3748 3749 3750 3751 3752
		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 已提交
3753
				return;
3754 3755 3756 3757 3758
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
3759
					u16 in_mss = get_unaligned_be16(ptr);
3760 3761 3762 3763 3764
					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 已提交
3765
					}
3766 3767 3768 3769
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
3770
				    !estab && net->ipv4.sysctl_tcp_window_scaling) {
3771 3772
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
3773 3774
					if (snd_wscale > TCP_MAX_WSCALE) {
						net_info_ratelimited("%s: Illegal window scaling value %d > %u received\n",
3775
								     __func__,
3776 3777 3778
								     snd_wscale,
								     TCP_MAX_WSCALE);
						snd_wscale = TCP_MAX_WSCALE;
L
Linus Torvalds 已提交
3779
					}
3780 3781 3782 3783 3784 3785
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
3786
				     (!estab && net->ipv4.sysctl_tcp_timestamps))) {
3787
					opt_rx->saw_tstamp = 1;
3788 3789
					opt_rx->rcv_tsval = get_unaligned_be32(ptr);
					opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
3790 3791 3792 3793
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
E
Eric Dumazet 已提交
3794
				    !estab && net->ipv4.sysctl_tcp_sack) {
3795
					opt_rx->sack_ok = TCP_SACK_SEEN;
3796 3797 3798
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3799

3800 3801 3802 3803 3804 3805 3806
			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;
3807
#ifdef CONFIG_TCP_MD5SIG
3808 3809 3810 3811 3812 3813
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3814
#endif
3815 3816 3817 3818 3819 3820
			case TCPOPT_FASTOPEN:
				tcp_parse_fastopen_option(
					opsize - TCPOLEN_FASTOPEN_BASE,
					ptr, th->syn, foc, false);
				break;

Y
Yuchung Cheng 已提交
3821 3822
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3823
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3824
				 */
3825 3826 3827 3828 3829 3830
				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 已提交
3831 3832 3833
				break;

			}
3834 3835
			ptr += opsize-2;
			length -= opsize;
3836
		}
L
Linus Torvalds 已提交
3837 3838
	}
}
E
Eric Dumazet 已提交
3839
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3840

E
Eric Dumazet 已提交
3841
static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
3842
{
3843
	const __be32 *ptr = (const __be32 *)(th + 1);
3844 3845 3846 3847 3848 3849 3850

	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;
3851 3852 3853 3854
		if (*ptr)
			tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
		else
			tp->rx_opt.rcv_tsecr = 0;
E
Eric Dumazet 已提交
3855
		return true;
3856
	}
E
Eric Dumazet 已提交
3857
	return false;
3858 3859
}

L
Linus Torvalds 已提交
3860 3861 3862
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
3863 3864
static bool tcp_fast_parse_options(const struct net *net,
				   const struct sk_buff *skb,
C
Christoph Paasch 已提交
3865
				   const struct tcphdr *th, struct tcp_sock *tp)
L
Linus Torvalds 已提交
3866
{
3867 3868 3869 3870
	/* 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 已提交
3871
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
3872
		return false;
L
Linus Torvalds 已提交
3873
	} else if (tp->rx_opt.tstamp_ok &&
3874
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3875
		if (tcp_parse_aligned_timestamp(tp, th))
E
Eric Dumazet 已提交
3876
			return true;
L
Linus Torvalds 已提交
3877
	}
3878

3879
	tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
3880
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3881 3882
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3883
	return true;
L
Linus Torvalds 已提交
3884 3885
}

3886 3887 3888 3889
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
3890
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th)
3891
{
3892 3893
	int length = (th->doff << 2) - sizeof(*th);
	const u8 *ptr = (const u8 *)(th + 1);
3894 3895 3896 3897 3898 3899 3900 3901 3902

	/* 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 已提交
3903
		switch (opcode) {
3904 3905 3906 3907 3908 3909 3910 3911 3912 3913
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3914
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3915 3916 3917 3918 3919 3920
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3921
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3922 3923
#endif

L
Linus Torvalds 已提交
3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946
/* 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) ]
 */

3947
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3948
{
3949 3950
	const struct tcp_sock *tp = tcp_sk(sk);
	const struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963
	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. */
3964
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
3965 3966
}

3967
static inline bool tcp_paws_discard(const struct sock *sk,
3968
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
3969
{
3970
	const struct tcp_sock *tp = tcp_sk(sk);
I
Ilpo Järvinen 已提交
3971 3972 3973

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988
}

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

3989
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
3990 3991 3992 3993 3994 3995
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
3996
void tcp_reset(struct sock *sk)
L
Linus Torvalds 已提交
3997 3998 3999
{
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
4000 4001 4002 4003 4004 4005 4006 4007 4008 4009
	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 已提交
4010
	}
T
Tom Marshall 已提交
4011 4012
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
4013

4014 4015
	tcp_done(sk);

L
Linus Torvalds 已提交
4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033
	if (!sock_flag(sk, SOCK_DEAD))
		sk->sk_error_report(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.
 */
4034
void tcp_fin(struct sock *sk)
L
Linus Torvalds 已提交
4035 4036 4037
{
	struct tcp_sock *tp = tcp_sk(sk);

4038
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4039 4040 4041 4042 4043

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

	switch (sk->sk_state) {
4044 4045 4046 4047
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
4048
		inet_csk(sk)->icsk_ack.pingpong = 1;
4049
		break;
L
Linus Torvalds 已提交
4050

4051 4052 4053 4054 4055 4056 4057 4058 4059
	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 已提交
4060

4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
	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 已提交
4078
		pr_err("%s: Impossible, sk->sk_state=%d\n",
4079
		       __func__, sk->sk_state);
4080
		break;
4081
	}
L
Linus Torvalds 已提交
4082 4083 4084 4085

	/* It _is_ possible, that we have something out-of-order _after_ FIN.
	 * Probably, we should reset in this case. For now drop them.
	 */
4086
	skb_rbtree_purge(&tp->out_of_order_queue);
4087
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4088
		tcp_sack_reset(&tp->rx_opt);
4089
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4090 4091 4092 4093 4094 4095 4096

	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)
4097
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
4098
		else
4099
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
4100 4101 4102
	}
}

E
Eric Dumazet 已提交
4103
static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4104
				  u32 end_seq)
L
Linus Torvalds 已提交
4105 4106 4107 4108 4109 4110
{
	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 已提交
4111
		return true;
L
Linus Torvalds 已提交
4112
	}
E
Eric Dumazet 已提交
4113
	return false;
L
Linus Torvalds 已提交
4114 4115
}

4116
static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4117
{
4118 4119
	struct tcp_sock *tp = tcp_sk(sk);

4120
	if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
4121 4122
		int mib_idx;

L
Linus Torvalds 已提交
4123
		if (before(seq, tp->rcv_nxt))
4124
			mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
L
Linus Torvalds 已提交
4125
		else
4126 4127
			mib_idx = LINUX_MIB_TCPDSACKOFOSENT;

4128
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4129 4130 4131 4132 4133 4134 4135

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

4136
static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4137
{
4138 4139
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
4140
	if (!tp->rx_opt.dsack)
4141
		tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4142 4143 4144 4145
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

4146
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
4147 4148 4149 4150 4151
{
	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)) {
4152
		NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4153
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4154

4155
		if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
4156 4157 4158 4159
			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;
4160
			tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
L
Linus Torvalds 已提交
4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173
		}
	}

	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];
4174
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
4175 4176 4177 4178

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
4179
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
4180 4181 4182 4183 4184 4185 4186
		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--;
4187 4188
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204
			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;

4205
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
4206 4207
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
4208
			for (; this_sack > 0; this_sack--, sp--)
4209
				swap(*sp, *(sp - 1));
L
Linus Torvalds 已提交
4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221
			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.
	 */
4222
	if (this_sack >= TCP_NUM_SACKS) {
L
Linus Torvalds 已提交
4223 4224 4225 4226
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
4227
	for (; this_sack > 0; this_sack--, sp--)
4228
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245

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. */
4246
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4247 4248 4249 4250
		tp->rx_opt.num_sacks = 0;
		return;
	}

4251
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
4252 4253 4254 4255 4256
		/* 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! */
4257
			WARN_ON(before(tp->rcv_nxt, sp->end_seq));
L
Linus Torvalds 已提交
4258 4259

			/* Zap this SACK, by moving forward any other SACKS. */
W
Weilong Chen 已提交
4260
			for (i = this_sack+1; i < num_sacks; i++)
L
Linus Torvalds 已提交
4261 4262 4263 4264 4265 4266 4267
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4268
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4269 4270
}

4271 4272 4273 4274 4275
enum tcp_queue {
	OOO_QUEUE,
	RCV_QUEUE,
};

4276 4277 4278
/**
 * tcp_try_coalesce - try to merge skb to prior one
 * @sk: socket
4279
 * @dest: destination queue
4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290
 * @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,
4291
			     enum tcp_queue dest,
4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308
			     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);
4309
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4310 4311 4312
	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;
4313 4314 4315 4316 4317 4318 4319 4320 4321

	if (TCP_SKB_CB(from)->has_rxtstamp) {
		TCP_SKB_CB(to)->has_rxtstamp = true;
		if (dest == OOO_QUEUE)
			TCP_SKB_CB(to)->swtstamp = TCP_SKB_CB(from)->swtstamp;
		else
			to->tstamp = from->tstamp;
	}

4322 4323 4324
	return true;
}

4325 4326 4327 4328 4329 4330
static void tcp_drop(struct sock *sk, struct sk_buff *skb)
{
	sk_drops_add(sk, skb);
	__kfree_skb(skb);
}

L
Linus Torvalds 已提交
4331 4332 4333 4334 4335 4336 4337
/* 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;
4338
	bool fin, fragstolen, eaten;
4339
	struct sk_buff *skb, *tail;
4340
	struct rb_node *p;
L
Linus Torvalds 已提交
4341

4342 4343 4344
	p = rb_first(&tp->out_of_order_queue);
	while (p) {
		skb = rb_entry(p, struct sk_buff, rbnode);
L
Linus Torvalds 已提交
4345 4346 4347 4348 4349 4350 4351
		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;
4352
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4353
		}
4354 4355
		p = rb_next(p);
		rb_erase(&skb->rbnode, &tp->out_of_order_queue);
4356 4357 4358
		/* Replace tstamp which was stomped by rbnode */
		if (TCP_SKB_CB(skb)->has_rxtstamp)
			skb->tstamp = TCP_SKB_CB(skb)->swtstamp;
L
Linus Torvalds 已提交
4359

4360
		if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
4361
			SOCK_DEBUG(sk, "ofo packet was already received\n");
4362
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4363 4364 4365 4366 4367 4368
			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);

4369
		tail = skb_peek_tail(&sk->sk_receive_queue);
4370 4371
		eaten = tail && tcp_try_coalesce(sk, RCV_QUEUE,
						 tail, skb, &fragstolen);
4372
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4373
		fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4374 4375
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4376
		else
4377
			kfree_skb_partial(skb, fragstolen);
4378 4379 4380 4381 4382 4383 4384 4385

		if (unlikely(fin)) {
			tcp_fin(sk);
			/* tcp_fin() purges tp->out_of_order_queue,
			 * so we must end this loop right now.
			 */
			break;
		}
L
Linus Torvalds 已提交
4386 4387 4388
	}
}

E
Eric Dumazet 已提交
4389
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4390 4391
static int tcp_prune_queue(struct sock *sk);

4392 4393
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
				 unsigned int size)
4394 4395
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4396
	    !sk_rmem_schedule(sk, skb, size)) {
4397 4398 4399 4400

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

4401
		while (!sk_rmem_schedule(sk, skb, size)) {
4402 4403
			if (!tcp_prune_ofo_queue(sk))
				return -1;
4404 4405 4406 4407 4408
		}
	}
	return 0;
}

E
Eric Dumazet 已提交
4409 4410 4411
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
4412
	struct rb_node **p, *q, *parent;
E
Eric Dumazet 已提交
4413 4414
	struct sk_buff *skb1;
	u32 seq, end_seq;
4415
	bool fragstolen;
E
Eric Dumazet 已提交
4416

4417
	tcp_ecn_check_ce(tp, skb);
E
Eric Dumazet 已提交
4418

4419
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4420
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4421
		tcp_drop(sk, skb);
E
Eric Dumazet 已提交
4422 4423 4424
		return;
	}

4425 4426 4427 4428
	/* Stash tstamp to avoid being stomped on by rbnode */
	if (TCP_SKB_CB(skb)->has_rxtstamp)
		TCP_SKB_CB(skb)->swtstamp = skb->tstamp;

4429 4430
	/* Disable header prediction. */
	tp->pred_flags = 0;
E
Eric Dumazet 已提交
4431 4432
	inet_csk_schedule_ack(sk);

4433
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
4434 4435
	seq = TCP_SKB_CB(skb)->seq;
	end_seq = TCP_SKB_CB(skb)->end_seq;
E
Eric Dumazet 已提交
4436
	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
4437
		   tp->rcv_nxt, seq, end_seq);
E
Eric Dumazet 已提交
4438

4439 4440
	p = &tp->out_of_order_queue.rb_node;
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
E
Eric Dumazet 已提交
4441 4442 4443
		/* Initial out of order segment, build 1 SACK. */
		if (tcp_is_sack(tp)) {
			tp->rx_opt.num_sacks = 1;
4444 4445
			tp->selective_acks[0].start_seq = seq;
			tp->selective_acks[0].end_seq = end_seq;
E
Eric Dumazet 已提交
4446
		}
4447 4448 4449
		rb_link_node(&skb->rbnode, NULL, p);
		rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4450 4451 4452
		goto end;
	}

4453 4454 4455
	/* In the typical case, we are adding an skb to the end of the list.
	 * Use of ooo_last_skb avoids the O(Log(N)) rbtree lookup.
	 */
4456 4457
	if (tcp_try_coalesce(sk, OOO_QUEUE, tp->ooo_last_skb,
			     skb, &fragstolen)) {
4458 4459 4460 4461 4462 4463
coalesce_done:
		tcp_grow_window(sk, skb);
		kfree_skb_partial(skb, fragstolen);
		skb = NULL;
		goto add_sack;
	}
4464 4465 4466 4467 4468 4469
	/* Can avoid an rbtree lookup if we are adding skb after ooo_last_skb */
	if (!before(seq, TCP_SKB_CB(tp->ooo_last_skb)->end_seq)) {
		parent = &tp->ooo_last_skb->rbnode;
		p = &parent->rb_right;
		goto insert;
	}
4470 4471 4472 4473 4474 4475 4476 4477 4478

	/* Find place to insert this segment. Handle overlaps on the way. */
	parent = NULL;
	while (*p) {
		parent = *p;
		skb1 = rb_entry(parent, struct sk_buff, rbnode);
		if (before(seq, TCP_SKB_CB(skb1)->seq)) {
			p = &parent->rb_left;
			continue;
E
Eric Dumazet 已提交
4479
		}
4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504
		if (before(seq, TCP_SKB_CB(skb1)->end_seq)) {
			if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
				/* All the bits are present. Drop. */
				NET_INC_STATS(sock_net(sk),
					      LINUX_MIB_TCPOFOMERGE);
				__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 {
				/* skb's seq == skb1's seq and skb covers skb1.
				 * Replace skb1 with skb.
				 */
				rb_replace_node(&skb1->rbnode, &skb->rbnode,
						&tp->out_of_order_queue);
				tcp_dsack_extend(sk,
						 TCP_SKB_CB(skb1)->seq,
						 TCP_SKB_CB(skb1)->end_seq);
				NET_INC_STATS(sock_net(sk),
					      LINUX_MIB_TCPOFOMERGE);
				__kfree_skb(skb1);
4505
				goto merge_right;
4506
			}
4507 4508
		} else if (tcp_try_coalesce(sk, OOO_QUEUE, skb1,
					    skb, &fragstolen)) {
4509
			goto coalesce_done;
E
Eric Dumazet 已提交
4510
		}
4511
		p = &parent->rb_right;
E
Eric Dumazet 已提交
4512
	}
4513
insert:
4514 4515 4516
	/* Insert segment into RB tree. */
	rb_link_node(&skb->rbnode, parent, p);
	rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4517

4518
merge_right:
4519 4520 4521
	/* Remove other segments covered by skb. */
	while ((q = rb_next(&skb->rbnode)) != NULL) {
		skb1 = rb_entry(q, struct sk_buff, rbnode);
E
Eric Dumazet 已提交
4522 4523 4524 4525 4526 4527 4528 4529

		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;
		}
4530
		rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4531 4532
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
4533
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
4534
		tcp_drop(sk, skb1);
E
Eric Dumazet 已提交
4535
	}
4536 4537 4538
	/* If there is no skb after us, we are the last_skb ! */
	if (!q)
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4539 4540 4541 4542 4543

add_sack:
	if (tcp_is_sack(tp))
		tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
4544 4545
	if (skb) {
		tcp_grow_window(sk, skb);
4546
		skb_condense(skb);
E
Eric Dumazet 已提交
4547
		skb_set_owner_r(skb, sk);
4548
	}
E
Eric Dumazet 已提交
4549 4550
}

4551
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
4552 4553 4554 4555 4556 4557 4558
		  bool *fragstolen)
{
	int eaten;
	struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);

	__skb_pull(skb, hdrlen);
	eaten = (tail &&
4559 4560
		 tcp_try_coalesce(sk, RCV_QUEUE, tail,
				  skb, fragstolen)) ? 1 : 0;
4561
	tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
4562 4563 4564 4565 4566 4567
	if (!eaten) {
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		skb_set_owner_r(skb, sk);
	}
	return eaten;
}
E
Eric Dumazet 已提交
4568

4569 4570
int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
{
4571
	struct sk_buff *skb;
4572 4573
	int err = -ENOMEM;
	int data_len = 0;
4574 4575
	bool fragstolen;

4576 4577 4578
	if (size == 0)
		return 0;

4579 4580 4581 4582 4583 4584 4585 4586 4587
	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);
4588 4589 4590
	if (!skb)
		goto err;

4591 4592 4593 4594
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4595
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
4596 4597
		goto err_free;

4598 4599
	err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
	if (err)
4600 4601 4602 4603 4604 4605
		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;

4606
	if (tcp_queue_rcv(sk, skb, 0, &fragstolen)) {
4607 4608 4609 4610 4611 4612 4613 4614
		WARN_ON_ONCE(fragstolen); /* should not happen */
		__kfree_skb(skb);
	}
	return size;

err_free:
	kfree_skb(skb);
err:
4615 4616
	return err;

4617 4618
}

L
Linus Torvalds 已提交
4619 4620 4621
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
E
Eric Dumazet 已提交
4622 4623
	bool fragstolen;
	int eaten;
L
Linus Torvalds 已提交
4624

4625 4626 4627 4628
	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
		__kfree_skb(skb);
		return;
	}
E
Eric Dumazet 已提交
4629
	skb_dst_drop(skb);
4630
	__skb_pull(skb, tcp_hdr(skb)->doff * 4);
L
Linus Torvalds 已提交
4631

4632
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4633

4634
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645

	/*  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. */
queue_and_out:
E
Eric Dumazet 已提交
4646 4647 4648 4649 4650
		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;

4651
		eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
4652
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
S
Stephen Hemminger 已提交
4653
		if (skb->len)
4654
			tcp_event_data_recv(sk, skb);
4655
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4656
			tcp_fin(sk);
L
Linus Torvalds 已提交
4657

4658
		if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4659 4660 4661 4662 4663
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4664
			if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4665
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4666 4667 4668 4669 4670
		}

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

4671 4672
		tcp_fast_path_check(sk);

4673 4674
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4675
		if (!sock_flag(sk, SOCK_DEAD))
4676
			sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
4677 4678 4679 4680 4681
		return;
	}

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

out_of_window:
4686 4687
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4688
drop:
4689
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4690 4691 4692 4693 4694 4695 4696
		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;

4697
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4698 4699 4700 4701 4702 4703 4704

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

4705
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4706

L
Linus Torvalds 已提交
4707 4708 4709 4710 4711 4712 4713 4714
		/* 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 已提交
4715
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4716 4717
}

4718 4719 4720 4721 4722 4723 4724 4725
static struct sk_buff *tcp_skb_next(struct sk_buff *skb, struct sk_buff_head *list)
{
	if (list)
		return !skb_queue_is_last(list, skb) ? skb->next : NULL;

	return rb_entry_safe(rb_next(&skb->rbnode), struct sk_buff, rbnode);
}

4726
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
4727 4728
					struct sk_buff_head *list,
					struct rb_root *root)
4729
{
4730
	struct sk_buff *next = tcp_skb_next(skb, list);
4731

4732 4733 4734 4735
	if (list)
		__skb_unlink(skb, list);
	else
		rb_erase(&skb->rbnode, root);
4736 4737

	__kfree_skb(skb);
4738
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
4739 4740 4741 4742

	return next;
}

4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761
/* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
static void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sk_buff *skb1;

	while (*p) {
		parent = *p;
		skb1 = rb_entry(parent, struct sk_buff, rbnode);
		if (before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb1)->seq))
			p = &parent->rb_left;
		else
			p = &parent->rb_right;
	}
	rb_link_node(&skb->rbnode, parent, p);
	rb_insert_color(&skb->rbnode, root);
}

L
Linus Torvalds 已提交
4762 4763
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4764
 *
4765
 * If tail is NULL, this means until the end of the queue.
4766
 *
L
Linus Torvalds 已提交
4767 4768 4769 4770
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
4771 4772
tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
	     struct sk_buff *head, struct sk_buff *tail, u32 start, u32 end)
L
Linus Torvalds 已提交
4773
{
4774 4775
	struct sk_buff *skb = head, *n;
	struct sk_buff_head tmp;
4776
	bool end_of_skbs;
L
Linus Torvalds 已提交
4777

S
Stephen Hemminger 已提交
4778
	/* First, check that queue is collapsible and find
4779 4780
	 * the point where collapsing can be useful.
	 */
4781
restart:
4782 4783 4784
	for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
		n = tcp_skb_next(skb, list);

L
Linus Torvalds 已提交
4785 4786
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4787
			skb = tcp_collapse_one(sk, skb, list, root);
4788 4789 4790
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4791 4792 4793 4794 4795 4796 4797
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4798
		if (!(TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)) &&
L
Linus Torvalds 已提交
4799
		    (tcp_win_from_space(skb->truesize) > skb->len ||
4800 4801
		     before(TCP_SKB_CB(skb)->seq, start))) {
			end_of_skbs = false;
L
Linus Torvalds 已提交
4802
			break;
4803 4804
		}

4805 4806 4807 4808
		if (n && n != tail &&
		    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
			end_of_skbs = false;
			break;
4809
		}
L
Linus Torvalds 已提交
4810 4811 4812 4813

		/* Decided to skip this, advance start seq. */
		start = TCP_SKB_CB(skb)->end_seq;
	}
4814 4815
	if (end_of_skbs ||
	    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
L
Linus Torvalds 已提交
4816 4817
		return;

4818 4819
	__skb_queue_head_init(&tmp);

L
Linus Torvalds 已提交
4820
	while (before(start, end)) {
4821
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4822 4823
		struct sk_buff *nskb;

4824
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4825
		if (!nskb)
4826
			break;
4827

L
Linus Torvalds 已提交
4828 4829
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4830 4831 4832 4833
		if (list)
			__skb_queue_before(list, skb, nskb);
		else
			__skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
4834
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4835 4836 4837 4838 4839 4840

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

4841
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4842 4843 4844 4845 4846 4847 4848 4849 4850
			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)) {
4851
				skb = tcp_collapse_one(sk, skb, list, root);
4852 4853
				if (!skb ||
				    skb == tail ||
4854
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
4855
					goto end;
L
Linus Torvalds 已提交
4856 4857 4858
			}
		}
	}
4859 4860 4861
end:
	skb_queue_walk_safe(&tmp, skb, n)
		tcp_rbtree_insert(root, skb);
L
Linus Torvalds 已提交
4862 4863 4864 4865 4866 4867 4868 4869
}

/* 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);
4870 4871
	struct sk_buff *skb, *head;
	struct rb_node *p;
L
Linus Torvalds 已提交
4872 4873
	u32 start, end;

4874 4875 4876 4877 4878 4879 4880 4881 4882 4883
	p = rb_first(&tp->out_of_order_queue);
	skb = rb_entry_safe(p, struct sk_buff, rbnode);
new_range:
	if (!skb) {
		p = rb_last(&tp->out_of_order_queue);
		/* Note: This is possible p is NULL here. We do not
		 * use rb_entry_safe(), as ooo_last_skb is valid only
		 * if rbtree is not empty.
		 */
		tp->ooo_last_skb = rb_entry(p, struct sk_buff, rbnode);
L
Linus Torvalds 已提交
4884
		return;
4885
	}
L
Linus Torvalds 已提交
4886 4887
	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
4888

4889 4890
	for (head = skb;;) {
		skb = tcp_skb_next(skb, NULL);
L
Linus Torvalds 已提交
4891

4892 4893 4894
		/* Range is terminated when we see a gap or when
		 * we are at the queue end.
		 */
4895
		if (!skb ||
L
Linus Torvalds 已提交
4896 4897
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
4898
			tcp_collapse(sk, NULL, &tp->out_of_order_queue,
D
David S. Miller 已提交
4899
				     head, skb, start, end);
4900 4901 4902 4903
			goto new_range;
		}

		if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
L
Linus Torvalds 已提交
4904
			start = TCP_SKB_CB(skb)->seq;
4905
		if (after(TCP_SKB_CB(skb)->end_seq, end))
L
Linus Torvalds 已提交
4906 4907 4908 4909
			end = TCP_SKB_CB(skb)->end_seq;
	}
}

4910
/*
4911 4912 4913 4914 4915 4916 4917 4918
 * Clean the out-of-order queue to make room.
 * We drop high sequences packets to :
 * 1) Let a chance for holes to be filled.
 * 2) not add too big latencies if thousands of packets sit there.
 *    (But if application shrinks SO_RCVBUF, we could still end up
 *     freeing whole queue here)
 *
 * Return true if queue has shrunk.
4919
 */
E
Eric Dumazet 已提交
4920
static bool tcp_prune_ofo_queue(struct sock *sk)
4921 4922
{
	struct tcp_sock *tp = tcp_sk(sk);
4923
	struct rb_node *node, *prev;
4924

4925
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4926
		return false;
4927

4928
	NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
4929 4930 4931 4932 4933
	node = &tp->ooo_last_skb->rbnode;
	do {
		prev = rb_prev(node);
		rb_erase(node, &tp->out_of_order_queue);
		tcp_drop(sk, rb_entry(node, struct sk_buff, rbnode));
4934
		sk_mem_reclaim(sk);
4935 4936 4937
		if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
		    !tcp_under_memory_pressure(sk))
			break;
4938 4939 4940
		node = prev;
	} while (node);
	tp->ooo_last_skb = rb_entry(prev, struct sk_buff, rbnode);
4941 4942 4943 4944 4945 4946 4947 4948 4949

	/* 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);
	return true;
4950 4951
}

L
Linus Torvalds 已提交
4952 4953 4954 4955 4956 4957 4958 4959 4960
/* 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)
{
4961
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4962 4963 4964

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

4965
	NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4966 4967

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4968
		tcp_clamp_window(sk);
4969
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
4970 4971 4972
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4973
	if (!skb_queue_empty(&sk->sk_receive_queue))
4974
		tcp_collapse(sk, &sk->sk_receive_queue, NULL,
4975 4976 4977
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4978
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4979 4980 4981 4982 4983 4984 4985

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

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

4986
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4987 4988 4989 4990 4991 4992 4993 4994

	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.
	 */
4995
	NET_INC_STATS(sock_net(sk), LINUX_MIB_RCVPRUNED);
L
Linus Torvalds 已提交
4996 4997

	/* Massive buffer overcommit. */
4998
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
4999 5000 5001
	return -1;
}

E
Eric Dumazet 已提交
5002
static bool tcp_should_expand_sndbuf(const struct sock *sk)
5003
{
5004
	const struct tcp_sock *tp = tcp_sk(sk);
5005

5006 5007 5008 5009
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
5010
		return false;
5011 5012

	/* If we are under global TCP memory pressure, do not expand.  */
5013
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
5014
		return false;
5015 5016

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

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

E
Eric Dumazet 已提交
5024
	return true;
5025
}
L
Linus Torvalds 已提交
5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036

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

5037
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
5038
		tcp_sndbuf_expand(sk);
5039
		tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
5040 5041 5042 5043 5044
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
5045
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
5046 5047 5048
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
5049
		/* pairs with tcp_poll() */
5050
		smp_mb();
L
Linus Torvalds 已提交
5051
		if (sk->sk_socket &&
5052
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
L
Linus Torvalds 已提交
5053
			tcp_new_space(sk);
5054 5055 5056
			if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
				tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
		}
L
Linus Torvalds 已提交
5057 5058 5059
	}
}

5060
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5061
{
5062
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073
	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... */
5074
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
5075 5076 5077
	     /* ... and right edge of window advances far enough.
	      * (tcp_recvmsg() will send ACK otherwise). Or...
	      */
5078
	     __tcp_select_window(sk) >= tp->rcv_wnd) ||
L
Linus Torvalds 已提交
5079
	    /* We ACK each frame or... */
5080
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
5081
	    /* We have out of order data. */
5082
	    (ofo_possible && !RB_EMPTY_ROOT(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
5083 5084 5085 5086 5087 5088 5089 5090
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
5091
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5092
{
5093
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
5094 5095 5096 5097 5098 5099 5100 5101
		/* 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 已提交
5102
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
5103 5104 5105 5106 5107 5108
 *	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).
 */
5109

5110
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146
{
	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 已提交
5147
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158
	 *
	 * 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 &&
5159
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5160 5161 5162
		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 已提交
5163
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5164 5165 5166 5167
			__kfree_skb(skb);
		}
	}

5168 5169
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
5170 5171 5172

	/* Disable header prediction. */
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5173 5174 5175
}

/* This is the 'fast' part of urgent handling. */
5176
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5177 5178 5179 5180 5181
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5182
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5183 5184 5185 5186 5187 5188

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

5189
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5190 5191 5192 5193 5194 5195
		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))
5196
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5197 5198 5199 5200
		}
	}
}

5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217
/* Accept RST for rcv_nxt - 1 after a FIN.
 * When tcp connections are abruptly terminated from Mac OSX (via ^C), a
 * FIN is sent followed by a RST packet. The RST is sent with the same
 * sequence number as the FIN, and thus according to RFC 5961 a challenge
 * ACK should be sent. However, Mac OSX rate limits replies to challenge
 * ACKs on the closed socket. In addition middleboxes can drop either the
 * challenge ACK or a subsequent RST.
 */
static bool tcp_reset_check(const struct sock *sk, const struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);

	return unlikely(TCP_SKB_CB(skb)->seq == (tp->rcv_nxt - 1) &&
			(1 << sk->sk_state) & (TCPF_CLOSE_WAIT | TCPF_LAST_ACK |
					       TCPF_CLOSING));
}

5218 5219 5220
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
E
Eric Dumazet 已提交
5221 5222
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
				  const struct tcphdr *th, int syn_inerr)
5223 5224
{
	struct tcp_sock *tp = tcp_sk(sk);
5225
	bool rst_seq_match = false;
5226 5227

	/* RFC1323: H1. Apply PAWS check first. */
5228 5229
	if (tcp_fast_parse_options(sock_net(sk), skb, th, tp) &&
	    tp->rx_opt.saw_tstamp &&
5230 5231
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
5232
			NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5233 5234 5235 5236
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDPAWS,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249
			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)".
		 */
5250 5251 5252
		if (!th->rst) {
			if (th->syn)
				goto syn_challenge;
5253 5254 5255 5256
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDSEQ,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5257 5258
		} else if (tcp_reset_check(sk, skb)) {
			tcp_reset(sk);
5259
		}
5260 5261 5262 5263 5264
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
5265 5266 5267 5268
		/* RFC 5961 3.2 (extend to match against (RCV.NXT - 1) after a
		 * FIN and SACK too if available):
		 * If seq num matches RCV.NXT or (RCV.NXT - 1) after a FIN, or
		 * the right-most SACK block,
5269
		 * then
E
Eric Dumazet 已提交
5270 5271 5272 5273
		 *     RESET the connection
		 * else
		 *     Send a challenge ACK
		 */
5274 5275
		if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt ||
		    tcp_reset_check(sk, skb)) {
5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293
			rst_seq_match = true;
		} else if (tcp_is_sack(tp) && tp->rx_opt.num_sacks > 0) {
			struct tcp_sack_block *sp = &tp->selective_acks[0];
			int max_sack = sp[0].end_seq;
			int this_sack;

			for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;
			     ++this_sack) {
				max_sack = after(sp[this_sack].end_seq,
						 max_sack) ?
					sp[this_sack].end_seq : max_sack;
			}

			if (TCP_SKB_CB(skb)->seq == max_sack)
				rst_seq_match = true;
		}

		if (rst_seq_match)
E
Eric Dumazet 已提交
5294
			tcp_reset(sk);
5295 5296 5297 5298 5299 5300 5301
		else {
			/* Disable TFO if RST is out-of-order
			 * and no data has been received
			 * for current active TFO socket
			 */
			if (tp->syn_fastopen && !tp->data_segs_in &&
			    sk->sk_state == TCP_ESTABLISHED)
5302
				tcp_fastopen_active_disable(sk);
5303
			tcp_send_challenge_ack(sk, skb);
5304
		}
5305 5306 5307 5308 5309
		goto discard;
	}

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

E
Eric Dumazet 已提交
5310
	/* step 4: Check for a SYN
5311
	 * RFC 5961 4.2 : Send a challenge ack
E
Eric Dumazet 已提交
5312 5313
	 */
	if (th->syn) {
5314
syn_challenge:
5315
		if (syn_inerr)
5316 5317
			TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
5318
		tcp_send_challenge_ack(sk, skb);
E
Eric Dumazet 已提交
5319
		goto discard;
5320 5321
	}

E
Eric Dumazet 已提交
5322
	return true;
5323 5324

discard:
5325
	tcp_drop(sk, skb);
E
Eric Dumazet 已提交
5326
	return false;
5327 5328
}

L
Linus Torvalds 已提交
5329
/*
5330
 *	TCP receive function for the ESTABLISHED state.
5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350
 *
 *	It is split into a fast path and a slow path. The fast path is
 * 	disabled when:
 *	- A zero window was announced from us - zero window probing
 *        is only handled properly in the slow path.
 *	- Out of order segments arrived.
 *	- Urgent data is expected.
 *	- There is no buffer space left
 *	- Unexpected TCP flags/window values/header lengths are received
 *	  (detected by checking the TCP header against pred_flags)
 *	- 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.
 *
 *	When these conditions are not satisfied it drops into a standard
 *	receive procedure patterned after RFC793 to handle all cases.
 *	The first three cases are guaranteed by proper pred_flags setting,
 *	the rest is checked inline. Fast processing is turned on in
 *	tcp_data_queue when everything is OK.
L
Linus Torvalds 已提交
5351
 */
5352
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
5353
			 const struct tcphdr *th)
L
Linus Torvalds 已提交
5354
{
5355
	unsigned int len = skb->len;
L
Linus Torvalds 已提交
5356 5357
	struct tcp_sock *tp = tcp_sk(sk);

5358
	tcp_mstamp_refresh(tp);
5359
	if (unlikely(!sk->sk_rx_dst))
E
Eric Dumazet 已提交
5360
		inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374
	/*
	 *	Header prediction.
	 *	The code loosely follows the one in the famous
	 *	"30 instruction TCP receive" Van Jacobson mail.
	 *
	 *	Van's trick is to deposit buffers into socket queue
	 *	on a device interrupt, to call tcp_recv function
	 *	on the receive process context and checksum and copy
	 *	the buffer to user space. smart...
	 *
	 *	Our current scheme is not silly either but we take the
	 *	extra cost of the net_bh soft interrupt processing...
	 *	We do checksum and copy also but from device to kernel.
	 */
L
Linus Torvalds 已提交
5375 5376 5377

	tp->rx_opt.saw_tstamp = 0;

5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 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 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483
	/*	pred_flags is 0xS?10 << 16 + snd_wnd
	 *	if header_prediction is to be made
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
	 *  turn it off	(when there are holes in the receive
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
	    !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
		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! */
			if (!tcp_parse_aligned_timestamp(tp, th))
				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);
				__kfree_skb(skb);
				tcp_data_snd_check(sk);
				return;
			} else { /* Header too small */
				TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
				goto discard;
			}
		} else {
			int eaten = 0;
			bool fragstolen = false;

			if (tcp_checksum_complete(skb))
				goto csum_error;

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

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

			tcp_rcv_rtt_measure_ts(sk, skb);

			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);

			/* Bulk data transfer: receiver */
			eaten = tcp_queue_rcv(sk, skb, tcp_header_len,
					      &fragstolen);

			tcp_event_data_recv(sk, skb);

			if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {
				/* Well, only one small jumplet in fast path... */
				tcp_ack(sk, skb, FLAG_DATA);
				tcp_data_snd_check(sk);
				if (!inet_csk_ack_scheduled(sk))
					goto no_ack;
			}

			__tcp_ack_snd_check(sk, 0);
no_ack:
			if (eaten)
				kfree_skb_partial(skb, fragstolen);
			sk->sk_data_ready(sk);
			return;
		}
	}

slow_path:
5484
	if (len < (th->doff << 2) || tcp_checksum_complete(skb))
L
Linus Torvalds 已提交
5485 5486
		goto csum_error;

5487
	if (!th->ack && !th->rst && !th->syn)
5488 5489
		goto discard;

5490 5491 5492 5493
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5494
	if (!tcp_validate_incoming(sk, skb, th, 1))
5495
		return;
L
Linus Torvalds 已提交
5496

5497 5498
step5:
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5499
		goto discard;
L
Linus Torvalds 已提交
5500

5501
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5502 5503 5504 5505 5506 5507 5508

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

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

5509
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5510
	tcp_ack_snd_check(sk);
5511
	return;
L
Linus Torvalds 已提交
5512 5513

csum_error:
5514 5515
	TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
	TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5516 5517

discard:
5518
	tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5519
}
E
Eric Dumazet 已提交
5520
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5521

P
Pavel Emelyanov 已提交
5522 5523 5524 5525 5526 5527
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);
5528
	icsk->icsk_ack.lrcvtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5529

5530
	if (skb) {
E
Eric Dumazet 已提交
5531
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5532
		security_inet_conn_established(sk, skb);
D
David S. Miller 已提交
5533
	}
P
Pavel Emelyanov 已提交
5534 5535 5536 5537 5538

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

	tcp_init_metrics(sk);
5539
	tcp_call_bpf(sk, BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB);
P
Pavel Emelyanov 已提交
5540 5541 5542 5543 5544
	tcp_init_congestion_control(sk);

	/* Prevent spurious tcp_cwnd_restart() on first data
	 * packet.
	 */
5545
	tp->lsndtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5546 5547 5548 5549 5550

	tcp_init_buffer_space(sk);

	if (sock_flag(sk, SOCK_KEEPOPEN))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
5551 5552 5553 5554 5555

	if (!tp->rx_opt.snd_wscale)
		__tcp_fast_path_on(tp, tp->snd_wnd);
	else
		tp->pred_flags = 0;
P
Pavel Emelyanov 已提交
5556 5557
}

5558 5559 5560 5561
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);
5562
	struct sk_buff *data = tp->syn_data ? tcp_write_queue_head(sk) : NULL;
5563 5564
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5565 5566 5567 5568 5569 5570 5571

	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;
5572
		tcp_parse_options(sock_net(sk), synack, &opt, 0, NULL);
5573 5574 5575
		mss = opt.mss_clamp;
	}

5576 5577
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5578
		cookie->len = -1;
5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592
	} 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;
	}
5593

5594
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5595 5596

	if (data) { /* Retransmit unacked data in SYN */
5597 5598
		tcp_for_write_queue_from(data, sk) {
			if (data == tcp_send_head(sk) ||
5599
			    __tcp_retransmit_skb(sk, data, 1))
5600 5601
				break;
		}
5602
		tcp_rearm_rto(sk);
5603
		NET_INC_STATS(sock_net(sk),
5604
				LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5605 5606
		return true;
	}
Y
Yuchung Cheng 已提交
5607
	tp->syn_data_acked = tp->syn_data;
5608
	if (tp->syn_data_acked)
5609
		NET_INC_STATS(sock_net(sk),
5610
				LINUX_MIB_TCPFASTOPENACTIVE);
5611 5612 5613

	tcp_fastopen_add_skb(sk, synack);

5614 5615 5616
	return false;
}

L
Linus Torvalds 已提交
5617
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5618
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5619
{
5620
	struct inet_connection_sock *icsk = inet_csk(sk);
5621
	struct tcp_sock *tp = tcp_sk(sk);
5622
	struct tcp_fastopen_cookie foc = { .len = -1 };
5623
	int saved_clamp = tp->rx_opt.mss_clamp;
5624
	bool fastopen_fail;
L
Linus Torvalds 已提交
5625

5626
	tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
5627
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5628
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5629 5630 5631 5632 5633 5634 5635 5636 5637 5638

	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)"
		 */
5639 5640
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5641 5642 5643 5644
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
5645
			     tcp_time_stamp(tp))) {
5646
			NET_INC_STATS(sock_net(sk),
5647
					LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680
			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..."
		 */

5681
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5682

5683
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
5684
		tcp_ack(sk, skb, FLAG_SLOWPATH);
L
Linus Torvalds 已提交
5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711

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

5712 5713
		if (tcp_is_sack(tp) && sysctl_tcp_fack)
			tcp_enable_fack(tp);
L
Linus Torvalds 已提交
5714

J
John Heffner 已提交
5715
		tcp_mtup_init(sk);
5716
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5717 5718 5719 5720 5721 5722
		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;
5723

R
Ralf Baechle 已提交
5724
		smp_mb();
L
Linus Torvalds 已提交
5725

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

5728 5729
		fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
				tcp_rcv_fastopen_synack(sk, skb, &foc);
5730

5731 5732 5733 5734 5735 5736
		if (!sock_flag(sk, SOCK_DEAD)) {
			sk->sk_state_change(sk);
			sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
		}
		if (fastopen_fail)
			return -1;
5737 5738 5739
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5740 5741 5742 5743 5744 5745 5746
			/* 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
			 */
5747 5748
			inet_csk_schedule_ack(sk);
			tcp_enter_quickack_mode(sk);
5749 5750
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5751 5752

discard:
5753
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773
			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. */
5774
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5775
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794
		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;
5795
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5796 5797 5798 5799 5800 5801 5802 5803 5804
		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;

5805
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5806

J
John Heffner 已提交
5807
		tcp_mtup_init(sk);
5808
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5809 5810 5811 5812 5813
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5814 5815 5816
		 * 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 已提交
5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845
		 *
		 * 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
5846
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5847 5848 5849
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5850

5851
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5852 5853
{
	struct tcp_sock *tp = tcp_sk(sk);
5854
	struct inet_connection_sock *icsk = inet_csk(sk);
5855
	const struct tcphdr *th = tcp_hdr(skb);
5856
	struct request_sock *req;
L
Linus Torvalds 已提交
5857
	int queued = 0;
5858
	bool acceptable;
L
Linus Torvalds 已提交
5859 5860 5861 5862 5863 5864

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5865
		if (th->ack)
L
Linus Torvalds 已提交
5866 5867
			return 1;

S
Stephen Hemminger 已提交
5868
		if (th->rst)
L
Linus Torvalds 已提交
5869 5870
			goto discard;

S
Stephen Hemminger 已提交
5871
		if (th->syn) {
E
Eric Dumazet 已提交
5872 5873
			if (th->fin)
				goto discard;
5874 5875 5876 5877 5878 5879
			/* It is possible that we process SYN packets from backlog,
			 * so we need to make sure to disable BH right there.
			 */
			local_bh_disable();
			acceptable = icsk->icsk_af_ops->conn_request(sk, skb) >= 0;
			local_bh_enable();
L
Linus Torvalds 已提交
5880

5881 5882
			if (!acceptable)
				return 1;
5883
			consume_skb(skb);
5884
			return 0;
L
Linus Torvalds 已提交
5885 5886 5887 5888
		}
		goto discard;

	case TCP_SYN_SENT:
5889
		tp->rx_opt.saw_tstamp = 0;
5890
		tcp_mstamp_refresh(tp);
5891
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
5892 5893 5894 5895 5896 5897
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5898
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5899 5900 5901
		return 0;
	}

5902
	tcp_mstamp_refresh(tp);
5903
	tp->rx_opt.saw_tstamp = 0;
5904
	req = tp->fastopen_rsk;
5905
	if (req) {
5906
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
5907 5908
		    sk->sk_state != TCP_FIN_WAIT1);

5909
		if (!tcp_check_req(sk, skb, req, true))
5910
			goto discard;
5911
	}
5912

5913
	if (!th->ack && !th->rst && !th->syn)
5914 5915
		goto discard;

5916
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
5917
		return 0;
L
Linus Torvalds 已提交
5918 5919

	/* step 5: check the ACK field */
5920 5921
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT |
5922
				      FLAG_NO_CHALLENGE_ACK) > 0;
5923

5924 5925 5926 5927 5928 5929
	if (!acceptable) {
		if (sk->sk_state == TCP_SYN_RECV)
			return 1;	/* send one RST */
		tcp_send_challenge_ack(sk, skb);
		goto discard;
	}
5930 5931
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
Y
Yuchung Cheng 已提交
5932 5933 5934
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

5935 5936 5937 5938
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
5939
			inet_csk(sk)->icsk_retransmits = 0;
5940 5941 5942 5943
			reqsk_fastopen_remove(sk, req, false);
		} else {
			/* Make sure socket is routed, for correct metrics. */
			icsk->icsk_af_ops->rebuild_header(sk);
5944
			tcp_call_bpf(sk, BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB);
5945 5946 5947 5948
			tcp_init_congestion_control(sk);

			tcp_mtup_init(sk);
			tp->copied_seq = tp->rcv_nxt;
E
Eric Dumazet 已提交
5949
			tcp_init_buffer_space(sk);
5950 5951 5952 5953
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
5954

5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976
		/* 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.
5977
			 */
5978 5979 5980
			tcp_rearm_rto(sk);
		} else
			tcp_init_metrics(sk);
L
Linus Torvalds 已提交
5981

5982 5983
		if (!inet_csk(sk)->icsk_ca_ops->cong_control)
			tcp_update_pacing_rate(sk);
5984

5985
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
5986
		tp->lsndtime = tcp_jiffies32;
5987 5988

		tcp_initialize_rcv_mss(sk);
5989
		tcp_fast_path_on(tp);
5990 5991
		break;

5992 5993 5994
	case TCP_FIN_WAIT1: {
		int tmo;

5995 5996 5997 5998 5999
		/* 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.
		 */
6000
		if (req) {
6001 6002 6003 6004
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
6005 6006
		if (tp->snd_una != tp->write_seq)
			break;
6007

6008 6009
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
6010

6011
		sk_dst_confirm(sk);
6012

6013 6014 6015 6016 6017
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
6018

6019 6020 6021 6022 6023 6024 6025 6026 6027
		if (tp->linger2 < 0) {
			tcp_done(sk);
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
			return 1;
		}
		if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
		    after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
			/* Receive out of order FIN after close() */
			if (tp->syn_fastopen && th->fin)
6028
				tcp_fastopen_active_disable(sk);
6029
			tcp_done(sk);
6030
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047
			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;
6048 6049
		}
		break;
6050
	}
L
Linus Torvalds 已提交
6051

6052 6053 6054 6055 6056 6057
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
6058

6059 6060 6061 6062 6063
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
6064
		}
6065
		break;
6066
	}
L
Linus Torvalds 已提交
6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080

	/* 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,
6081
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
6082 6083 6084 6085 6086
		 * 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)) {
6087
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
6088 6089 6090 6091 6092
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
6093
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
6094 6095 6096 6097 6098 6099 6100
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6101
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6102 6103 6104
		tcp_ack_snd_check(sk);
	}

6105
	if (!queued) {
L
Linus Torvalds 已提交
6106
discard:
6107
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
6108 6109 6110 6111
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6112 6113 6114 6115 6116 6117

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)
6118 6119
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6120 6121
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6122 6123
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6124
#endif
O
Octavian Purdila 已提交
6125 6126
}

6127 6128 6129 6130 6131
/* 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 已提交
6132
 * TCP ECN negotiation.
6133 6134
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6135 6136 6137
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6138 6139 6140
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6141 6142
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6143 6144 6145 6146
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6147
	bool ect, ecn_ok;
6148
	u32 ecn_ok_dst;
6149 6150 6151 6152 6153

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6154 6155
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6156

6157
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
6158 6159
	    (ecn_ok_dst & DST_FEATURE_ECN_CA) ||
	    tcp_bpf_ca_needs_ecn((struct sock *)req))
6160 6161 6162
		inet_rsk(req)->ecn_ok = 1;
}

6163 6164 6165 6166 6167 6168
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);

6169
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6170 6171 6172
	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;
6173
	tcp_rsk(req)->snt_synack = tcp_clock_us();
6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187
	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 已提交
6188
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6189 6190
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6191
{
6192 6193
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6194 6195 6196 6197 6198

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

		kmemcheck_annotate_bitfield(ireq, flags);
E
Eric Dumazet 已提交
6199
		ireq->ireq_opt = NULL;
6200 6201 6202
#if IS_ENABLED(CONFIG_IPV6)
		ireq->pktopts = NULL;
#endif
E
Eric Dumazet 已提交
6203 6204 6205
		atomic64_set(&ireq->ir_cookie, 0);
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6206
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6207 6208 6209 6210 6211 6212
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6213 6214 6215
/*
 * Return true if a syncookie should be sent
 */
6216
static bool tcp_syn_flood_action(const struct sock *sk,
6217 6218 6219
				 const struct sk_buff *skb,
				 const char *proto)
{
6220
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6221 6222
	const char *msg = "Dropping request";
	bool want_cookie = false;
6223
	struct net *net = sock_net(sk);
6224 6225

#ifdef CONFIG_SYN_COOKIES
6226
	if (net->ipv4.sysctl_tcp_syncookies) {
6227 6228
		msg = "Sending cookies";
		want_cookie = true;
6229
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
6230 6231
	} else
#endif
6232
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
6233

6234
	if (!queue->synflood_warned &&
6235
	    net->ipv4.sysctl_tcp_syncookies != 2 &&
6236
	    xchg(&queue->synflood_warned, 1) == 0)
6237 6238
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6239

6240 6241 6242
	return want_cookie;
}

6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259
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 已提交
6260 6261 6262 6263
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)
{
6264 6265
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6266 6267
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6268
	struct net *net = sock_net(sk);
6269 6270 6271
	struct sock *fastopen_sk = NULL;
	struct request_sock *req;
	bool want_cookie = false;
6272
	struct dst_entry *dst;
O
Octavian Purdila 已提交
6273 6274 6275 6276 6277 6278
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
6279
	if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
O
Octavian Purdila 已提交
6280 6281 6282 6283 6284 6285
	     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;
	}

6286
	if (sk_acceptq_is_full(sk)) {
6287
		NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
O
Octavian Purdila 已提交
6288 6289 6290
		goto drop;
	}

6291
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6292 6293 6294 6295
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;
6296
	tcp_rsk(req)->ts_off = 0;
O
Octavian Purdila 已提交
6297 6298 6299 6300

	tcp_clear_options(&tmp_opt);
	tmp_opt.mss_clamp = af_ops->mss_clamp;
	tmp_opt.user_mss  = tp->rx_opt.user_mss;
6301 6302
	tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0,
			  want_cookie ? NULL : &foc);
O
Octavian Purdila 已提交
6303 6304 6305 6306 6307 6308

	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);
6309
	inet_rsk(req)->no_srccheck = inet_sk(sk)->transparent;
O
Octavian Purdila 已提交
6310

6311
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6312
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6313

O
Octavian Purdila 已提交
6314 6315 6316 6317 6318
	af_ops->init_req(req, sk, skb);

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

6319
	if (tmp_opt.tstamp_ok)
6320
		tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);
6321

6322 6323 6324 6325
	dst = af_ops->route_req(sk, &fl, req);
	if (!dst)
		goto drop_and_free;

6326
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6327
		/* Kill the following clause, if you dislike this way. */
6328 6329 6330 6331
		if (!net->ipv4.sysctl_tcp_syncookies &&
		    (net->ipv4.sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
		     (net->ipv4.sysctl_max_syn_backlog >> 2)) &&
		    !tcp_peer_is_proven(req, dst)) {
O
Octavian Purdila 已提交
6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343
			/* 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;
		}

6344
		isn = af_ops->init_seq(skb);
O
Octavian Purdila 已提交
6345 6346
	}

6347 6348 6349 6350 6351 6352 6353 6354 6355
	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 已提交
6356
	tcp_rsk(req)->snt_isn = isn;
6357
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6358
	tcp_openreq_init_rwin(req, sk, dst);
6359 6360
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6361
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc);
6362
	}
6363
	if (fastopen_sk) {
6364
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6365
				    &foc, TCP_SYNACK_FASTOPEN);
6366 6367 6368 6369
		/* 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);
6370 6371
		sock_put(fastopen_sk);
	} else {
6372
		tcp_rsk(req)->tfo_listener = false;
6373
		if (!want_cookie)
6374 6375
			inet_csk_reqsk_queue_hash_add(sk, req,
				tcp_timeout_init((struct sock *)req));
6376 6377 6378
		af_ops->send_synack(sk, dst, &fl, req, &foc,
				    !want_cookie ? TCP_SYNACK_NORMAL :
						   TCP_SYNACK_COOKIE);
6379 6380 6381 6382
		if (want_cookie) {
			reqsk_free(req);
			return 0;
		}
O
Octavian Purdila 已提交
6383
	}
6384
	reqsk_put(req);
O
Octavian Purdila 已提交
6385 6386 6387 6388 6389 6390 6391
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
6392
	tcp_listendrop(sk);
O
Octavian Purdila 已提交
6393 6394 6395
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);